More in-depth functions?

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.

To draw a rect? Draw its outline, and then go to its center, and fill.

Welcome to Snap!!

:slight_smile: 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).

You have a bunch of questions in there. Starting with the easy one, the way we make the bricks in a brick wall exercise in our curriculum is

  1. Turn on "Flat line ends" either from the gear menu or from the getter/setter library blocks. (There's a primitive for this in 5.0, coming soon.)
  2. Set the pen size very wide, like 20.
  3. Then just MOVE,

More generally, if there's something in HTML5 Canvas that isn't primitive in Snap!, you can use the JavaScript Function block to roll your own. Given that, providing every primitive JS library feature as a primitive block is low on our priority list. You can draw your ellipses that way, for example.

I don't see why you think this question about graphics is especially connected with OOP. What we do that is connected with OOP is provide true inheritance of sprite properties, so if you clone a sprite, and then change the definition of a sprite-local block in the parent, the children automatically see that change. See the details in the reference manual.

Even more important, we provide lexically scoped first class procedures, and that means you can create your own object hierarchy using closures. That's in the Reference Manual also.

P.S. Check out the WARP block, to answer another of your questions.

Different languages prioritise different things
You might find GP more suitable for some of your projects when moving on from Scratch
Not as well supported as Snap but worth checking out

GP would probably be better due to it being a little more like Processing than Snap! as well, so less of a learning curve