R0J0hound's Recent Forum Activity

  • I guess the basic logic would be this. With no easing. 

    var startX=0

on touch 0 start
-- set startX to touch.xat(0)

has touch 0
-- sprite: set angle to touch.xat(0)-startX

on touch end
--sprite: set angle to 0

    A simple way to add easing is to set a target variable which the actual angle is lerped to. Here i used curAngle as one more layer over the sprite's angle to handle the jump from 0 to 360 in a graceful way. 

    var startX=0
var curAng=0
var targetAng=0

on touch 0 start
-- set startX to touch.xat(0)

has touch 0
-- set targetAng to touch.xat(0)-startX

on touch end
--set targetAng to 0

every tick
-- set curAng to lerp(curAng, targetAng, exp(-20*dt))
-- sprite: set angle to curAngle

    If you wanted to limit the rotation of the wheel you could just clamp() curAng.

    Now using lerp() in that way is ok for an ease out, but it will cause jumps if you change the target angle drastically.

    Lately I've found a lot of use for damped springs to do stuff like this. Here it uses the x motion of touch to drive the spring. The result is pretty smooth and even some overshoot when turning back to the rest position (although that can be tuned by changing the numbers in the spring event).

    dropbox.com/scl/fi/15r86pr9k1k6xvyjxul9y/steering_wheel_horz_touch.capx

    Also it's trivial to do the rotation based on how the touch drags around the wheel instead of just x. It's a bit more intuitive imo.

    dropbox.com/scl/fi/15r86pr9k1k6xvyjxul9y/steering_wheel_horz_touch.capx

  • You can check this by putting a sprite with z=0 next to the cube.

    The bottom of the cube has a z of 0 and the top will have a z of 100

  • move the knife to the bg layer

    edit:

    wait, you want it above the face but under the texture.

    Here's one way to do it. 

    layer 1, Force_own_texture=true
-- face, blend=destination_in
-- bee_texture
layer 0
-- knife
-- face

  • It doesn't provide any other info in the browser console about why it's invalid, or which json file is invalid?

    I did a quick skim comparing your json with the sdk example on github and nothing stands out as amiss. Btw if you put source code in code tags (Ctrl+\) it's a bit easier to read on the forum.

    If it doesn't provide any more info, then I'd try taking the example on the sdk, see if that loads, then try incrementally changing that into your effect to hopefully find the issue.

  • You can calculate the speed from the xy velocities with:

    Speed=distance(0,0,sprite.physics.velocityx,sprite.physics.velocityy)

    Then you can make a condition to check is speed>maxspeed, and if it is then set the velocity to

    sprite.physics.velocityx*maxspeed/speed ,sprite.physics.velocityy*maxspeed/speed

  • So... the OSM file format doesn't provide too much. With some fiddling you can parse out roads, building outlines, coastlines, etc...

    You'd have to infer bodies of water, or overlay it over some satellite imagery.

    dropbox.com/scl/fi/mmxnxbiinnwbk65lly8i0/osm_loader.capx

    You can even use ajax to query some websites to get an osm file from any lat/lon. However, what the games you referenced probably do is utilize something like this to get map/satellite imagery on the fly:

    developers.google.com/maps/documentation/maps-static/overview

    You do have to pay a subscription for such a thing.

    If you're happy with offline methods you could use something like this to get the satellite imagery, as well as the height or any 3d buildings directly from google earth. Although I will say the pipeline for using this is pretty poor and incomplete.

    github.com/retroplasma/earth-reverse-engineering/tree/master

    For example I took some satellite imagery and converted it to a textured heightmap to use with mesh distort.

    dropbox.com/scl/fi/7k4acehi6zp9yx45lxal8/island_orbit.c3p

  • At a glance OSM files are just xml files. Load the osm files into the xml plugin and you can get anything you need from that. You'll need to get familiar with xpaths to navigate the file.

    I was slightly curious so here's a start. Add an osm file to the files folder of your project, access the file with the ajax plugin, and finally load it into the xml plugin.

    One basic primitive in osm files are "nodes" which give lat/lons of points. Here's a way create a sprite at every node. Note that you need to adjust the lat/lon to convert them to reasonable xy positions on the layout. 

    xmin = float(XML.StringValue("/osm/bounds/@minlon"))
ymin = float(XML.StringValue("/osm/bounds/@minlat"))

start of layout
XML: for each node "osm/node"
-- create sprite at (float(XML.StringValue("./@lon"))-xmin)*3000, -(float(XML.StringValue("./@lat"))-ymin)*3000

    Another basic primitive are "ways" which are made up of a list of the ids of nodes. Basically, polylines. A way to handle those is to first add the nodes to an array, and use a dictionary to relate the node ids to the array indexes.

    Beyond that there are tags in the ways and nodes in the osm file that indicate if they are a river, road or whatnot, but I didn't see any obvious patterns. You'll want to refer to the osm file format perhaps.

    wiki.openstreetmap.org/wiki/OSM_XML

    You could go further to see if there are other things you can access from the file.

    If you want to access osm data dynamically from open maps on the fly then that's out of the scope of what i'm interested in. I just was getting the osm files in my tests by going to the openmaps website, navigating to where I wanted, and exported it.

  • Main issue I'm seeing is you're not reading the pixel from the right spot. The snapshot size won't be the same size as the drawingCanvas unless the window isn't resized or if the drawing canvas' resolution mode is set to fixed, and the resolution is the same size as the canvas.

    Anyways, a fix would be to convert the coordinates. Instead of 

    x = Mouse.x
y = mouse.y

    use: 

    x = Mouse.X*DrawingCanvas.SnapshotWidth/DrawingCanvas.Width
y = Mouse.Y*DrawingCanvas.SnapshotHeight/DrawingCanvas.Height

    or if the drawing canvas isn't positioned at the top left of the layout: 

    x = (Mouse.X-DrawingCanvas.BBoxLeft)*DrawingCanvas.SnapshotWidth/DrawingCanvas.Width
y = (Mouse.Y-DrawingCanvas.BboxTop)*DrawingCanvas.SnapshotHeight/DrawingCanvas.Height

    dropbox.com/scl/fi/c9zekz1ru5pzw6u26mxon/read_pixels.c3p

    EDIT:

    Looks like these three expressions are approximately the same. So you could just divide the mouse position by the pixelScale. The fact that all three aren't all the same is another c3 issue but shouldn't matter too much.

    DrawingCanvas.SnapshotWidth/DrawingCanvas.Width

    DrawingCanvas.SnapshotHieght/DrawingCanvas.Height

    1/DrawingCanvas.PixelScale

    Edit2:

    If you manually set the fixed resolution mode size, then don't use pixelScale.

  • More ideas.

    This one starts with a list of all the numbers and removes random ones one by one. For example 20 possibilities. 

    Var list=“”
Var n=0

Start of layout
Repeat 20 times
— add zeropad(loopindex,2) to list

Start of layout
For each sprite
— set n to int(random(len(list))/2)*2
— sprite: set frame to mid(list, n, 2)
— set list to left(list, n) & right(len(list)-2-n)

    This one just randomizes till all four numbers are different. 

    Var done = 1
Start of layout
While
Compare: done>0
— sprite: set animation frame to int(random(sprite.animationFrameCount))
— set done to 0
— add sprite(0).animationFrame = sprite(1).animationFrame to done
— add sprite(0).animationFrame = sprite(2).animationFrame to done
— add sprite(0).animationFrame = sprite(3).animationFrame to done
— add sprite(1).animationFrame = sprite(2).animationFrame to done
— add sprite(1).animationFrame = sprite(3).animationFrame to done
— add sprite(2).animationFrame = sprite(3).animationFrame to done

    Same as above in a cleaner way. 

    Var r0=0
Var r1=0
Var r2=0
Var r3=0

Start of layout
while
compare: (r0=r1 | r0=r2 | r0=r3 | r1=r2 | r1=r3 | r2=r3) = 1
— sprite: set frame to int(random(sprite.animationFrameCount))
— set r0 to sprite(0).animationFrame
— set r1 to sprite(1).animationFrame
— set r2 to sprite(2).animationFrame
— set r3 to sprite(3).animationFrame

    This one uses a tuned pseudo random number generator to generate random numbers without duplicates. This one was tuned to handle 10 possible frames, but it would work for any count by changing the right numbers. 

    Var r=0

Start of layout
— set r to int(random(1000))
— for each sprite
— — set r to (r*906+1866)%1000
— — sprite: set frame to r%10

    I’m sure there are other ways. Each have pros and cons.

    Edit:

    One more for good measure using an array. 

    Start of layout
-- array: set size to (0,1,1)
-- for each sprite
-- -- sprite: set frame to int(random(self.animationFrameCount-loopindex))
-- -- sprite: set frame to (loopindex>0 & Array.at(0)<=self.AnimationFrame)+self.AnimationFrame
-- -- sprite: set frame to (loopindex>1 & Array.at(1)<=self.AnimationFrame)+self.AnimationFrame
-- -- sprite: set frame to (loopindex>2 & Array.at(2)<=self.AnimationFrame)+self.AnimationFrame
-- -- array: push sprite.animationFrame
-- -- array: sort x axis

  • Try Construct 3

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

    Try Now Construct 3 users don't see these ads

  • I mean if you’re after alternative ways to flip cards, here’s a way with two instance variables: target and spin. 

    On card clicked
— card: set target to 180-self.target

Every tick
— card: set spin to lerp(self.spin, self.target, exp(-16*dt))
— card: set width to self.imageWidth*cos(self.spin)
— card: set animation to self.width>0?”back”:”front”

  • In c2 you can do shuffle by having another y in the array with a random value and use sort. Here is the solution I posted above modified to do that. 

     Start of layout
— array: set size to (sprite.frame count,2,1)

Start of layout
Repeat array.width times
— array: set at (loopindex,0) to random(1)
— array: set at (loopindex,1) to loopindex

Start of layout
— array: sort x

Start of layout
For each sprite
— sprite: set frame to array.at(loopindex,1)

    Now as an exercise you probably can reduce that to less events. One to populate a shuffled list of numbers, and one to set animation frames. You could use a text variable instead of the array if you wanted too.

  • If it works, it works and it seems to make sense to you so I say stick with it.