Posts by BartekB

I recall a mention that fast loop names are actually optimised out if they are static (i.e. the fast loop's name is just one string, not an expression), so internally there is no string comparisons happening for those loops.

You can test this theory out by using "On loop 'MyFastLoopName("Active")' which will force Fusion to make a string comparison for this loop event.

There should be no performance or memory difference when writing any value, be it large or negative.
Though, the Array object might be compressing itself so similar values close together might be beneficial, but it's not certain without a source for it.

In the "realm" of programming languages, flags are the equivalent of a boolean (Please login to see this link.) which are true or false only.

Fusion stores flags in a 32bit number. If flag 0 and 3 is enabled, that would be represented in binary like so: 0b00000000000000000000000000001001
Since one flag occupies one bit and there's 32 bits to work with you get 32 flags to use. Bits can only be off or on, so there's no space to fit a neutral state without modifying flags in a major way and breaking compatibility.

Quote from NaitorStudios

I wonder if there's a mathematical way of doing this to toggle between -1 and 1 X)

multiply by * -1?

X(Variable) wouldn't work because expressions and objects are paired together. One object can have an expression which another object won't. It would be impossible to tell whether the expression you typed is valid and the object you chose is capable of executing that expression.

But if it were to happen, a lot of guards would have to implemented to fail silently on invalid input at runtime instead of at edittime, which is going to impact performance. (runtime = while the game is running, edittime = while developing the game in editor)

You can simplify your solution by doing this:
* Upon your action
Group.Good : Set Alterable String A to OName$( "Group.Good" )

* Upon your action
* Alterable String A of Group.Good = "MyObjName"
Counter : Set Counter to "Group.Good" )

If I recall, in the next update you'll be able to choose "Compare to object's expression", writing OName$( "Group.Good" ) in the top box, and "MyObjName" in the other, omitting the first event above completely.

That'll grab the X of the first object matching their name to "MyObjName". Ideally though you'd steer away from using strings this way as string comparisons get expensive.

Fusion stores position as an integer so it wraps any expression you give in Set Position X/Y with an Int() which removes the decimal point (Like Floor(), but different), hence why you see the increase in speed when going left.

The latest Scope Control version can now be found here: Please login to see this link.

Yes, over at the Discord I released a few fixes that other users have brought up.

For cross platform what you've said is pretty much it:
- Set Alt value "Chosen Fixed" of object O to 0
- Set Alt value "Lowest Distance" of object O to 999999
- Set Alt value "Distance To" of object X to (distance equation)
- Start for each on objects X

On for each loop on object X
+If X's Distance To is lower than O's Lowest Distance
- Set Alt value "Chosen Fixed" of O to X's fixed value
- Set Alt value "Lowest Distance" of O to X's Distance to

You should always try to place fast loops separate from other actions because they introduce scoping issues after they execute until the event they are in ends.

You are moving the zoom center by setting fZoomX and fZoomY. The expression X Left Frame / 2 + X Right Frame / 2 stands for the middle of the screen i.e. 0.5, so if fZoomX/fZoomY isn't set to that value, that will no longer work. What you're looking for is interpolation:

X Left Frame + (X Right Frame - X Left Frame) * fZoomX

With this the center changes with fZoomX/Y, so now you should be able to reuse the previous expression:

Centre + (Cursor - Centre) / Zoom

Please login to see this attachment.

It doesn't sound like you need a 12000x12000 object to cover the entire frame though. You should be fine with just covering the area visible through the camera/window.
But if it's required for some reason then like contra said you can scale an object which doesn't modify the original image and so the ram stays the same.

DRPC has been updated, you can get it via Please login to see this link.

- Fixed an issue with remaining time always displaying "00:00" instead of the correct time

Check the hotspot (the origin of an image) of the player sprite. Between the Stopped & Walking animation, it varies in position causing the bug.
You can change hotspots by clicking the eye icon under the "A" for writing text. You can change all hotspots currently visible in the frames list by holding alt while clicking on hotspot UI/buttons.

I would also recommend using an invisible "hitbox" active which is just a rectangle. Using a sprite with animations that changes a lot will make objects clip into walls regardless of hotspots.

Then move the hotspot of the box down by 1 pixel. The origin is not a pixel in size, but rather the top/left coordinate of the "center" pixel while you edit the hotspot:
Please login to see this picture.
changing it to this fixes it:
Please login to see this picture.

I think the layout of the forum changing may be related to the maintenance that is currently going on, some sections do seem to have disappeared but I'm not sure.

Quote from Edel

Hey Vol

How's Spryk coming along? Are you still developing it or waiting for the F3?

Please keep the thread on-topic

You'll have to make a request through CT's customer service portal: Please login to see this link.

If the sprite active object's animation is correctly clipped so that there is no transparent borders. It's easy as retrieving OHeight("Active") from the active.
To make it work for scale, you'll have to divide OHeight by the original height of the collision box. Make sure you pass decimals somewhere before the division so Fusion recognises this as a float (number with decimals) rather than an integer: OHeight * 1.0 / original_col_height

If the sprite does have bounds, unfortunately it won't be as easy, since you now have to run overlap events through a fastloop to check where a horizontal line in the sprite is empty.

Quote from stiggits

[MENTION]Musta[/MENTION]
Fusion reads and checks every line of code every frame( 60xsec)

When Fusion goes through each event, it ignores events starting with green (e.g. user clicked mouse button), because they're triggered/called from somewhere else. So they're preferred over other events (always/comparisons).

I'd recommend checking out our Click Converse Discord server. It is a community server with many users willing to help out, myself included: Please login to see this link.
Though, it'll also be fine if you want to contact me personally for work you want done, I've been paid to create game logic/elements, go through maths and make shaders for users before. As I am Staff on the forums I'm unable to receive private messages here so Discord will have to do, or email contact at uppernate.com

You can't activate/deactivate groups for certain instances, it's either for everyone or for none.
You will have to change the group activation/deactivation for something else, like For Each Loops, or just simple flag checks.