R0J0hound's Recent Forum Activity

  • 1.

    You could either just nudge vx and vy around when bouncing. For example for a horizontal bounce:

    set vx to -self.vx

    add random(-1,1) to vy

    A vertical bounce can be done similarly.

    Or you can actually nedge the angle. To do that takes two steps. First calculate speed and angle from vx and vy, then convert it back to vx and vy from that after nudging the angle.

    ang = angle(0,0,ball.vx,ball,vy)

    speed = distance(0,0,ball.vx,ball,vy)

    vx = speed * cos(ang+random(-2,2))

    vx = speed * sin(ang+random(-2,2))

    2.

    For changing the angle depending on where on the paddle was hit you could just add the horizontal distance between the ball and paddle when hitting the top of the paddle (event 16). So basically:

    add (ball.x-paddle.x) to vx

    You could multiply it by 0.5 or something to make it more subtle.

    For actual round objects you'd need something better for contact normal detection.

    This may work, you may want to add 1 or so to the radius check.

    local number NormalAngle=0

For each roundWall
system compare: distance(roundWall.x,roundWall.y,ball.x,ball.y) <= ball.radius+roundWall.radius
--- set normalAngle to angle(roundWall.x,roundWall.y,ball.x,ball.y)[/code:1dvz1wet]

Basically to bounce you need to know the normal of the surface hit and then you can bounce using either the math event 19 in your capx or with the normal angle using that formula from granpa:
set angleOfMotion to 2*normalAngle-ball.AngleOfMotion+180

  • 1. It's for organization purposes and probably has no impact on performance at all.

    2. Less things to draw would speed up rendering.

    3. Whether the music is one minute long or on hour has no impact on performance, only loading time of the webpage.

    4. Basically. The pin behavior has more features than just that, such as setting angle. And there are cases where doing it with events is more useful.

    5. Any value below 0.0166 (1/60) with every n seconds will be the same as "every tick". Other than that just use the one that makes sense for what you're doing.

    6. As I understand it CocoonJS takes some shortcuts to make rendering faster at the expense of unsupported edge cases, whereas IntelXdk supports everything C2 supports. Making it faster is unknown to me, I do not use it.

    7. Don't know. I'm guessing it's where you're placing them. Else can't be used after a trigger is one reason that comes to mind.

    8. Why not just increase the layout size? Margins are just extra space around the layout for editing purposes.

  • —

    Just an idea. You could spread out the processor load further by doing something like this: instead of updating all the enemies every time interval just update half one interval and the other half the next. Or you could spread it further if needed. That would reduce the amount of stalling when looping over a large number of enemies.

  • The way to join two objects together like that is to give them the same collision group and add two joints, a pivot joint and a gear joint with a ration of 1.

  • Here's the topic where go faster's approach was devised.

    In the linked post there's a capx. Events 6-9 move the tiles. The recalc variable is just a flag to tell the tile to re-lookup if it's a wall or not in it's new position. The most complicated bit is how the level is generated. It uses a array of random values and then does some interpolation with those values so that any position can be checked on the layout and always be able to get the same value. There's a perlin noise plugin that would greatly simply this.

  • Basen

    I think you can improve it by increasing the the space iterations perhaps.

  • Doing it with just events is simple enough. Give the ball two variables vx and vy for the x and y velocity. Motion is done by appling the formula speed*time=distance. You can also set it from a speed and direction if you so please with a simple convertion from polar coordinates to rectangular: vx=speed*cos(direction) and vy=speed*sin(direction).

    Then instead of using a plugin or behavior, just check the position against the four walls and bounce. See attached capx.

    That's just for outside walls. For inside walls you'll need push the ball out of the wall before using overlaps at offset to bounce. In the following link I implemented the push out with just events and it works well enough. If you make the ball too fast so that the jump of positions completely misses the wall then this still could fail.

    To solve passing through walls you'll want to check the positions in between or do a raycast.

    For the first you could do the same as this bouncing laser example:

  • Try Construct 3

    Develop games in your browser. Powerful, performant & highly capable.

    Try Now Construct 3 users don't see these ads

  • In the image editor there's a button on the toolbar where you can specify the "export file format" where png-8 is one of the options. As far as actual memory usage by your game, it doesn't matter what file format is used because when an image is loaded it's loaded as a uncompressed 32bit image in video memory.

    The best that could be done if the game designer was happy about a loss of color depth would be for c2 to use compressed textures in webgl. The issue is support of it. According to the stats here:

    http://webglstats.com/

    The most supported texture compression format is s3tc and even then it's only supported by about 75% of devices.

    s3tc gives a 4:1 compression at the loss of the amount of colors.

    http://en.wikipedia.org/wiki/S3_Texture ... Comparison

  • I can't open the capx now, but since you say breakout I'm guessing you'll only have unrotated rectangles that the ball bounces against.

    One way to do it is to move the ball backwards when it collides with a block, which can be done with the push out of solid action of custom movement. Then you can use dom's idea to find what direction walls are.

    Bouncing off horizontal and vertical walls is just a matter of reversing the y or x velocity of the object. You can also calculate the bounce angle if you know the angle of the wall hit but I don't recall the formula off hand.

  • One approach I've used in the past is create enough tiles to cover the screen and create no more. I then used a large array to store the generated level and hide and disable solid for eny empty tiles onscreen. When you scroll around as normal the tiles that move offscreen are then moved to the other side and updated from the array.

    Another idea could be to use the tilemap object if it's acceptable to have edges.

  • Good catch with the parenthesis, multiplication and division are done left to right. I think I learned about that in basic algebra.

    It's slow because between the .asJSON expression and loading it into an array it's a slow operation. I haven't really seen a way to make it faster.

    There are two asJSON expressions because all objects have that expression to get a json version of their state. For canvas object they both do the same thing.

  • Instead of loopindex I used Sprite.Count-1 to set the animation frame. I could just as well have used sprite.iid though. Would that work? I don't see the need for loopindex.