R0J0hound's Forum Posts

  • 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:

  • 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.

  • Instead of a loop just compare the object count.

  • You can look here for stats on it:

    http://webglstats.com/

    For computers that support webgl 100% of them support 2048, hence that recommended limit. Looking at the graph you can use bigger textures but it won't work on all computers.

    On a side note if you don't use webgl, eg turn webgl to off in the project settings you can have much larger images, but I couldn't find any info on the upper limits. The limits seem to be based on if there's enough video memory and if you run into graphics card limits, it just varies on how the canvas is implemented in the browser.

  • Here's a bit of info about the .asJson expression for the canvas:

    And here's how to do it:

    global number pixelCount = 0

    global number percentClear = 0

    every 1.0 seconds

    --- array: load from canvas.asJSON

    --- set pixelCount to 0

    ------ repeat canvas.width*canvas.height times

    ------ Array at (0,0,loopindex*4+3) = 0

    --------- add 1 to pixelCount

    --- set percentClear to pixelCount/canvas.width*canvas.height

    In the array comparison instead of checking if the alpha is 0 you could for instance use <128 to count any pixel less than 50% trasparent.

  • striimix

    I can't reproduce it. Can you provide a capx that gives that error?

    spongehammer

    That's just a case of over aggressive sleeping. Disabling sleeping fixes it. Although it is odd that size has anything to do with it.

    Prominent

    You shouldn't need to use dt anywhere. A fixed timestep of 1/30 is the timestep used per frame. So if the game is running at 60fps then after 60 frames the physics will be 2 seconds along compared to the actual 1 second.

    You can specify a variable timestep but that isn't so good with physics, so a fixed timestep is recommended. The drawback is the physics can run faster/slower depending on the screen refresh rate, aka it's not framerate independent. That said you could detect the fps of the game when it starts and set the timestep based on that.

  • One thing you could try is make the player lighter and/or increase the iterations of the simulation. Also it would just pull apart if the platform behavior is used.

  • Try Construct 3

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

    Try Now Construct 3 users don't see these ads

  • Yeah you'd want to use a joint to attach the player to the rope. The main issue you'll run into is the platform behavior and physics clash so it may be simpler to just move the player around with just physics.

  • Look at "go faster" on the arcade for one idea. It even comes with a capx you can look at. The auto runner template that comes with C2 is another.

    Basically whatever kind of level generation you can implement can then have a player inserted into with even the most basic movement.

  • Here's one way. Find the angle from the point to all the corners of the sprite and then only keep the more clockwise and counter-clockwise angle. The difference of the angles is then the subtended angle.