ALICE 2.8.4 (Missiles, Physics & More)

[stalkerfox]

as a casual user with knowledge only to gui this looks like basic chinese to me
but there is so much potentail here! hope it gets approved

 

[Antares]

as a casual user with knowledge only to gui this looks like basic chinese to me
but there is so much potentail here! hope it gets approved

Thanks Yea, it's a bit too technical mumbo-jumbo right now, but I hope there can be a GUI-friendly version in the future, or something built with it that is GUI-friendly.

 

[maddeem]

Saying this resource is extensive is a severe understatement. I am glad to see someone else using spatial hashing... The performance you can get from these algorithms are amazing. I actually have the problem where the effect models themselves are more expensive to compute than the collision/pathing logic. With that being said we can reduce the number of table lookups from table[x][y] to table[index]. You can do this by doing:
index = x + y * 1e7 (works for any map size)

Edit:
You should consider doing effects all the way down. I've done it and the performance increase is stupendous.

 

[Antares]

Saying this resource is extensive is a severe understatement. I am glad to see someone else using spatial hashing... The performance you can get from these algorithms are amazing. I actually have the problem where the effect models themselves are more expensive to compute than the collision/pathing logic. With that being said we can reduce the number of table lookups from table[x][y] to table[index]. You can do this by doing:
index = x + y * 1e7 (works for any map size)

Thank you, yes, the performance increase after I added the cell optimization was quite substantial. With my vJASS version, I was hardlocked at 181 objects (sqrt(32768), the max array size), but I estimate the maximum I could do without that restriction was 250. After translating it to Lua, I went up to 1000, so a ~16x performance increase. Then, after adding the cells, I went to 3000, so another ~10x performance increase, but probably much more, because, like you said, at such a high number of objects, rendering and moving the objects starts to take the majority of the resources.

You're right that I could improve the performance by doing linear indexing. However, I have to make sure that there are no bugs and I don't want to change anything about the core, because after converting it to linear indizes, the code becomes quite unreadable. Currently, I'm focused on getting the API to always work in the way you'd intuitively expect it to. I'm creating different scenarios and when I encounter a problem I can't solve, I change the engine such that I can.

I'm also not sure if linear indexing would make sense everywhere, because the math to get the index could be slower than the table lookup itself. I'd have to make some tests. Did you do tests on that?

Edit:
You should consider doing effects all the way down. I've done it and the performance increase is stupendous.
View attachment 468609

Holy ****, that's a lot of skeletons! With effects all the way down you mean replace units etc. with special effects? Well, I did make a map where there's like 5 units on the map and everything else are special effects... But, of course, that's not always feasible.

 

[Antares]

Working on a collision/physics library right now. Here's a small preview :

 

[Ferro]

Is there a way to automatically assign an actor for a destructible upon its creation? I can do it with unit by using a Unit Indexer library, but so far there is no function to detect a destructible entering the map if I am correct.
Does your system work on particles with different collision sizes and masses? I mean does it work if I have two spheres with radii 10000 and 100 colliding with each other?

 

[Antares]

Is there a way to automatically assign an actor for a destructible upon its creation? I can do it with unit by using a Unit Indexer library, but so far there is no function to detect a destructible entering the map if I am correct.

Yes, there is no trigger to detect a destructable entering, but, in the destructables library, I created hooks to create actors when the CreateDestructable functions are called. On map initialization, I loop over all destructables. A destructable being revived won't create one, though. That's a problem I haven't solved yet.

Does your system work on particles with different collision sizes and masses? I mean does it work if I have two spheres with radii 10000 and 100 colliding with each other?

Yes, that's not a problem. You can see in the video I posted above your post that there are rocks with different sizes and masses colliding with each other.

You can store the collision sizes of your particles in the table, then in your collision function do:

local distance = ALICE_PairGetDistance()
if distance < particle1.collisionSize + particle2.collisionSize then
    DoStuff()
end

However, the engine also needs to know at which range it should start checking for collisions. That's done with the .radius field. You can take a look at the Cells example in the showcase map to see how that works.

Welcome to hive btw

 

[Antares]

This video was a lot of fun to make . Should have an update with ready-to-use systems showcased in that video up in a week or two.

 

[KenArok]

Imagine implement this system with 3d / first person camera system together..

 

[Antares]

Imagine implement this system with 3d / first person camera system together..

Haha, yea, you could build a sick RPG with it . I'm actually looking into camera movement systems right now. Are you interested in that?

Thanks for the stars!

 

[maddeem]

Very hot

 

[KenArok]

Haha, yea, you could build a sick RPG with it . I'm actually looking into camera movement systems right now. Are you interested in that?

Thanks for the stars!

exactly, there no cure for that! lol

hmm.. like playing warcraft with 3d camera movement, but not always losing sight when walking under giant trees or the camera falling when walking through the hills?

 

[Antares]

exactly, there no cure for that! lol

hmm.. like playing warcraft with 3d camera movement, but not always losing sight when walking under giant trees or the camera falling when walking through the hills?

Hm, I'm not that far yet. Currently looking into ways to accurately track the mouse movement so you can move the camera with your mouse like in WoW. But you're talking about using the engine for the camera movement? If so, that's difficult, because camera positions are not synced and the engine needs to stay synced.

Do you have a map in mind that has that camera movement you're describing?

Very hot

Thank you!

 

[KenArok]

Hm, I'm not that far yet.

bro, thats not too far.. you just managed to make the nearby trees faded and with physic/collision on progress..

Currently looking into ways to accurately track the mouse movement so you can move the camera with your mouse like in WoW.

that interesting.. cant wait for this.. really..

But you're talking about using the engine for the camera movement? If so, that's difficult, because camera positions are not synced and the engine needs to stay synced.

no, i meant not the camera thats moving, but my movement with 3rd camera.. sorry for my english.. maybe you can adjust the camera's distance of view when you near small trees / big trees / giant trees with accurate size of the trees or just simply hide the trees.. and adjust camera's height/offset when you walk on low/high ground with accurate height of the ground and the camera.. due to respect, you are the wizard of this matters.. im just a person who is always amazed by magic..

Do you have a map in mind that has that camera movement you're describing?

sorry, no longer have the maps, but Shadow of the Past and Daemonic's sword is not bad..

 

[Antares]

no, i meant not the camera thats moving, but my movement with 3rd camera.. sorry for my english.. maybe you can adjust the camera's distance of view when you near small trees / big trees / giant trees with accurate size of the trees or just simply hide the trees.. and adjust camera's height/offset when you walk on low/high ground with accurate height of the ground and the camera.. due to respect, you are the wizard of this matters.. im just a person who is always amazed by magic..

Ah, I see what you mean now. I totally forgot about the tree transparency thing in my video.

Yes, when you have a 3rd person camera like in WoW, it "collides" with objects and walls and goes around them. So, you'd need some kind of collision detection with the camera and the objects. Same thing if you want to make the objects transparent. The example in the video is really simple compared to a 3rd person camera in a 3D world. It's also based on the position of the hero and not on the position of the camera.

The collision detection could be done with ALICE. You would create an object that represents the camera that moves around the world. I would just need to upgrade the engine to allow interactions to be executed asynchronously if it's for a multiplayer map. One player has the camera over at location A and the camera is trying to go around tree B, the next player has the camera somewhere else and doesn't see the same collision detection being performed. This must not cause a desync.

That's my current thinking. Of course, there could be easier ways that I haven't considered yet.

sorry, no longer have the maps, but Shadow of the Past and Daemonic's sword is not bad..

They both just have regular game camera during gameplay, do they not?

 

[KenArok]

They both just have regular game camera during gameplay, do they not?

as i remember, they have 3rd person camera, but you know they are old maps, so i dont want to judge or anything, but sometimes i need to return the camera view back to normal view during gameplay ..

The collision detection could be done with ALICE. You would create an object that represents the camera that moves around the world. I would just need to upgrade the engine to allow interactions to be executed asynchronously if it's for a multiplayer map. One player has the camera over at location A and the camera is trying to go around tree B, the next player has the camera somewhere else and doesn't see the same collision detection being performed. This must not cause a desync.

that what i was talking about .. camera's distance get closer to the hero, if there a wall or trees behind the hero, but not change the view front the hero.. i mean it will change the field of view..

 

[Antares]

as i remember, they have 3rd person camera, but you know they are old maps, so i dont want to judge or anything, but sometimes i need to return the camera view back to normal view during gameplay ..

Well, hopefully a mouse-controlled camera doesn't turn out to be too jank, so RPG maps can use that . With such a camera, you would also need WASD movement then. I can't get over the fact that none of these RPGs have their own movement system (at least drag-move) and it's just clicking everywhere while your hero is constantly spamming "A sound plan." "Of course." "For honor." "A sound plan." and so on.

 

[KenArok]

Well, hopefully a mouse-controlled camera doesn't turn out to be too jank, so RPG maps can use that . With such a camera, you would also need WASD movement then. I can't get over the fact that none of these RPGs have their own movement system (at least drag-move) and it's just clicking everywhere while your hero is constantly spamming "A sound plan." "Of course." "For honor." "A sound plan." and so on.

check this out..

 

[ILH]

This video was a lot of fun to make . Should have an update with ready-to-use systems showcased in that video up in a week or two.

The way the missiles just uncontrollably bounce off the force field is pure chef kiss.

 

[Ferro]

Very nice update. I have a half-built particle system in JASS but may just give up finalizing it since this system is much more efficient.

 

[Antares]

The way the missiles just uncontrollably bounce off the force field is pure chef kiss.

Thank you!

Very nice update. I have a half-built particle system in JASS but may just give up finalizing it since this system is much more efficient.

My system is Lua-only. Can you make the switch to Lua?


And here's the change log:

Version 2.0

• Added ready-to-use libraries - Objects, Entities, Missiles, Collisions, Ballistics, and Forces.
• Return values in interaction functions are now optional. If the return value is omitted, ALICE will automatically put pairs using that function into the optimized EveryStep cycle.
• Added API functions to add or remove self-interactions.
• Added the Matrix API. These functions can be used to write data tables and share data between object pairs.
• ALICE now uses the WidgetType library to infer the correct type of objects passed into it.
• To improve performance with widgets, Math API functions now use cached values for object coordinates that get reset each cycle.
• Freeze protection is now based on evaluation time instead of number of pairs.
• ALICE_Benchmark can now be used to view the evaluation time of each cycle.
• Added the HALT_ON_FIRST_CRASH option in the config.
• Reorganized API into Core and Advanced API.

 

[Galileo]

Any idea how to use your alice system to make custom auto attack projectiles? the native one cant be changed on a unit. I need ability to change unit projectile model.

 

[Antares]

Version 2.1 is out. This update focuses mostly on making ALICE easier to set up and work with. To this end, there are multiple changes that should simplify the API and make it more consistent. Thank you for the feedback from @Galileo.

• The Units, Destructables, Items, and Widgets CATs have been removed and incorporated directly into the main script. There are new options in the config to customize ALICE's default actor creation.
• When using tables as hosts, debugging can be a nightmare because you don't get a syntax check on a misspelled table field from your IDE. Therefore, I added an option in the config to warn about tables containing unrecognized fields. By default, only the fields used by ALICE are listed as being recognized, but more can be added with ALICE_RecognizeFields. ALICE_RequireFields is a similar feature. It warns you when a table field that is required for an interaction function is not set.
• The debug mode has new hotkeys, such as halting and resuming the cycle and going to the next step. There is now an option to automatically enable debug mode on map initialization.
• Simplified and streamlined how the pairing of actors is controlled. The ability to pass functions as the interactionFunc, the "other" keyword, and the pairsWith flag have all been removed. Actors that pair with everything are never a good idea and the pairsWith flag was unintuitive and clunky. In place of these features, you can now use tables as keys in the interactionFunc, for example interactionFunc = {[{"steak", "grilled"}] = Eat, [{"steak", "raw"}] = Grill}. An actor must possess all identifiers listed in the table for a pairing to occur.
• The manuals have been moved to the resource page, since hiveworkshop is more pleasant to read than a code comment.
• You now enter the cell size in the config instead of the amount, so it doesn't need to be updated as the map size changes.

Since the cost isn't too high yet, I renamed some of the functions and features:

• The table containing all interaction functions is now expected to be called "interactions" instead of "interactionFunc", because it might be confusing to use that term for two different things.
• Removed the ALICE_CreateFromClass function and incorporated its functionality into ALICE_Create.
• We have doodads and widgets, but we do not have gizmos!? Therefore, I renamed "entities" (objects represented by a table with coordinates and a special effect) to gizmos, which is clearly a much more awesome term. I will from now on lobby that gizmo becomes the official term for that kind of object.
• The gizmo fields "visual" and "owner" are now hard-coded and can no longer be customized.

Other changes and additions:

Hidden

• Added the Callback API, which allows creating delayed function calls that are performant and run on the main cycle. This makes them pauseable for debug purposes. Potentially, you could pause the entire game.
• Added the Modular API, which contains functions to inject additional properties and functionality into actors on creation, including into the default actors created for widgets. This allows libraries to add functionality to actors that these libraries need to work correctly without modifying the ALICE script itself.
• Overhauled how pair data is handled. There was an issue with the previous implementation, where an interaction could break without invoking the onDestroy function. Now, callback functions are declared on an per-function basis with ALICE_FuncSetOnDestroy, ALICE_FuncSetOnBreak, or ALICE_FuncSetOnReset, with all functions behaving slightly differently. There is now a tutorial on pair data in the Advanced Manual.
• ALICE_PairPreciseInterval has been added to allow interaction intervals that are not integer multiples of the minimum interval.
• You can now display additional variables in actor tooltips with ALICE_TrackVariables.
• In the Collisions CAT, the onWidgetDamage feature now works without declaring an onCollision function. onWidgetDamage can now be a function, not just a number. Added the option to disable friendly fire. The documentation has been improved.
• The WidgetType library has been updated with a better method and renamed to HandleType.
• Added the Mice CAT, a snippet to create an actor for each player's mouse.

Upcoming:

• Support for asynchronous code execution by moving all arrays to linked lists. This ensures that the order of execution remains consistent between all players when asynchronous pairs are thrown into the mix. This will enable several ideas for systems I have using visibility detection.
• Fixing ballistic movement around cliffs.
• Line-segment enumeration.

 

[Antares]

Small update to fix some bugs.

Version 2.1.2

• Fixed the ALICE_PairCallDelayed function.
• Added missing hooks for RemoveDestructable and RemoveItem that prevent actors from leaking.
• All actors now get properly cleared on a widget death or removal, preventing possible leaks of additional actors.
• ALICE_PairPause is now more reliable.
• ALICE_PairCooldown now allows starting multiple cooldown.
• The Matrix API has been removed and replaced with the Pair Access API, which is faster, more flexible, and less confusing.

 

[darkravenbest]

I think its obviously for post reforged versions of the game strictly?

 

[Antares]

I think its obviously for post reforged versions of the game strictly?

I'm not an expert on this, I haven't designed it with pre-Reforged in mind. There might be some frame functions that I'm using for the debug mode that aren't available pre-Reforged, but other than that, this is just a giant Lua table rearrangement machine, so most of it should work. If that's the case, it shouldn't be too much effort to make a pre-Reforged compatible version. I just have to know the functions I need to avoid.

 

[darkravenbest]

I'm not an expert on this, I haven't designed it with pre-Reforged in mind. There might be some frame functions that I'm using for the debug mode that aren't available pre-Reforged, but other than that, this is just a giant Lua table rearrangement machine, so most of it should work. If that's the case, it shouldn't be too much effort to make a pre-Reforged compatible version. I just have to know the functions I need to avoid.

I will try this system, and i hope most of it will work. Because i really like the functionality. Most of needed systems in one piece.

 

[Antares]

I will try this system, and i hope must of it will work. Becaus i really like the functionality. Most of needed systems in one piece.

Cool, hopefully you won't encounter too many bugs.

Could you give me an overview of the patch you're on? Lua was added in the last patch before Reforged, I assume you're on that one? Frame natives were also added in that patch, but not all of them if I'm not mistaken.

 

[darkravenbest]

Cool, hopefully you won't encounter too many bugs.

Could you give me an overview of the patch you're on? Lua was added in the last patch before Reforged, I assume you're on that one? Frame natives were also added in that patch, but not all of them if I'm not mistaken.

Of course im on 1.31. The last pre reforged patch to get as much of new functionality (and sadly bugs) as possible without need to always log in battle.net to test maps. If i was using later version, i didn't even think about a mere possibility to use this system.

 

[Antares]

More important bug fixes:

Version 2.1.3

• Fixed a bug that caused newly created objects to sometimes only start interacting when entering a new cell.
• Fixed a bug that caused changing identifiers to sometimes crash the engine.

Of course im on 1.31. The last pre reforged patch to get as much of new functionality (and sadly bugs) as possible without need to always log in battle.net to test maps. If i was using later version, i didn't even think about a mere possibility to use this system.

My knowledge of this is only from looking up the patch history just now, and from my vague memory, so I wouldn't know this. If you have the list of natives missing in 1.31 or know where I can find something like that, it would help me a lot.

 

[Antares]

Version 2.1.4

• Accidently broke the Rockslide example in the test map in the last update. This has been fixed.
• OnCreation hooks now always accept function arguments as advertised and now work properly in (hopefully) all situations.
• ALICE_PairCooldown now returns the remaining cooldown instead of a boolean.
• Added ALICE_FuncPauseOnStationary to declare a function that should always get paused when an object becomes stationary.
• Removed the random delay option in ALICE_FuncSetDelay, as it is a possible cause of desync.

 

[Bain_Rebirth]

This might be the most impressive thing I've ever seen done in warcraft III. Bravo

 

[Antares]

This might be the most impressive thing I've ever seen done in warcraft III. Bravo

Wow, thank you!

 

[Antares]

Version 2.2

• Enabled asynchronous code execution. Pairs and actors can now be created asynchronously without risking a desync as long as certain rules are being followed.
• Added the ALICE_EnumObjectsInLineSegment and ALICE_ForAllObjectsInLineSegmentDo functions.
• Added the ALICE_GetClosestObject function.
• Added the Cameras CAT, which creates an actor for each player's camera.
• Various bug fixes.

 

[Antares]

Version 2.2.2

• Fixed a bug that caused the engine to crash when passing a non-widget handle as the host .
• Fixed a bug that caused unpredictable behavior when changing the identifiers of global actors.
• Classifications to unit actors can now be added individually.
• Added the ALICE_OnWidgetEvent function. This function creates hooks on the widget event hooks (sup dawg) used by ALICE to create the default widget actors, allowing users to easily manage their own widget actors.
• Added the ALICE_IsStationary function.
• Added an optimization that caches the interaction function for two actor types, allowing it to be retrieved faster the next time two actors of the same types meet.

 

[Trokkin]

been just a year away and all this goodness pops up. My god are you inspiring. Between this and perfect camera and mouse tracking, like every everything is possible now.

Also those rock animations are perfect, between standing still and then rolling at just the right speed to feel right

 

[Antares]

been just a year away and all this goodness pops up. My god are you inspiring. Between this and perfect camera and mouse tracking, like every everything is possible now.

Thank you so much! Yea, moddiemads' libraries are insane as well.
Here's to better modding days ahead than the post-Reforged days .

Also those rock animations are perfect, between standing still and then rolling at just the right speed to feel right

Those took me some time to get right. The formulas I got online for the yaw/pitch/roll transformations didn't work, because yaw-pitch-roll is defined differently in Warcraft 3, so I just brute-force tried all possible permutations until one of them was correct .

 

[Regno]

I assume implementing this system is only gonna be possible to lua users?

 

[Antares]

I assume implementing this system is only gonna be possible to lua users?

This kind of system isn't really possible in JASS, unfortunately.

 

[Regno]

This kind of system isn't really possible in JASS, unfortunately.

No wonder, it looked so complicated and amazing, I wont be able to make use of it, but I'm gonna say it still, it looks freaking amazing, good job.

 

[Antares]

Alright, hopefully the last bug fix update for now...

Version 2.2.3

• Fixed a bug that caused item actors to have the wrong position when an item is dropped by a hero.
• Fixed a bug that caused objects with the .hasInfiniteRange flag to be ignored by enum functions.
• Fixed an issue that caused destructables to not receive an actor after being revived.
• Removed AUTO_DEBUG_MODE and AUTO_SELECT config options. Instead, added ALICE_Debug function to enable debug mode.
• Stationary flags are now always kept consistent among multiple actors attached to one object.

No wonder, it looked so complicated and amazing, I wont be able to make use of it, but I'm gonna say it still, it looks freaking amazing, good job.

A bummer, but you can always make the switch to Lua . It's worth it!

 

[Antares]

New version that fully enables asynchronous execution, adds a smorgasbord of new features, and fixes some of the remaining inconsistencies and bugs.

Version 2.3

• Asynchronous actors can now be paired with synchronous actors without risking a desync.
• ALICE will now throw an error when the interaction function between two actors is ambiguous.
• Shadowing interaction functions (such as {"unit" = DamageUnit, [{"unit", "hero"}] = DamageHero}) is now supported.
• Improved config annotations. Config variables are not stored in the ALICE_Config table.
• The destroyOnDeath flag has been replaced with persistOnDeath, which does the opposite. By default, all actors are now destroyed on a widget's death.
• Added the width and height flags for actors, which can be used to create non-square actors.
• The ALICE_Kill function can now also destroy unit- and image-based visuals.
• Added the Rects CAT, which contains helper functions for creating actors from rects.
• Added the onUnitChangeOwner option for ALICE_OnWidgetEvent.
• Added the ALICE_SetInteraction function, which can modify the interaction table of an actor after creation.
• Added the ALICE_FindField function, which returns the field in a table whose key matches an object's identifier.
• Added the ALICE_GetAnchoredObject function, which returns objects anchored to the specified object.
• Removed the ALICE_GetActor and ALICE_ForAllActorsDo functions.
• ALICE_HasActor now has an optional flag to exclude actors only anchored to the object.
• Added the ALICE_FuncSetName function so that interaction functions don't have to be globals in order for their names to be displayed in debug tooltips.
• Pair Access functions can now access self-interactions by passing a function as the second argument.
• The CAT_AnimateShadow function now uses images instead of special effects.
• In the Collisions CAT, passing a table for onObjectDamage now works.
• Fixed a bug that caused a destructable or item being removed or picked up to not destroy all actors if it has multiple.
• Fixed a bug that caused ALICE_Kill to not destroy all actors on an object with multiple actors.
• Fixed an issue that caused anchoring to an object that is itself anchored to another object to not work.

 

[Wrda]

As I've discussed with Antares about several aspects of the resource elsewhere, I'll publish here my notes for reference.

Spoiler: Review of the previous version

local function OnUnitChangeOwner()
        local u = GetTriggerUnit()
        local newOwner = GetOwningPlayer(u)
        unitOwnerFunc[newOwner] = unitOwnerFunc[newOwner] or function() return newOwner end
        if actorOf[u] then
            if actorOf[u].isActor then
                actorOf[u].getOwner = unitOwnerFunc[newOwner]
            else
                for __, actor in ipairs(actorOf[u]) do
                    actor.getOwner = unitOwnerFunc[newOwner]
                end
            end
        end
    end
    SetOwnerFuncs = function(self, source)
        if source then
            if IsHandle[source] then
                if HandleType[source] == "unit" then
                    local owner = GetOwningPlayer(source)
                    unitOwnerFunc[owner] = unitOwnerFunc[owner] or function() return owner end
                    self.getOwner = unitOwnerFunc[owner]
                else
                    self.getOwner = ReturnNil
                end
            elseif type(source) == "table" then
                if type(source.owner) == "number" then
                    self.getOwner = GetClassOwnerById
                elseif source.owner then
                    self.getOwner = GetClassOwner
                else
                    self.getOwner = ReturnNil
                end
            end
        end
        if self.getOwner == ReturnNil and source ~= self.anchor then
            SetOwnerFuncs(self, self.anchor)
        else
            self.sourceOfOwner = source
        end
    end

I wonder if you could rework this in a way to avoid the creation of anonymous functions.
sort(pairTypes, function(a, b) return a[4] > b[4] end)
This should be a straightforward one to rework.

CreateOnDeathTrigger = function(self)
        if IsWidget[self.host] then
            self.destroyOnDeathTrigger = CreateTrigger()
            TriggerRegisterDeathEvent(self.destroyOnDeathTrigger, self.host)
            TriggerAddAction(self.destroyOnDeathTrigger, function() Destroy(self) end)
        elseif IsWidget[self.anchor] then
            self.destroyOnDeathTrigger = CreateTrigger()
            TriggerRegisterDeathEvent(self.destroyOnDeathTrigger, self.anchor)
            TriggerAddAction(self.destroyOnDeathTrigger, function() Destroy(self) end)
        else
            Warning("|cffff0000Warning:|r Cannot use automatic onDeath clean-up with non-widget hosts.")
        end
    end

Another potential rework.

local objects = ALICE_EnumObjectsInRange(mouseX, mouseY, 500, {MATCHING_TYPE_ALL}, nil)
It seems it would be better to reuse a table in the stack.

---Executes the function onBreakFunc(objectA, objectB, pairData, wasDestroyed) when a pair using the specified function is destroyed, the actors leave interaction range. Only one callback per function.
    ---@param whichFunc function
    ---@param onBreakFunc function
    function ALICE_FuncSetOnBreak(whichFunc, onBreakFunc)
        functionOnBreak[whichFunc] = onBreakFunc
    end

Looking at ALICE_FuncSetOnReset you probably meant "or" here? Was leaving a bit of doubt.

---Pause the entire cycle. Optional pauseGame parameter to pause all units on the map.
    ---@param pauseGame? boolean
    function ALICE_Halt(pauseGame)
        cycle.isHalted = true
        PauseTimer(MASTER_TIMER)
        if pauseGame then
            ALICE_ForAllObjectsDo(function(unit) PauseUnit(unit, true) end, "unit")
        end
        debug.gameIsPaused = pauseGame
    end

[CODE=lua]---Slow down the ALICE cycle by the specified factor.
    ---@param factor number
    function ALICE_SlowMotion(factor)
        cycle.isHalted = false
        TimerStart(MASTER_TIMER, ALICE_MIN_INTERVAL*factor, true, Main)
        if debug.gameIsPaused then
            ALICE_ForAllObjectsDo(function(unit) PauseUnit(unit, false) end, "unit")
            debug.gameIsPaused = false
        end
    end

    ---Resume the entire cycle.
    function ALICE_Resume()
        cycle.isHalted = false
        TimerStart(MASTER_TIMER, ALICE_MIN_INTERVAL, true, Main)
        if debug.gameIsPaused then
            ALICE_ForAllObjectsDo(function(unit) PauseUnit(unit, false) end, "unit")
            debug.gameIsPaused = false
        end
    end

Can easily rework to avoid using the anonymous functions.

function ALICE_EnumObjectsInLineSegment(x1, y1, x2, y2, halfWidth, identifier, condition, ...)
        if x2 == x1 then
            return ALICE_EnumObjectsInRect(x1 - halfWidth, min(y1, y2), x1 + halfWidth, max(y1, y2), identifier, condition, ...)
        end


        ResetCoordinateLookupTables()


        local returnTable = {}
        local cells = GetTable()


        local angle = atan(y2 - y1, x2 - x1)
        local cosAngle = math.cos(angle)
        local sinAngle = math.sin(angle)

Why doesn't returnTable also use GetTable?

---Compiles the identifiers of an object into a table. Optional keyword parameter to specify actor with the keyword in its identifier for an object with multiple actors.
    ---@param object any
    ---@param keyword? string
    function ALICE_GetIdentifier(object, keyword)
        local actor = GetActor(object,keyword)
        if actor == nil then
            return
        end
        local returnTable = {}
        for key, __ in pairs(actor.identifier) do
            insert(returnTable, key)
        end
        sort(returnTable)
        return returnTable
    end

Same here.
There's ALICE_GetClosestObject but no GetClosestNObjects? would be very nice to have that implemented.

objects script:

if knockbackItem then
            SetItemPosition(knockbackItem, x, y)
            xi = GetItemX(knockbackItem)
            yi = GetItemY(knockbackItem)
            if not IsTerrainPathable(x , y , PATHING_TYPE_WALKABILITY) and x - xi < 1 and x - xi > -1 and y - yi < 1 and y - yi > -1 then
                SetUnitX(u, x)
                SetUnitY(u, y)
            else
                knockbackSpeed[u].x = 0
                knockbackSpeed[u].y = 0
                ALICE_PairPause()
                return
            end
            SetItemPosition(knockbackItem, WORLD_MIN_X, WORLD_MIN_Y)
        else
            SetUnitX(u, x)
            SetUnitY(u, y)
        end

Would be better to encapsulate the pathing check method into a function, which also solves the need of moving the item back to unaccessable spot, which right now is being skipped if the path isn't walkable.

---@param u unit
    ---@param vx number
    ---@param vy number
    ---@param vz number
    function CAT_Knockback(u, vx, vy, vz)
        if not knockbackSpeed[u] then
            knockbackSpeed[u] = {}
            ALICE_AddSelfInteraction(u, CAT_ApplyKnockback, "CAT")
            knockbackSpeed[u].x = 0
            knockbackSpeed[u].y = 0
            knockbackSpeed[u].z = 0
        else
            ALICE_Unpause(u, nil, "unit")
        end


        knockbackSpeed[u].x = (knockbackSpeed[u].x) + vx
        knockbackSpeed[u].y = (knockbackSpeed[u].y) + vy
    end

Unused "vz" parameter.

gizmos script:

CAT_GlobalReplace(widgetId, widgetType, constructorFunc)    A function that allows you to place widgets using the World Editor and replace them on map initialization with
                                                                gizmos. The constructorFunc is the function creating your gizmo. It will be called with the parameters
                                                                (x, y, z, mana, owner, facing, unit) if the replaced widget is a unit, (x, y, z, life, widget) if the widget is a
                                                                destructable, and (x, y, z, widget) if it is an item.

The comment is missing the life parameter if it's a unit or item. On the function itself, it's only missing the life parameter.

local z_x1 = GetTerrainZ(x - 4, y)
        local z_x2 = GetTerrainZ(x + 4, y)
        local z_y1 = GetTerrainZ(x, y - 4)
        local z_y2 = GetTerrainZ(x, y + 4)
        local dz_x = (z_x2 - z_x1)/8
        local dz_y = (z_y2 - z_y1)/8

I would like to know why it's these magic numbers and not some other value

if dist < 0 then
            if gizmo.onTerrainCollision then
                gizmo:onTerrainCollision(GetTerrainCollisionPoint(gizmo))
            else
                ALICE_Kill(gizmo)
            end
            gizmo.lastTerrainCollisionCheck = ALICE_TimeElapsed
            return INTERVAL
        elseif vHorizontal - gizmo.vz < 200 then
            gizmo.lastTerrainCollisionCheck = ALICE_TimeElapsed
            return dist/600
        else
            gizmo.lastTerrainCollisionCheck = ALICE_TimeElapsed
            return dist/(3*(vHorizontal - gizmo.vz))
        end

Another set of magic numbers.

elseif widgetType == "destructable" then
            EnumDestructablesInRect(bj_mapInitialPlayableArea, nil, function()
                local d = GetEnumDestructable()
                if GetDestructableTypeId(d) == widgetId then
                    local x = GetDestructableX(d)
                    local y = GetDestructableY(d)
                    local z = GetTerrainZ(x, y)
                    local life = GetDestructableLife(d)
                    constructorFunc(x, y, z, life, d)
                    RemoveDestructable(d)
                end
            end)
        elseif widgetType == "item" then
            EnumItemsInRect(bj_mapInitialPlayableArea, nil, function()
                local i = GetEnumItem()
                if GetItemTypeId(i) == widgetId then
                    local x = GetItemX(i)
                    local y = GetItemY(i)
                    local z = GetTerrainZ(x, y)
                    constructorFunc(x, y, z, i)
                    RemoveItem(i)
                end
            end)
        end

The creation of anonymous functions are easily avoidable here.

Can always optimize parts such as

local norm = missile.speed/sqrt(missile.vx^2 + missile.vy^2 + missile.vz^2)

and in other places, where you replace to the power of 2 with multiplication of the variable with itself.

effects script:
Would be nice for "CAT_Shadow.mdl" to be a configurable, allows users to create other types of shadows independently.

---@param gizmo table
    local function InitAnimateShadow(gizmo)
        gizmo.shadow = AddSpecialEffect("CAT_Shadow.mdl", gizmo.x, gizmo.y)
        BlzSetSpecialEffectTimeScale(gizmo.shadow, 0)
        if gizmo.shadowHeight > gizmo.shadowWidth then
            BlzSetSpecialEffectTime(gizmo.shadow, 1 + 0.25*(gizmo.shadowHeight/gizmo.shadowWidth - 1))
            BlzSetSpecialEffectScale(gizmo.shadow, gizmo.shadowWidth/200)
            gizmo.shadowOffsetY = 0.15*gizmo.shadowWidth
            gizmo.shadowOffsetX = 0.25*gizmo.shadowWidth
            gizmo.shadowOffsetZ = 0.1*gizmo.shadowHeight
            gizmo.shadowAttenuation = 12/gizmo.shadowWidth
        else
            BlzSetSpecialEffectTime(gizmo.shadow,  1 - 0.25*(gizmo.shadowWidth/gizmo.shadowHeight - 1))
            BlzSetSpecialEffectScale(gizmo.shadow, gizmo.shadowHeight/200)
            gizmo.shadowOffsetY = 0.15*gizmo.shadowHeight
            gizmo.shadowOffsetX = 0.25*gizmo.shadowHeight
            gizmo.shadowOffsetZ = 0.1*gizmo.shadowWidth
            gizmo.shadowAttenuation = 12/gizmo.shadowHeight
        end
    end

Where do these numbers 0.25 0.15 0.1 12 come from?

function CAT_Orient2D(gizmo)
        if gizmo.vx ~= 0 or gizmo.vy ~= 0 then
            BlzSetSpecialEffectYaw(gizmo.visual, atan2(gizmo.vy, gizmo.vx))
        end
        if gizmo.isResting then
            ALICE_PairPause()
        end
        return 0.1
    end


    function CAT_Orient3D(gizmo)
        if gizmo.vx ~= 0 or gizmo.vy ~= 0 or gizmo.vz ~= 0 then
            BlzSetSpecialEffectOrientation(gizmo.visual, atan2(gizmo.vy, gizmo.vx), atan2(-gizmo.vz, sqrt(gizmo.vx^2 + gizmo.vy^2)), 0)
        end
        if gizmo.isResting then
            ALICE_PairPause()
        end
        return 0.1
    end


    function CAT_OrientPropelled2D(gizmo)
        if gizmo.ax ~= 0 or gizmo.ay ~= 0 then
            BlzSetSpecialEffectYaw(gizmo.visual, atan2(gizmo.ay, gizmo.ax))
        end
        return 0.1
    end


    function CAT_OrientPropelled3D(gizmo)
        if gizmo.ax ~= 0 or gizmo.ay ~= 0 or gizmo.az ~= 0 then
            BlzSetSpecialEffectOrientation(gizmo.visual, atan2(gizmo.ay, gizmo.ax), atan2(-gizmo.az, sqrt(gizmo.ax^2 + gizmo.ay^2)), 0)
        end
        return 0.1
    end

Worth mentioning what the return value represents.

local function WidgetCollisionMath2D(gizmo, widget)
        local data = ALICE_PairLoadData()
        local xa, ya, xb, yb = ALICE_PairGetCoordinates2D()
        local dx, dy = xa - xb, ya - yb
        local vxa, vya = CAT_GetObjectVelocity2D(gizmo)
        local vxb, vyb = CAT_GetObjectVelocity2D(widget)
        local dvx, dvy = vxa - vxb, vya - vyb
        local dist = sqrt(dx*dx + dy*dy)


        local nx, ny = dx/dist, dy/dist
        local collisionX, collisionY
        local overlap = data.radius + gizmo.collisionRadius - dist


        local normalSpeed = -(nx*dvx + ny*dvy)


        if normalSpeed < 0 then
            return false
        end


        collisionX = xb + nx*data.radius
        collisionY = yb + ny*data.radius


        local totalSpeed = sqrt(dvx*dvx + dvy*dvy)
        local tangentialSpeed = sqrt(totalSpeed^2 - normalSpeed^2)


        local massA = CAT_GetObjectMass(gizmo)
        local massB = CAT_GetObjectMass(widget)
        local massSum = massA + massB
        local centerOfMassVx, centerOfMassVy


        if massA == INF then
            if massB == INF then
                centerOfMassVx = (vxa*massA + vxb*massB)/massSum
                centerOfMassVy = (vya*massA + vyb*massB)/massSum
            else
                centerOfMassVx = vxa
                centerOfMassVy = vya
            end
        elseif massB == INF then
            centerOfMassVx = vxb
            centerOfMassVy = vyb
        else
            centerOfMassVx = (vxa*massA + vxb*massB)/massSum
            centerOfMassVy = (vya*massA + vyb*massB)/massSum
        end


        return true, xa, ya, xb, yb, dist,
        vxa, vya, vxb, vyb,
        dx, dy, dvx, dvy,
        nx, ny,
        collisionX, collisionY, overlap,
        massA, massB,
        normalSpeed, totalSpeed, tangentialSpeed,
        centerOfMassVx, centerOfMassVy
    end

Worth recycling the table when no longer needed.

--------------------
    --Collision Checks
    --------------------


    local function InitDestructableCollisionCheck2D(gizmo, destructable)
        local data = ALICE_PairLoadData()
        local id = GetDestructableTypeId(destructable)
        data.radius = WIDGET_TYPE_COLLISION_RADIUS[id] or DEFAULT_DESTRUCTABLE_COLLISION_RADIUS
        data.collisionRange = data.radius + gizmo.collisionRadius
        gizmo.maxSpeed = gizmo.maxSpeed or DEFAULT_GIZMO_MAX_SPEED
    end


    function CAT_DestructableCollisionCheck2D(gizmo, destructable)
        local data = ALICE_PairLoadData()
        local dist = ALICE_PairGetDistance2D()


        if dist < data.collisionRange then
            local callback = FindCallback(gizmo, "onDestructableCollision")
            if callback then
                callback(gizmo, destructable)
            else
                ALICE_Kill(gizmo)
            end
        end


        if gizmo.isResting then
            ALICE_PairPause()
        end


        return (dist - data.collisionRange)/gizmo.maxSpeed
    end


   --===========================================================================================================================================================
    --Gizmo-Item Collisions
    --==========================================================================================================================================================


    --------------------
    --Collision Checks
    --------------------


    local function InitItemCollisionCheck2D(gizmo, item)
        local data = ALICE_PairLoadData()
        local id = GetItemTypeId(item)
        data.collisionRange = (WIDGET_TYPE_COLLISION_RADIUS[id] or DEFAULT_ITEM_COLLISION_RADIUS) + gizmo.collisionRadius
        gizmo.maxSpeed = gizmo.maxSpeed or DEFAULT_GIZMO_MAX_SPEED
    end


    function CAT_ItemCollisionCheck2D(gizmo, item)
        local data = ALICE_PairLoadData()
        local dist = ALICE_PairGetDistance2D()


        if dist < data.collisionRange then
            local callback = FindCallback(gizmo, "onItemCollision")
            if callback then
                callback(gizmo, item)
            else
                ALICE_Kill(gizmo)
            end
        end


        if gizmo.isResting then
            ALICE_PairPause()
        end


        return (dist - data.collisionRange)/gizmo.maxSpeed
    end

Same here.

local function InitDestructableCollisionCheck3D(gizmo, destructable)
        local data = ALICE_PairLoadData()
        local id = GetDestructableTypeId(destructable)
        data.radius = WIDGET_TYPE_COLLISION_RADIUS[id] or DEFAULT_DESTRUCTABLE_COLLISION_RADIUS
        data.height = WIDGET_TYPE_HEIGHT[id] or DEFAULT_DESTRUCTABLE_HEIGHT
        data.collisionRange = data.radius + gizmo.collisionRadius
        data.maxdz = data.height/2 + gizmo.collisionRadius
        gizmo.maxSpeed = gizmo.maxSpeed or DEFAULT_GIZMO_MAX_SPEED
        data.xDest, data.yDest, data.zDest = ALICE_GetCoordinates3D(destructable)
    end


    function CAT_DestructableCollisionCheck3D(gizmo, destructable)
        local data = ALICE_PairLoadData()
        local dx, dy, dz
        if gizmo.x  then
            dx, dy, dz = data.xDest - gizmo.x, data.yDest - gizmo.y, data.zDest - gizmo.z
        else
            local x, y, z = ALICE_GetCoordinates3D(gizmo)
            dx, dy, dz = data.xDest - x, data.yDest - y, data.zDest - z
        end
        local horiDist = sqrt(dx*dx + dy*dy)
        local dist


        if horiDist < data.collisionRange and dz < data.maxdz and dz > -data.maxdz then
            local dtop = data.height/2 - dz
            if dtop < data.radius then
                dist = sqrt(horiDist*horiDist + (dtop - data.radius)^2)
            else
                dist = horiDist
            end
            if dist < data.collisionRange then
                local callback = FindCallback(gizmo, "onDestructableCollision")
                if callback then
                    callback(gizmo, destructable)
                else
                    if gizmo.onDestructableDamage then
                        DamageWidget(gizmo, destructable)
                    end
                    ALICE_Kill(gizmo)
                end
            end
        else
            dist = sqrt(horiDist*horiDist + dz*dz)
        end


        if gizmo.isResting then
            ALICE_PairPause()
        end


        return (horiDist - data.collisionRange)/gizmo.maxSpeed
    end

Same thing as the 2D counterpart.

ballistics script:

local PI                                = bj_PI
You can store it with math.pi() :P


    ---@param xLaunch number
    ---@param yLaunch number
    ---@param zLaunch number
    ---@param xTarget number
    ---@param yTarget number
    ---@param zTarget number
    ---@param angle number
    ---@return number | nil, number | nil, number | nil
    function CAT_GetBallisticLaunchSpeedFromAngle(xLaunch, yLaunch, zLaunch, xTarget, yTarget, zTarget, angle)
        local dx = xTarget - xLaunch
        local dy = yTarget - yLaunch
        local dz = zTarget - zLaunch
        local dist = sqrt(dx^2 + dy^2)
        local vSquared = (GRAVITY*dist^2/(2*cos(angle)^2))/(dist*tan(angle) - dz)
        if vSquared < 0 then
            return nil, nil, nil
        end
        local velocity = sqrt(vSquared)
        return velocity*cos(angle)*dx/dist, velocity*sin(angle)*dy/dist, velocity*sin(angle)
    end

Potential space for optimization such as store cos(angle) and sin(angle).

local function InitMoveablesCAT()
        Require "ALICE"
        Require "CAT_Objects"
        Require "PrecomputedHeightMap"
        INTERVAL = ALICE_MIN_INTERVAL
        ALICE_FuncSetInit(CAT_MoveBallistic, InitMoveBallistic)
        ALICE_RecognizeFields(
            "vx",
            "vy",
            "vz",
            "friction",
            "isResting",
            "collisionRadius"
        )
        ALICE_FuncRequireFields(CAT_MoveBallistic, true, false, "x", "y", "z", "vx", "vy", "collisionRadius")
    end

INTERVAL is a global and is very susceptible for name clashing.
Objects' script configuration is before you listing the possible functions to use, while on collisions 2D, forces 2D and possible others have the the list of functions before the configuration. So seems inconsistent at the moment.

This is the review of the last update:

Spoiler: Review of the current version

Force2D script:

local function ClearForce2D(source, target)
        local data = ALICE_PairLoadData(forceMatrix)
        local FxOld = data.Fx + data.Fxdt*(ALICE_TimeElapsed - data.lastUpdate)
        local FyOld = data.Fy + data.Fydt*(ALICE_TimeElapsed - data.lastUpdate)
        local FxdtOld = data.Fxdt
        local FydtOld = data.Fydt

        local forceTable
        if data.targetIsGizmo then
            forceTable = target
        else
            forceTable = unitForce[target]
        end
        

        if forceTable then
            forceTable.Fx = forceTable.Fx - FxOld
            forceTable.Fy = forceTable.Fy - FyOld
            forceTable.Fxdt = forceTable.Fxdt - FxdtOld
            forceTable.Fydt = forceTable.Fydt - FydtOld
        end
    end




    local function InitForce2D(source, target)
        local data = ALICE_PairLoadData(forceMatrix)
        data.lastUpdate = ALICE_TimeElapsed
        data.targetIsGizmo = type(target) == "table"
        if data.targetIsGizmo then
            data.typeMultiplier = 1
            if target.Fx == nil then
                ALICE_AddSelfInteraction(target, AccelerateGizmo2D)
                ALICE_AddSelfInteraction(target, ResumForceGizmo2D)
                target.Fx, target.Fy = 0, 0
                target.Fxdt, target.Fydt = 0, 0
            end
        elseif HandleType[target] == "unit" then
            data.typeMultiplier = FORCE_UNIT_MULTIPLIER
            if unitForce[target] == nil then
                unitForce[target] = {}
                local forceTable = unitForce[target]
                ALICE_AddSelfInteraction(target, AccelerateUnit2D)
                ALICE_AddSelfInteraction(target, ResumForceUnit2D)
                forceTable.Fx, forceTable.Fy = 0, 0
                forceTable.Fxdt, forceTable.Fydt = 0, 0
            end
        end
    end

source parameter isn't being used at all. Are you going to expand later, or it simply serves as a model for users to expand? Would be nice for unitForce[target] = {} to use the GetTable() functionality.

local dist = sqrt(dx^2 + dy^2)
Potential spot for optimization

local function GravityForce2D(source, target, data, dist, dx, dy, dvx, dvy)
        if data.minDistance > dist then
            dist = data.minDistance
        end
        local factor = data.strength/dist^3
        return dx*factor, dy*factor
    end


    local function GravityInterval2D(source, target, data, dist, dx, dy, dvx, dvy)
        --Increased update frequency when objects are moving towards each other.
        local vdotd = -(dvx*dx + dvy*dy)
        if vdotd < 0 then
            vdotd = 0
        end
        return dist^2*data.intervalFactor/(1 + vdotd*data.intervalFactor)
    end

    local function PressureForce2D(source, target, data, dist, dx, dy, dvx, dvy)
        if dist > source.pressureMaxRange then
            return 0, 0
        end
        local factor = -source.pressureStrength*data.strengthFactor*(source.pressureMaxRange - dist)/(source.pressureMaxRange*dist)
        return dx*factor, dy*factor
    end

    local function PressureInterval2D(source, target, data, dist, dx, dy, dvx, dvy)
        --Increased update frequency when objects are moving towards each other.
        local vdivd = -(dvx*dx + dvy*dy)/dist^2
        if vdivd < 0 then
            vdivd = 0
        end
        local interval = (0.15 + 0.85*(dist/source.pressureMaxRange))*data.intervalFactor/source.pressureStrength
        return interval/(1 + vdivd*interval)
    end

    local function WindForce2D(source, target, data, dist, dx, dy, dvx, dvy)
        if dist > source.windFieldMaxRange then
            return 0, 0
        end
        local dvxWind = dvx + data.vx
        local dvyWind = dvy + data.vy
        local dvWindTotal = sqrt(dvxWind^2 + dvyWind^2)
        local factor = dvWindTotal*source.windFieldDensity*data.strengthFactor*(source.windFieldMaxRange - dist)/(source.windFieldMaxRange*dist)
        return dvxWind*factor, dvyWind*factor
    end

    local function WindFieldInterval2D(source, target, data, dist, dx, dy, dvx, dvy)
        --Increased update frequency when objects are moving towards each other.
        local vdivd = -(dvx*dx + dvy*dy)/dist^2
        if vdivd < 0 then
            vdivd = 0
        end
        local interval = (0.15 + 0.85*(dist/source.windFieldMaxRange))*data.intervalFactor/source.windFieldDensity
        return interval/(1 + vdivd*interval)
    end

Same question about the unused parameters, and other spots for optimizations (PressureForce2D is fine)

local interval = (0.15 + 0.85*(dist/source.windFieldMaxRange))*data.intervalFactor/source.windFieldDensity

Where does 0.15 and 0.85 come from?

function CAT_AddForce2D(class, interactsWith, initFunc, forceFunc, intervalFunc)
        class.initForceFunc = initFunc
        class.forceFunc = forceFunc
        class.intervalFunc = intervalFunc
        if class.interactions == nil then
            class.interactions = {}
        end

Spot to use a recycled table.

Force3D script:

local function InitAccelerateUnit3D(unit)
        local data = ALICE_PairLoadData()
        data.multiplier = INTERVAL/CAT_GetObjectMass(unit)
        if data.multiplier == math.huge then
            error("Attempting to apply force to unit with no mass.")
        end
    end

    local function AccelerateUnit3D(unit)
        local data = ALICE_PairLoadData()
        local forceTable = unitForce[unit]
        if not forceTable or (forceTable.Fx == 0 and forceTable.Fy == 0 and forceTable.Fz == 0) then
            ALICE_PairPause()
            return
        end
        CAT_Knockback(unit, forceTable.Fx*data.multiplier, forceTable.Fy*data.multiplier, forceTable.Fz*data.multiplier)
        forceTable.Fx = forceTable.Fx + forceTable.Fxdt*INTERVAL
        forceTable.Fy = forceTable.Fy + forceTable.Fydt*INTERVAL
        forceTable.Fz = forceTable.Fz + forceTable.Fzdt*INTERVAL
    end

Force2D script uses forceMatrix on ALICE_PairLoadData, I'd assume you also wanted it here too.
Rest of Force3D is very similar to my comments on Force2D.

cameras script:

local newCameraRadius = math.min(MAX_CAMERA_RADIUS, 0.5*GetCameraField(CAMERA_FIELD_TARGET_DISTANCE)/(camera.angleOfAttack + 5.88))

5.88, my favourite magic number

This is now part of the Lua Bible. Extremely useful for Lua maps to go berserk with enumerations, spam units, effects, doodads, it won't disappoint you! Offers you templates of collisions, physics movement and a few more. Math is beyond my reach.

Splendid.

Spoiler: Don't read

Spoiler: Still don't read

Spoiler: OK READ NOW

No more 10k lines to read please

 

[Antares]

No more 10k lines to read please

Actually currently creating an operating system inside Warcraft 3, but after that, I promise!


Version 2.3.2

• Fixed a bug with the Forces CATs.
• Added some missing annotations and fixed a find-and-replace mishap in the config annotations

 

[Wrda]

Actually currently creating an operating system inside Warcraft 3, but after that, I promise!

 

[Antares]

Version 2.4 adds improvements to the Callback API, as well as introduces Minimal ALICE, or MINACE, which is a version of ALICE that has been stripped of everything except for the Callback API and the few functions that would make sense to be used within the callbacks. The purpose of this version is mostly to allow me to use the Callback API as a requirement for other resources without demanding from the user that they install a 5k line library.

Version 2.4

• Added MINACE, a stripped-down version of ALICE.
• Added 1.31 support by replacing BlzFrameGetChild with BlzGetFrameByName.
• The fourCC codes of widgets are now added to the default actors' identifiers.
• The ALICE_CallPeriodic function can now capture additional arguments and the interval is no longer limited by MAX_INTERVAL.
• Added the ALICE_CallRepeated function, which works like ALICE_CallPeriodic, but executes the function a set number of times.
• Added the ALICE_DisablePeriodic function, which should be used to disable periodic callbacks instead of ALICE_PairDisable.
• Removed the ALICE_CallAt function.
• Added the ALICE_GetPairState function for debug mode.
• Removed the ALICE_SlowMotion function.
• Removed the MAXIMUM_EVALUATION_TIME config parameter and the in-built freeze protection.
• Changed the ALICE_Statistics function to print function names instead of actor identifiers.
• The CAT_MoveArcedHoming function now recognizes the arcAngle field to allow missiles to not only arc vertically.
• The CAT_UnitCollisionCheck function now recognizes the onlyTarget field, which excludes all units from the collision check other than the gizmo's target.
• Instead of creating one death trigger for each actor, now at most one death trigger is created for each destructable and item.
• Added the missing onDestructableEnter, onDestructableDestroy, onItemEnter, and onItemDestroy event hooks.
• In debug mode, when clicking on a spot with multiple actors, you will now properly cycle through the different actors instead of repeatedly selecting the same one.
• Fixed a bug that caused the CAT_MoveArced function to crash when the .arcAngle field was not set.
• Fixed a bug that caused a single table passed as an additional argument into ALICE_CallDelayed to not be forwarded into the callback function.

Unfortunately, didn't quite finish the operating system in time. Maybe next update .

 

[Greedy Procrastinator]

In video i lost it at Jaina's machinegun. Sad im on 1 26 bros

 

[Xthreo]

After downloading the RPGminimap, I thought I could use ALICE to improve my missile system since it’s now installed anyway. Best thing I could do, now I’m having tremendous fun applying ALICE capabilities everywhere!
Thank you Antares for such a powerful tool!

 

[Antares]

After downloading the RPGminimap, I thought I could use ALICE to improve my missile system since it’s now installed anyway. Best thing I could do, now I’m having tremendous fun applying ALICE capabilities everywhere!
Thank you Antares for such a powerful tool!

That is so great to hear! Can I quote your testimonial in the description?

Also, I'm wondering, did you use the in-built missile functions or integrate your own into ALICE?