You can correct the slight inaccuracies in a number of ways, the way I would use myself (am using in the game I'm currently designing anyway) is to populate an array of the layout with the X and Y values then move up and down the array index read then apply the appropriate value. I've found this to be the best way where accuracy is important and the game is quite complicated.

But you're new (welcome aboard) so I'll spare you that and show you an easier method which you can use to nail things into position via the bullet behaviour. It's basically the same method as in my earlier post but with a couple of extra steps.

Firstly your object I'll call it "block" needs an instance variable so create one we'll call it OldY and make it a number.

Then we need to give the variable a value so we do this at the start of the layout:

System }

On start of layout }

For each "block" } (add the action) Set OldY to block.Y

// this assigns the current Y value to all instances of the block in the level so you have a starting height.

Then we skip to the movement.

As before

Apply bullet behaviour to block if you haven't already.

Then:

Set bullet speed to 100

Set angle to 90 deg

Wait 0.5s

Set bullet speed to 0.

//Now the extra steps.

Set block Y to block.OldY+50

// This sets the new position of the block Y value to an absolute value of its starting position plus the 50 pixels vertical offset that you want. ie nails it into place

Add 50 to block.OldY

// Sets the "starting value" of block.Y to its new starting point ie 50 ppx below it's original starting point so if the block needs to move down again it adds another 50 to the correct value.

So what you're doing on your move is sending it downwards at 100px per second for half a second so it travels 50 pixels before it stops approximately in place then once stopped you shunt it into position the final 2-3 px so it finishes exactly 50 px below it's starting point.

(If horizontal values are critical just do the same with different angles and another instance var called OldX).

It's a bit more effort to set up but very easy to use once it is, you could further improve it by putting the movement part into a function and simply calling the function each time a block needs to make that movement.

I'm a firm believer in the use of bullet behaviour when you want things to move accurately.

Apply bullet behaviour.

Set bullet speed to 100

Set angle to 90 deg

Wait 0.5s

set bullet speed to 0.

This gives a nice smooth movement and is very, very customisable eg you can have a sprite accelerate to a certain speed then decelerate smoothly into position.

Thanks Blackhornet I knew it would be something simple like that jus didn't know what or where.

Have I missed something blindingly obvious, but I can't find a way to include an "Exit" button which will close the game??

Multiply by 10 -> SAVE -> LOAD -> divide by 10 -> display.

Iclone is 3D but I use it with the inbuilt cell shader to export PNG sequences 8FPS, Crazy Talk is their dedicated 2d animation tool and probably more like you're after.

Spriter and two "reallusion" products Crazy Talk animator and iclone are the best I've found

int() does the job too.

I'm going to ask the obvious but have you adjusted the collision polygons to suit the points of collision you require or is your game using the default Polys (which iirc tend to be very tight around the opaque parts of transparent png's).

HTML5 is javascript , and it gets interpreted (converted) into native code ( I think , correct me if I'm wrong ) in the browser , WHILE running the application , that's called an JIT compiler (Just In Time) , and that's why it's slower than native C , aka NodeWebkit ...

I hope this shed a bit of light on Javascript manners

Moreso , if you want to go more into details ,

Subscribe to Construct videos now

Almost correct, interpreting it would mean running the JS without compiling it into native code this is the more traditional slower "web" method of running JS.

The V8 engine (Chrome) actually compiles the JS to native machine code X86-64, ARM etc which has a number of advantages eg it can be further optimised at runtime, be cached etc etc It's almost as fast as native because it is ultimately native there's a loss of time in the initial conversion one must assume. Thing is although its been out in the wild a few years now the V8 engine is imo very much a work in progress I expect to see further significant improvements in time.

On trigger event eg every X seconds:

System create object at int(random(Z,(LayoutWidth-Z)),Y)

Where Y is the Y "height" at which you want it to spawn.

Z is half the width in pixels of the object you want to create to ensure the spawned object always fits on screen.

You can make a button transparent via its CSS properties like this:

<img src="http://s14.postimg.org/twwkdyxdt/button.jpg" border="0" />