How to optimize Trigger for lag and space

[armoha]

Original Question: https://cafe.naver.com/edac/112087

For units whose indexes are from 1 to 1500,
I want to set their groundWeaponCooldown to 1 for 0 <= unitID <= 12,
and set their groundWeaponCooldown to 99 for unitID > 12.

epScript code

function setGroundCooldown() {
    const weaponCooldown = EUDArray(py_eval("[1] * 13 + [99] * 215"));
    for (var i = 1 ; i <= 1500 ; i++) {
        if (MemoryX(0x628298 + 0x150 * (i-1) + 0x54, AtLeast, 256 *
        weaponCooldown[dwread(0x628298 + 0x150 * (i-1) + 0x64)], 0xFF00)) {
            SetMemoryX(0x628298 + 0x150 * (i-1) + 0x54, SetTo,  256 *
            weaponCooldown[dwread(0x628298 + 0x150 * (i-1) + 0x64)], 0xFF00);
        }
    }
}

This is a sample code for asking if there's a lag.
Real code in question has additional parameters to determine cooldown. I assume it will take two or more division for calculation.

[armoha]

Why sample code are poorly written

Sample code occupies only 41 triggers at the expense of massive runtime lag.

1. var i is EUDVariable, so address must be calculated during game.
   Calculating 0x628298 + 0x150 * (i-1) + 0x54 involves following trigger executions:
   • Subtract 1 in (i-1)
   • Multiply 0x150
   • Add 0x628298 and 0x64
   • EPD conversion takes subtraction and division: EPD = (ptr - 0x58A364) ÷ 4
   • These in-game arithmetics will take around 40 triggers and 80 actions.
2. Copy-paste everywhere eagerly recalculates and never reuse known value.
   Simple refactoring quarters trigger executions.

   function setGroundCooldown() {
       const weaponCooldown = EUDArray(py_eval("[1] * 13 + [99] * 215"));
       for (var i = 1 ; i <= 1500 ; i++) {
           const epd = EPD(0x628298) + 84 * (i-1);
           const unit = bread_epd(epd + 0x64/4, 0);
           const cooldown = 256 * weaponCooldown[unit];
           if (MemoryXEPD(epd + 0x54/4, AtLeast, cooldown, 0xFF00)) {
               SetMemoryXEPD(epd + 0x54/4, SetTo, cooldown, 0xFF00);
           }
       }
   }

3. It always read unit type and recalculate on every frame.

Answer 1.

Since weapon cooldown is determined by unit type, we can cache unit type and reuse cooldown value if unit type has not changed.
Following code takes 3021 triggers and runs about 15000 triggers on idle.

function setGroundCooldown() {
    const updateTrigger = function(unitEpd, unitVar, varEpd, triggerEpd) {
        // Do not recalculate trigger if unitType stays still
        if (MemoryXEPD(unitEpd, Exactly, unitVar, 255)) return;
        const unit = bread_epd(unitEpd, 0);
        dwwrite_epd(varEpd, unit);
        const cooldownArray = EUDArray(py_eval("[1] * 13 + [99] * 215"));
        const cooldown = 256 * bread_epd(EPD(cooldownArray) + unit, 0);
        dwwrite_epd(triggerEpd + (8 + 8) / 4, cooldown);  // set value of 1st condition
        dwwrite_epd(triggerEpd + (328 + 20) / 4, cooldown);  // set value of 1st action
    };
    foreach(i : py_range(1500)) {
        const ptr = 0x628298 - 0x150 * i;
        const setCooldown = Forward();
        static var unit = 228;
        updateTrigger(EPD(ptr + 0x64), unit, EPD(unit.getValueAddr()), EPD(setCooldown));
        setCooldown.__lshift__(RawTrigger(
            conditions=MemoryX(ptr + 0x54, AtLeast, 0, 0xFF00),
            actions=SetMemoryX(ptr + 0x54, SetTo, 0, 0xFF00)
        ));
    }
}

Question 2. More parameter

Real code has enchant level at unused space CUnit +0x26.
I want to decrease cooldown 10% per enchant level individually.
Would it take too much triggers?

Answer 2. Simple adjustment

Unit type and enchant level are parameters for weapon cooldown.
Since their values can be overlapped, single variable can cache both.
(0~255: unit type, (0~255)*65536: enchant level)
Following code takes 3038 triggers and runs about 18000 triggers on idle.

function setGroundCooldown() {
    const updateTrigger = function(unitEpd, cache, cacheEpd, triggerEpd) {
        // Do not recalculate trigger if unitType and enchantLevel stay still
        if (MemoryXEPD(unitEpd + 0x64/4, Exactly, cache, 255)
        && MemoryXEPD(unitEpd + 0x24/4, Exactly, cache, 0xFF0000)) return;
        const unit = bread_epd(unitEpd + 0x64/4, 0);
        const enchant = maskread_epd(unitEpd + 0x24/4, 0xFF0000);
        dwwrite_epd(cacheEpd, unit + enchant);
        const cooldownArray = EUDArray(py_eval("[1] * 13 + [99] * 215"));
        const cooldown = bread_epd(EPD(cooldownArray) + unit, 0) * (655360 - enchant) / 655360;
        dwwrite_epd(triggerEpd + (8 + 8) / 4, cooldown);  // set value of 1st condition
        dwwrite_epd(triggerEpd + (328 + 20) / 4, cooldown);  // set value of 1st action
    };
    foreach(i : py_range(1500)) {
        const ptr = 0x628298 - 0x150 * i;
        const setCooldown = Forward();
        static var cache = 228;
        updateTrigger(EPD(ptr), cache, EPD(cache.getValueAddr()), EPD(setCooldown));
        setCooldown.__lshift__(RawTrigger(
            conditions=MemoryX(ptr + 0x54, AtLeast, 0, 0xFF00),
            actions=SetMemoryX(ptr + 0x54, SetTo, 0, 0xFF00)
        ));
    }
}

Similar optimization has done in Buizz/EUD-Editor-3#96

Summary

• Spend triggers for hot code path where performance is critical.
  It would be too much work if setting weapon cooldown involves recalculating bunch of stuffs for every units on every frame. If there are assumptions like 'weapon cooldown is determined by unit type and enchant level`, you can exploit them and get fast running triggers, at expense of complexity and inflexible code.
• Reuse triggers for cold code path.
  Keep rarely executing code compact and simple as possible.
  Changes of unit type or enchant level rarely happen during game, so we don't need to pour lots of time on updateTrigger function for performance.