R0J0hound's Forum Posts

  • You can do it with a sprite that has a hotspot at it's left. Then you can position it to (x0,y0), set it's angle toward (x1,y1) and set it's width to distance(x0,y0,x1,y1). The height of the sprite is the thickness of the line.

    An example that does this is here:

    Another idea is to use the canvas plugin which has an action to draw a line.

  • Those things can be done by adding some conditions to check if lives=0 and such.

    Look at this tutorial, it will help you get the concept down.

    https://www.scirra.com/tutorials/37/beg ... onstruct-2

  • Your formula is wrong. You have this:

    Self.iniy-JumpStrengh_green*(time-Self.time)+Gravity_green*(time-Self.time)^2[/code:19hjq2f2]

You forgot the 0.5*.
[code:19hjq2f2]Self.iniy-JumpStrengh_green*(time-Self.time)+0.5*Gravity_green*(time-Self.time)^2[/code:19hjq2f2]

[code:19hjq2f2]y = y_initial + y_velocity_initial*time + 0.5*acceleration*time^2[/code:19hjq2f2]

After that it will still differ in height with the platform behavior, a little.  Yours will give the same jump height regardless of the framerate, but the platform behavior will vary a little.

This is basically how the platform behavior does the y motion:
every tick:
--- add gravity*dt to vy
--- set y to self.y + vy*dt

In order for it to be truly framerate independent it would need an extra term:
every tick:
--- add gravity*dt to vy
--- set y to self.y + vy*dt + 0.5*gravity*dt^2

It's not as simple a change as that when I looked in the platform behavior's source, but that's the general idea.

  • It probably can, since it just corrects the object's positions when they do overlap.

  • This topic has a few ideas

  • Try Construct 3

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

    Try Now Construct 3 users don't see these ads

  • At any given moment a object has a position (x,y) and a velocity (vx,vy). Using a formula like rate*time=distance, you can guess what an object's position in the future will be: (x+vx*t, y+vy*t), where t is the number of seconds in the future. If the object's velocity does not change then the guess will be 100% correct.

    So checking in the future just means to move the objects to where they will be, check for overlaps, and then move them back.

    For formations each object has it's own goal, which is pretty straightforward.

    Collision response is what will allow units to not walk over each other or not walk over the walls.

    For units this is done by finding the distance between each pair of units and just move each away from each other if they are two close.

    For units against walls you find the distance to each side of the wall and use the closest side to push away from. This distance calculation is the distance from a line to a point, which is different from the distance from a point to a point.

    /examples26/simple_pathfind2.capx

    https://www.dropbox.com/s/lxzh1lizunezw ... .capx?dl=1

  • leandronw

    Webgl speed is not so good with this, since it has to copy the texture to vram every time it changes (internal issue).

    Different size circles is trivial, but for different color circles you mainly have these options:

    1. Use this plugin to draw the circles using any color. You'd be only drawing to this so if you clear it to transparent you can have anything underneath show just fine.

    2. A second option could be to use the paster object which is similar to the canvas object, but was made with webgl in mind. It doesn't draw circles but it does allow making any color. So you could do some clever things with blend modes, a circle sprite, and the paste action.

    3. You could use a white circle sprite with the tint effect. This by far would be the simplest.

    4. As a last resort you could just use a lot of animation frames with different colors.

  • There are two plugins for that here:

    One pay for, one free. look in their topics for use.

  • I've done this before by using a large sprite with the dragDrop behavior to move it, as well as the pin behavior for the other sprites to attach them.

    Then also one or two events to limit how far you can drag the sprite. Something like

    Sprite x < 0

    --- set sprite x to 0

    Sprite x > 640

    --- set sprite x to 640

  • Probably not exactly what you want but you can make multi-line comments by using shift-enter.

  • You can do something more robust than that, which just tests if the point touches the object.

    Like pick all the objects in a radius:

    on touch

    for each sprite

    system compare: distance(sprite.x, sprite.y, touch.x, touch.y) < 50

    --- do something

    or just the closest in a radius:

    on touch

    pick sprite closest to (touch.x, touch.y)

    system compare: distance(sprite.x, sprite.y, touch.x, touch.y) < 50

    --- do something

    Another idea could be to position a circle to the touch location and test what overlaps it.

  • The player doesn't utilize the solid behavior, it's only used for the line of sight.

    It could be re-worked to utilize astar so the shortest distance is used every time, but it would have to be astar done from scratch, since it wouldn't be grid based.

    If smaller objects are passed through you could roll your own LOS with events with that in mind, or probably more appropriate implement some kind of collision response to push objects out of each other. Avoiding moving objects can be done by looking at where the objects will be a little in the future and if they are colliding adjust the current angle of motion so it won't.

  • You possibly could get away with doing something much simpler for a game like that. Most of the moves have a line of sight to the players and the obstacles look to be mainly just rectangles with no crevices.

    You could use line of sight and just move forward if the player has a clear view. If there is an obstacle in the way then just pick the furthest corner of the building that the player can see an move toward that, then they can continue to the goal as they round the corner. This should be able to work with many buildings, but the beauty of it is the player only addresses obstacles as they see them.

    It's simple and fast but can fail if you have alleyways instead of just buildings. I could be acceptable though, as I've played games where I had to help the player pick a better path. But now that I think of it you can mark the alleys in the editor so that the player can know to only go inside if the goal is in there. In a similar way you could mark long winding corridors I think, and just handle that in a unique way.

    EDIT:

    https://dl.dropboxusercontent.com/u/542 ... hfind.capx

  • An action shouldn't be needed, the textures are told to free in the appropriate places. I don't know why they aren't. I'll look into it more later.

  • 1.

    Probably a grid based approach. I might use tiled and a parser to read the iso grid, but that may be an overkill. Or I might just place objects in the editor or make an editor so I also get sorting. The level design is just data and it should be possible to convert it to any format that's needed to use.

    2.

    The isometric view is just smoke and mirrors, I'd use a 2d array with the heightmap info for the grid, and compare the projectile isometric positions with that.

    3.

    I've devised complicated sorting before to find what order to draw the object's based on their isometric size and position, but it's not very fast as i boils down to being a topographical sort. For most isometric games it's acceptable to do sorting like this:

    For each sprite sorted by 10000*isoX+100*isoY+isoZ

    ---- send to front

    Well not exactly, you may need to change the positions around. Basically it reads that more y will be infront of more z and more x is infront of everything.

    4.

    I'd store the fog in an array like the heightmap and set the units to be invisible if they were on grids with fog.