R0J0hound's Recent Forum Activity

  • For the math, give the sprite two variables:

    velocityX and velocityY

    Then make this event:

    Always:

    --- sprite: add 100*timedelta to veloctyY

    --- sprite: set x to sprite.x+sprite('velocityX')*timedelta

    --- sprite: set y to sprite.y+sprite('velocityY')*timedelta

    The 100 is the gravity which you can adjust.

  • akkthedev

    You can access the pixels, but that is the extent this plugin provides. Outside of that you'd have to find other means.

  • There isn't any program that does that currently.

    Most isometric games made in C2 don't use Tiled at all, they just turn on grid snapping and position sprites in C2's editor.

  • The wait is messing it up in this case. What it's doing is pushing the function call to the end of the event sheet, and what you want is the call done in place.

    When creating a new object this defines when it can be picked:

    and

    "pick by uid" is the exception as it works for any object that was created.

    For accessing new object's immediately from a function you should pass that object's uid. Then you can pick the object by uid in the function, and reverse it to pick a sprite from the sprite2.

    For ex:

    call "hasframechanged" (sprite2.uid)

    on function "hasframechanged"

    sprite2: pick with uid function.param(0)

    sprite: pick closest to (sprite2.x, sprite2.y)

    sprite: x = sprite2.x

    sprite.y = sprite2.y

    --- sprite: set ischanged to true

    AllanR

    The newly created object is added to the object list at the next toplevel event as per the links above.

  • The simplest would be to use multiple layers in tiled and edit the capx to get more than the first layer. For example you could have one layer define the collisions.

    To get it in the layout would need one to write a program to convert a tmx file to a C2 layout file and add it to your project.

  • Try Construct 3

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

    Try Now Construct 3 users don't see these ads

  • A simple way would be to create a bunch of bullets from the source object and set their angle to a random direction, also save that angle to a instance variable on each. Next you just move the objects and bounce them as they hit walls. Ideally you'd do it the same way as in that laser example. Now as soon as one of those objects collides with the other object, use that object's initial angle for the laser and delete everything else.

    Sending lots of lasers will use more cpu, this is true, but when it's the only solution atm there's not much you can do.

  • The simplest idea would be to send lots of lasers from one object and let them bounce until one hits the other object, then you can discard the rest.

  • They do something entirely different to what my capx does. My capx loads an isometric tmx file to sprites, and those plugins help with motion and such in isometric. I couldn't tell you more because I've never used them.

  • It just loads the tmx to a bunch of sprites. After that you can do whatever you like with them.

  • Juicy

    You could make you're own loader for isometric tiled files. You'll just need to use sprites instead of the tilemap object.

    Here's an example:

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

    The tiles are imported into the sprite's animation as a sprite strip, and the tmx file needs to be saved with csv encoding.

  • In the first link I posted I did show how to use interpolation for all easing effects. What I'm saying is only using a fixed value (0.1 is fixed) for the last parameter won't give anything but an easing out effect.

    Basically all the interpolation functions define some kind of curve from a to b. For example cosp() could look like this:

    a|--.
 |   `-.      
 |      `.
 |        `.
 |           |           \           
 |             |             \          
 |              \         
 |               `.         
 |                 `.       
 |                   `-.    
b|                     `--,
 +-------------------------
 0                        1[/code:1n6dc089]

The last parameter specifies a location along this curve from 0 to 1.  Now if you gradually increase that value from 0 to 1 you'll get whatever easing as the curve provides.  If you instead just use a fixed value for the last parameter and keep changing "a" then none of the functions will give any advantage over just using lerp.

But the best proof is to try it.

  • akkthedev

    To detect a pixel you first need to paste that object into the canvas object, then use the canvas.rgbaAt(x,y) expression.

R0J0hound's avatar

R0J0hound

Member since 15 Jun, 2009

Twitter
R0J0hound has 157 followers

Connect with R0J0hound

buymeacoffee.com

Trophy Case

  • 15-Year Club
  • Jupiter Mission Supports Gordon's mission to Jupiter
  • Forum Contributor Made 100 posts in the forums
  • Forum Patron Made 500 posts in the forums
  • Forum Hero Made 1,000 posts in the forums
  • Forum Wizard Made 5,000 posts in the forums
  • Regular Visitor Visited Construct.net 7 days in a row
  • Steady Visitor Visited Construct.net 30 days in a row
  • Enduring Visitor Visited Construct.net 90 days in a row
  • Unrelenting Visitor Visited Construct.net 180 days in a row
  • Continuous Visitor Visited Construct.net 365 days in a row
  • RTFM Read the fabulous manual
  • Great Comment One of your comments gets 3 upvotes
  • Email Verified

Progress

28/44
How to earn trophies