dop2000's Forum Posts

  • Mouse.x=oldX
Mouse.y=oldY : Mouse not moving

Else : Mouse is moving

On every tick : Set oldX to Mouse.x, Set oldY to Mouse.Y

  • Then what should I use? For each?

    Depends on the task - For Each, Timer behavior, state machine. But "Trigger once" will only cause bugs when you use it like that.

  • The "Lookup Variables" idea is interesting, but setting it up must be a chore.

    Here are my tips:

    1. In all my big projects, I create a AudioPlay function and call it whenever I need to play a sound, instead of using the "Play" action directly. This makes it easy to modify the entire sound system later. For example, you can quickly implement a global volume setting or adjust how audio tags are named.

    2. Similarly, I use a single _LOG function for console logging. This allows me to disable all logs before publishing the game.

    3. Another logging tip: right-clicking anywhere prints all objects under mouse cursor to the console. This is incredibly useful in large games with thousands of objects, many of which are hidden. I used to waste a lot of time manually searching for the right instance in the debugger.

    Here is the code: 

    const excludeFamilies = true;

const results = []; // Collect results in an array

for (const objectTypeName in runtime.objects) {

	const allInstances = runtime.objects[objectTypeName].getAllInstances();
 const filteredInstances = allInstances.filter((e) => e.layer && e.layer.name);

	var idx=0;
	for(var i=0; i<filteredInstances.length; i++) {
		const instance = filteredInstances[i];
		const layerIndex = instance.layer.index;
 const x = runtime.objects.Mouse.getMouseX(layerIndex);
 const y = runtime.objects.Mouse.getMouseY(layerIndex);

		const left = instance.getBoundingBox().left;
 const top = instance.getBoundingBox().top;
 const right = instance.getBoundingBox().right;
 const bottom = instance.getBoundingBox().bottom;

 // Check if the mouse cursor is within the instance's bounding box
		// If excludeFamilies=true, duplicate UIDs will be skipped
		if (excludeFamilies===false || !results.some(record => record.UID === instance.uid)) {
			if (x >= left && x <= right && y >= top && y <= bottom) {
				// console.log(`${objectTypeName}\t\tLayer: ${instance.layer.name},\t\tUID: ${instance.uid}`);
					results.push({
						Object: objectTypeName,
						Layer: instance.layer.name,
						UID: instance.uid,
						IID: idx,
						Visible: instance.isVisible,
						Collisions: instance.isCollisionEnabled || "",
						Animation: (instance.animation ? (instance.animation.name+":"+instance.animationFrame) : "")
					});

			}
		}
		idx++;

 }
}

console.table(results);

    4. My final logging tip: I created an addon (which, unfortunately, won't work with SDK2) that adds event sheet names and event numbers to all log messages. It also allows to disable logging in the entire project. I wish the Browser object had built-in settings for this.

  • Remove "Trigger once" condition. Never use it with objects that have multiple instances.

  • Try Construct 3

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

    Try Now Construct 3 users don't see these ads

  • Here is my attempt:

    dropbox.com/scl/fi/vbfmptsy0qdcl823c9kaw/8Direction_Gamepad.c3p

    Sliding, acceleration, deceleration - all work. The speed also changes based on how far you tilt the stick.

  • You can use "Simulate control" action. It will only work for 8 directions though, as the behavior name suggests.

    Another option is to use vectors and handle acceleration/deceleration with events.

  • and when I'm in the title screen scene, my ‘LanguageIndex’ variable resets

    Is it a global variable? Global variables are not reset by themselves. There must be an event in your code that resets it.

  • Ashley himself says you don’t need delta time there!

    During the aiming stage and trajectory calculations, delta time is irrelevant. You only need it after firing the projectile to adjust its speed.

  • im_pro_viz An average of dt would be the same as time/tickcount.

    I agree with R0J0hound - you don't need to use dt at all in your case.

  • Other options are: dictionary, array, static local variable, an instance variable on a global object.

  • if we do the same for “round”, this method also shows itself well.

    Yes. But floor(random(0,6)) is easier to type and understand than round(random(-0.5,5.5))

  • choose(0,1,2,3,4,5) = round(random(0,5))

    igortyhon

    No, that’s not correct. The correct expression is int(random(0,6))

    choose(0,1,2,3,4,5) = int(random(0,6))

    Using round(random(0,5)) skews the distribution — both the lowest and highest numbers in the range will have a 50% lower chance of appearing compared to the others.

    See this demo:

    dropbox.com/scl/fi/kpnbq43gc6786r9blg7xn/RandomDemo.capx

  • Can you show your code, or share the project file?

  • In most cases, you don’t need For Each because the engine automatically loops through instances. For example,

    Enemy: Set HP to random(50,100)

    This will assign random HP values to each enemy instance, not the same value to all.

    However, you do need For Each if you specifically need to process each instance separately. For example:

    For Each Enemy → Call Function DealDamage(Enemy.UID)

    Without For Each, the function would only be called once for the first enemy instance.

    Another interesting fact I only recently learned: when multiple objects with multiple instances are referenced in the same event, the engine tries to process them in pairs.

    For instance:

    Enemy: Set size to Box.size

    This works fine if there’s only one Enemy or one Box. But if there are multiple instances of both, the engine will match them like this:

    • Enemy(0) → Box(0)
    • Enemy(1) → Box(1)
    • Enemy(2) → Box(2)

    Once it runs out of Box instances, it loops back to the beginning, meaning Enemy(15) might get Box(0)’s size.

    To avoid this, you’d need a For Each loop or another way to pick the correct instances.

    .

    Here’s a more obscure example of the same issue. Since the "On Timer" event picks both Tree instances, the engine compares Leaf.treeID with Tree.ID in pairs. As a result, some of the leaves are not picked.

    A "For Each Tree" loop is needed here:

  • So far, I have found this method: dividing time by tickCount. It seems much more stable.

    For what purpose? Where do you use this value?