Differential D1490 Diff 16728 binaries/data/mods/public/maps/scenarios/unit_pushing_test.js

Changeset View

Standalone View

binaries/data/mods/public/maps/scenarios/unit_pushing_test.js

This file was added.

				const REG_UNIT_TEMPLATE = "units/athen/infantry_spearman_b";
				const FAST_UNIT_TEMPLATE = "units/athen/cavalry_swordsman_b";
				StanUnsubmitted Not Done Inline Actions Should probably be in that test map mod we talked about. Stan: Should probably be in that test map mod we talked about.

				const ATTACKER = 2;

				var QuickSpawn = function(x, z, template, owner = 1)
				{
				let ent = Engine.AddEntity(template);

				let cmpEntOwnership = Engine.QueryInterface(ent, IID_Ownership);
				if (cmpEntOwnership)
				cmpEntOwnership.SetOwner(owner);

				let cmpEntPosition = Engine.QueryInterface(ent, IID_Position);
				cmpEntPosition.JumpTo(x, z);
				return ent;
				};

				var Rotate = function(angle, ent)
				{
				let cmpEntPosition = Engine.QueryInterface(ent, IID_Position);
				cmpEntPosition.SetYRotation(angle);
				return ent;
				};

				var WalkTo = function(x, z, queued, ent, owner=1)
				{
				ProcessCommand(owner, {
				"type": "walk",
				"entities": Array.isArray(ent) ? ent : [ent],
				"x": x,
				"z": z,
				"queued": queued,
				"force": true,
				});
				return ent;
				};

				var FormationWalkTo = function(x, z, queued, ent, owner=1)
				{
				ProcessCommand(owner, {
				"type": "walk",
				"entities": Array.isArray(ent) ? ent : [ent],
				"x": x,
				"z": z,
				"queued": queued,
				"force": true,
				"formation": "special/formations/box"
				});
				return ent;
				};

				var Attack = function(target, ent)
				{
				let comm = {
				"type": "attack",
				"entities": Array.isArray(ent) ? ent : [ent],
				"target": target,
				"queued": true,
				"force": true,
				};
				ProcessCommand(ATTACKER, comm);
				return ent;
				};


				var gx;
				var gy;
				var experiments = {};

				// Perf check: put units everywhere, not moving.
				experiments.Idle = {
				"spawn": () => {
				const spacing = 12;
				for (let x = 0; x < 20164 - 20; x += spacing)
				for (let z = 0; z < 20164 - 20; z += spacing)
				QuickSpawn(x, z, REG_UNIT_TEMPLATE);
				}
				};

				// Perf check: put units everywhere, moving.
				experiments.MovingAround = {
				"spawn": () => {
				const spacing = 12;
				for (let x = 0; x < 20164 - 20; x += spacing)
				for (let z = 0; z < 20164 - 20; z += spacing)
				{
				let ent = QuickSpawn(x, z, REG_UNIT_TEMPLATE);
				for (let i = 0; i < 5; ++i)
				{
				WalkTo(x + 4, z, true, ent);
				WalkTo(x + 4, z + 4, true, ent);
				WalkTo(x, z + 4, true, ent);
				WalkTo(x, z, true, ent);
				}
				}
				}
				};
				// Perf check: fewer units moving more.
				experiments.LighterMovingAround = {
				"spawn": () => {
				const spacing = 36;
				for (let x = 0; x < 20164 - 20; x += spacing)
				for (let z = 0; z < 20164 - 20; z += spacing)
				{
				let ent = QuickSpawn(x, z, REG_UNIT_TEMPLATE);
				for (let i = 0; i < 5; ++i)
				{
				WalkTo(x + 20, z, true, ent);
				WalkTo(x + 20, z + 20, true, ent);
				WalkTo(x, z + 20, true, ent);
				WalkTo(x, z, true, ent);
				}
				}
				}
				};

				// Perf check: rows of units crossing each other.
				experiments.BunchaCollisions = {
				"spawn": () => {
				const spacing = 36;
				for (let x = 0; x < 20164 - 20; x += spacing)
				for (let z = 0; z < 20164 - 20; z += spacing)
				{
				for (let i = 0; i < 10; ++i)
				{
				let ent = QuickSpawn(x + i, z + 20 * (i%2), REG_UNIT_TEMPLATE);
				for (let ii = 0; ii < 5; ++ii)
				{
				WalkTo(x + i, z + 20, true, ent);
				WalkTo(x + i, z, true, ent);
				}
				}
				}
				}
				};

				// Massive moshpit of pushing.
				experiments.LotsaLocalCollisions = {
				"spawn": () => {
				const spacing = 4;
				for (let x = 100; x < 200; x += spacing)
				for (let z = 100; z < 200; z += spacing)
				{
				let ent = QuickSpawn(x, z, REG_UNIT_TEMPLATE);
				for (let ii = 0; ii < 20; ++ii)
				WalkTo(randFloat(100, 200), randFloat(100, 200), true, ent);
				}
				}
				};

				var cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);

				Trigger.prototype.Setup = function()
				{
				let start = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer).GetTime();
				gx = 20;
				gy = 20;

				let time = 0;
				for (let key in experiments)
				{
				cmpTrigger.DoAfterDelay(1000 + time * 10000, "RunExperiment", { "exp": key });
				time++;
				}
				};

				Trigger.prototype.Cleanup = function()
				{
				warn("cleanup");
				let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
				let ents = cmpRangeManager.GetEntitiesByPlayer(1).concat(cmpRangeManager.GetEntitiesByPlayer(2));
				for (let ent of ents)
				Engine.DestroyEntity(ent);
				};

				Trigger.prototype.RunExperiment = function(data)
				{
				warn("Start of " + data.exp);
				experiments[data.exp].spawn();
				cmpTrigger.DoAfterDelay(9500, "Cleanup", {});
				};

				Trigger.prototype.EndGame = function()
				{
				Engine.QueryInterface(4, IID_Player).SetState("defeated", "trigger");
				Engine.QueryInterface(3, IID_Player).SetState("won", "trigger");
				};

				/*
				var cmpModifiersManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ModifiersManager);

				// Reduce player 1 vision range (or patrolling units reacct)
				cmpModifiersManager.AddModifiers("no_promotion", {
				"Vision/Range": [{ "affects": ["Unit"], "replace": 5 }],
				}, 3); // player 1 is ent 3

				// Prevent promotions, messes up things.
				cmpModifiersManager.AddModifiers("no_promotion_A", {
				"Promotion/RequiredXp": [{ "affects": ["Unit"], "replace": 50000 }],
				}, 3);
				cmpModifiersManager.AddModifiers("no_promotion_B", {
				"Promotion/RequiredXp": [{ "affects": ["Unit"], "replace": 50000 }],
				}, 4); // player 2 is ent 4
				*/

				cmpTrigger.DoAfterDelay(1000, "Setup", {});

				cmpTrigger.DoAfterDelay(300000, "EndGame", {});