I'm brand new to snap, in fact, I just discovered it existed last month and decided to mess around with it looking around and reading the documentation and figuring out what things do. I've had years of experience in Scratch and I made a small game over the summer. I intended to recreate it in processing and got a bit stuck (irrelevant ik, but this is key to my full question).
The best way I learn is through visualization. If I thoroughly know one language and have several projects saved, and I c how one project is coded in another language, I c the similarities and can quickly grasp how the new language works.
I have some Java experience, a lot of Scratch experience, and enough processing experience. What I need is to c the various projects and games I've worked on in those, but done with this new Snap! language. One small flaw I noticed was that in both scratch and Snap! there is no "rect" or "ellipse" function built in. The reason this is crucial personally is that if you were to make a class called "wall" for a game, with variables and constructors which lead to a drawing function for a rectangle (a legit solid shape), it's virtually impossible to do so in scratch and Snap!.
Other forums indicate the reasoning for scratch not including some of the more complex Object Oriented Programming tools and ideas. I understand that scratch is marketed towards younger students and it needs to be as simple as possible, but Snap! to my knowledge was created for the complex nature of OOP and other complex ideas and tools. If that's the case, shouldn't there be tools (possibly included within libraries) which allow for solid-object functions which can be called inside a class?
I already tried making a block (in scratch) which takes 4 arguments (x, y, xSize, ySize), then draws a rectangle by:
(inside invisible sprite)
pen up;
go to (x), (y);
pen down;
repeat until (full shape reaches x2, y2 coordinates){
move (x) by xSize;
move (y) by 0.5;
move (x) by -xSize;
move (y) by 0.5;
}
Essentially drawing a solid object (the thinner the pen (thus the smaller the increment of y-movement needed to draw solid-looking shape)).
This seems easy enough but it failed (and the object actually animates its own drawing, doesn't just SHOW UP as a rectangle).
So having Snap! work similarly to how processing works would make things a bit easier. We already have the ability to draw sprites and move them freely, why not add a function which draws them using code.
Alas, being just like Processing is not one of our goals; if we want to be just like some other language, it's Scheme (God's programming language).