R0J0hound's Forum Posts

  • 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

  • Try Construct 3

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

    Try Now Construct 3 users don't see these ads

  • 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

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

  • I’m becoming more and more convinced that construct isn’t as simple to use as it appears.

    There are many solutions to that, each with their own set of things to be familiar with.

    The first approach I’d use is how would you do that in real life? What would the steps be?

    Probably: roll 4 dice, then look for two or more dice that are the same, and reroll the duplicates and check again. So roll, and reroll if there are duplicates.

    However picking seems to be hard to most, so is picking two separate instances at the same time.

    So you could put all the possibilities values in an array, shuffle that, and use that to set frames.

    Start of layout

    — array: set size to (sprite.frame count,1,1)

    Start of layout

    Repeat array.width times

    — array: set at loopindex to loopindex

    Start of layout

    — array: shuffle

    Start of layout

    For each sprite

    — sprite: set frame to array.at(loopindex)

  • One of the issues you’re encountering is the object’s blend mode and the “drawing blend mode” are two different things. You’d want to set the drawing blend mode to destination-out before filling the ellipse, but you should leave the object’s blend mode as normal.

    So roughly this would create a canvas over the sprite, draw the sprite to the canvas, and erase a circle out of it. What you do with the sprite after is up to you, but I destroyed it here. 

    On clicked sprite
— create canvas at sprite position
— set canvas size to sprite size
— canvas: paste sprite
— sprite: destroy
— canvas: set drawing blend mode to destination-out
— canvas: fill ellipse at mouse

    The other way could be to use circle sprites with the destination-out blend on layers with “force own texture”.

    You said each sprite is on its own layer, so just make sure each of those layers has “force own texture” enabled. Then erasing holes would be as simple as: 

    On sprite clicked
— create: circleSprite on layer: sprite.layer at mouse.x, mouse.y
— circleSprite: set blend mode to destination-out

  • TestOverlapSolid just returns true or false. It doesn’t provide any info about what instance it was overlapping.

    To know the instance you’d need to use testOverlap(a,b) instead. But for that you’d need a list of instances with the solid behavior to loop over.

    One way to get that list is to access an object type that has the solid behavior, and get a list of all instances with solid like so:

    let inst = runtime.objects.Sprite. getFirstInstance();

    let list = inst.behaviors.Solid.behavior. getAllInstances();

    That’s basically how you access behaviors according to the manual. It’s not too generic if you have to tell it a type that has the solid behavior. Also it needs an instance to exist to be able to access the list too.

    A generic way could be to have a function that loops over the types in runtime.objects, gets the first instance and if it has the solid behavior save that somewhere. A bit brute force but ideally it would only need to run once, so if it found the solid behavior it would save it. Worst case is you’d have no instances with the solid behavior so it would keep searching and failing to find it.

    Anyways with that you’d be able to get a list of the instances with the solid behavior, loop over them and use testOverlap() to see if they overlap. And if they do you could then compare inst.instVars or something. Or you could even access the solid behavior tags but that may be automatic.

    You could also try and utilize constructs collision cells. To do that you’d use runtime.collisions.getCollisionCandidates() but for that it needs an object type. To get those you could loop over the list of instances with the solid behavior and make a second list without duplicates of the object types.

    Anyways I’d argue that js is fairly easy to learn. However, the hard part is finding ways to access things from the engine. Some things are easy to access, some things have to be accessed in round about ways, and for some there’s no access at all.