R0J0hound's Forum Posts

  • The keys are just text so maybe you could just set the key's to be like "abcd" to begin with?

    I mean you could convert the text "l1&l2&l3&l4" to "abcd" using the replace() expression, or even the reverse. Would that help?

  • Irbis

    This doesn't split up the texture to separate frames and you could use spritesheets where images aren't arranged in a grid if you want with this.

  • Try Construct 3

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

    Try Now Construct 3 users don't see these ads

  • —

    If you google "spritesheet" you'll see the type of images this could be used for. Typically you'd need to split those images up to use. This plugin just lets you specify a rectangle of the image and use that instead of the whole image at once.

  • Ken95

    The process? It's basically just finding the intersection between lines a bunch of times. The objects have a border made up of lines and the ray is a line. You can just place the lines of the objects manually or use math to place them.

    It finds all the lines that intersect the ray, then uses the intersection closest to the start of the ray. From there you can calculate the normal of where the lines intersect and in turn calculate the reflection angle. Then it's just a matter of setting the ray to be from the intersection going at the reflection angle and repeating the process a number of times.

    The calculating of the line intersections and reflection angles is easily found in a search engine.

  • You could check the value of number%1. If it's 0 it's an integer, otherwise it's a float. Alternatively you could convert the number to a string and use a find to see if there's a point in it.

  • There has been a topic on webgl2 before where Ashley indicated what could be used by C2 from webgl2. That texture thing was the main useful thing as I recal but otherwise nothing much else. I'd have to find the topic to get a better explanation.

  • Looking at the pseudo code for that algorithm it looks like it's done with just 32bit variables, so there's no issue there. Beyond that you'll need to use a plugin that provides bit operations or just use js directly. But if you were to use a plugin isn't there one that does sha256 already?

  • Pretty much just a improvement with tiling non power of two (npot) textures. By improvement I mean it'll look better. Right now npot textures are stretched onto power of two textures before it can be tiled.

  • I think any solution will have a certain level of pain. JavaScript stores numbers as 64bit and in some of it's calculations with integers will use 32bit.

    If you use JavaScript you could use a typed array of multiple 64bit numbers and then use the memory address of that with some asm.js or web assembly that can call a cpu instruction that works on 256bit numbers. However that probably isn't very cross platform.

    Another option is to use a js library like this:

    https://github.com/MikeMcl/bignumber.js/

    But you still have to deal with numbers in a certain way.

    Besides that you probably just need to use multiple numbers or text to store the number.

  • Here's an example of it in action:

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

    Basically look at every pair of lists with two loops like I mentioned above. Families can be used to pick both at once or you can just pick each individually like in the capx. In the capx I copy the list over to an array, and then sort the array. Next if the number of items is the same we can compare each item and see if they're equal, and if they are you can mark those lists as no unique.

  • How do you store and use your lists currently?

  • Put all the arrays you want to compare into two families: listA,listB

    The first step is to compare every two pair of arrays, and check if their sizes are the same. Here's a way to do that:

    for "a" from 0 to listA.count-2

    system: pick instance # loopindex("a") of listA

    for "b" from loopindex("a")+1 to listB.count-1

    system: pick instance # loopindex("b") of listB

    system: compare listA.width = listB.width

    --- sub event

    The sub event is how you compare the values in the two lists. If you sort the lists then it's simple and you can compare each index of each pair of lists. If you don't want the lists' values to be sorted then then you can copy the lists using asJson to two different arrays and sort them first.

  • Solutions include using:

    * The chipmunk physics behavior. This has expressions to get the collision vector (or normal).

    * The raycasting plugin. It doesn't give the collision vector between two shapes but you can use some rays to calculate it.

    * Here are a few other ideas I've used to calculate the collision vector:

  • mrtumbles

    I'm curious, how did you make your assets, and did you go for a low resolution look?

    Also "paster" is a plugin that allows you to draw to it's texture.

  • It doesn't look too bad. Generating the graphics would be the hardest to do. Drawing layer by layer or using a voxel editor are a couple options. Personally I think It would be cool to just slice up textured 3D objects, but I haven't seen a workflow to do that yet.

    The graphics would probably need to be lower resolution to keep the video ram usage low.

    Rendering using multiple instances for every frame isn't so bad. Probably just a matter of zordering everything by frame. The rotation may take a bit of math, but it's not bad either. Animation is just more images and isn't bad, maybe a couple more events.

    Now the paster plugin could be used to cut down on the number of instances needed and the amount of things to be drawn. The static scenery could all be drawn to a paster per layer that way you only have draw those and the moving objects per frame.

    Another plus of using the paster object is all the rotation math isn't needed.

    Besides that the vertical squish can't be done with vanilla C2.

    Collisions would be done in the same way as isometric. Everything is done from a top view.

    I'm not very proficient with shaders but I don't think they would be helpful here because for one you can't access more than one source image in C2.

    A plugin may work, but internally it would be much more complicated to make than with events imo. Not to mention it would be less flexible.

    Reenabling the "front to back" may give some rendering improvement but at the same time the paster plugin wouldn't work with it, but that may be a small loss.