Matrix Games Forums

ORIGINAL: Veloz

just one question; if permitted is the AI strong; have levels.

One of the major new additions to Campaign Series game engine is the addition for being able to script AI player with CS Event Engine scripts. For the first time, AI can be given orders to have some units attack a certain location, while other units stay put holding a vital area, for instance. While these scripts are being added, we have a new team member adding these retrospectively to Middle East scenarios as well, to be made available in a future (free) UPDATE.

Meanwhile, what the game already has are these settings for AI:

[*] Generic stance Audacious / Cautious / Shifting (between the two)
[*] Aggressiveness setting (slider)
[*] Advantage setting (slider), also available in H2H play between sides IIRC.

Exciting times for wargaming vs AI

Campaign Series Vietnam: I was expanding the My Tho master map to the west to encompass Thanh Phu Island for a scenario that depicts an actions that happened in January 1964 and was pleasantly surprised to find the expansion also covers this well known site.

Boy oh boy OH BOY

Also known as my first attempt at scripting AI for my first Winter War scenario. This is what the Vietnam scenario guys have been doing now, and boy is this a game changer (all the puns intended!!!) [X(]

Scripted AI is aware which - or even both - sides are under AI, and it kicks on accordingly. So say I want to play the Soviets on this scenario vs AI? The bugger has a specific battle plan!

And here we are, at turn 4: The Finnish 3rd Coy had secured the flank, while 1st Coy had taken the main objective - and using their initiative, the smaller objective next to it as well - while the 2nd Coy had stopped at their northern most objective.

At this stage, I'd give the next orders. Upon capturing the bridge, the 3rd Coy would Halt() and Digin(), as would 3rd Coy, while 2nd Coy would Halt() just one of their platoon at the objective, while the rest of them would attack the remaining objective next to the lake, and (if) upon capturing it, would also Halt() and Digin(). That would then give the Soviet player quite a tough nut to crack for the remaining turns.

Note that in this AI-vs-AI test run, all Soviets were given an order to Hold(), so they would only sit and Op fire, so that I could observe how the optimal Finnish attack would go on. I also made a fix that the initial Finnish order would be Halt(), not Hold(), as former will allow for active firing and fire missions for Indirect units, while latter will strict to Op Fire only.

Then, once the Finns have a cunning plan (Blackadder, anyone?), I'd then move to have Soviets with a proper plan, mainly moving their reinforcements in to are where objectives have been lost.

Cool!

Another AI-vs-AI test battle, now with Soviet battle plan in place as well:

[*] Release the units west of Naykkijarvi to test out the Finnish flank
[*] Order all the tanks to Honkaniemi from word go
[*] Not yet really visible here, but unleash the units at rear guard forward come turn 6 to make it a proper counter attack

With these orders for both sides having played out, it looks like a proper Tank Battle at Honkaniemi now, doesn't it [:)]

And if you look at the different ARVN infantry, they do indeed have different camo uniforms!! Hard to teel very much in game, but the devil is in the details!!

Campaign Series Vietnam: ALPHA graphics. Here is the extent of the My Tho map expansion. Those who want to play the riverine operations will love this map! For a master map, it is "small" at 160 x 240 hexes.

I was watching the Battlefield Vietnam episode including Ap Bac today. That went sideways fast.

"A Bright Shining Lie" has a nice account too...

Current progress on the My Tho expansion for Campaign Series Vietnam.

Ample waterways for riverine battles!

Jason Petho

looking really good, thanks for the share

Thank you, zak!

There is progress everyday!

This is looking really nice Jason.....

Another recent (private) Dev Team Forum post:

ORIGINAL: berto

ORIGINAL: berto

ORIGINAL: berto

In connection with the above new Scripted AI actions, I am implementing a bunch of new map awareness capabilities. More to follow. [;)]

ORIGINAL: berto

Such as: has_bunker(hexcoor), has_minefield(hexcoor), has_light_bridge(hexcoor, DOWNRIGHTDIR), has_damage(hexcoor, DOWNDIR), etc. [:'(]

I am in the process of implementing -- would you believe? -- over 90 new map info functions.

All told, and at latest count, the CSEE will have over 340 functions! [X(]

In future, with more still to follow. [:'(]

The latest init.lua file is

---

rober@Rob10rto /cygdrive/c/Documents and Settings/rober/My Documents/Games/Matrix Games/CS/devel/work
$ wc -l "$ME"/init.lua
4146 /cygdrive/c/Games/Matrix Games/Middle East/middle_east/init.lua

---

4146 lines long.

With all of this capability and flexibility and extensibility, is there any doubt that a scripted event engine is the way to go?

If I am taking my own good time with this, it is because -- with all of this complexity, thereby with the ever increasing possibility of bugs -- we need the most robust, automated QA checking capabilities possible. That would include the CSlint utility cseechk.

The latest cseechk:



For now, this is for my development use only. I am undecided if I will include this in the standard, public Tools/CSlint package. (If I do, I will be sure to revise the Cygwin parts and adapt this to WSL.)

With all of these new CSEE functions, I need to incorporate them into the cseechk system. Also add many dozens of other functions I had neglected to incorporate earlier. Let's not forget either that I need to document all of this new stuff in the LUA_FUNCTIONS_REFERENCE.txt. It all takes time and . Lots of it. Patience.

Say, with Microsoft now packaging the WSL capability in standard Windows 10, have we mentioned that in CSVN and all future games, we will be packaging CSlint

ORIGINAL: berto

CSlint

What is CSlint? Akin to the well-known C programming language utility lint. ("Lint: A Unix C language processor which carries out more thorough checks on the code than is usual with C compilers. Lint is named after the bits of fluff it supposedly picks from programs." See here.) Similarly, CSlint is a toolkit of programs designed to discover and report bugs, problems, glitches, anomalies in the Campaign Series game data files.

If anybody thinks that CSlint is poppycock, that I'm just making this up, please read this:

http://en.wikipedia.org/wiki/Static_code_analysis

http://en.wikipedia.org/wiki/Automated_code_review

Proactive, pre-execution debugging (CSlint) vs. reactive, post-execution debugging (the traditional way).

Static analysis (CSlint) vs. dynamic analysis (playtest the game, inspect the log files).

Each approach has its strengths and weaknesses, but together they've got the bugs surrounded -- no escape!

in the standard install, thereby making it fully open and available to the playing public? Lots of modder goodies in CSlint beyond just the QA checking capabilities.

A follow-up to the previous post:

ORIGINAL: berto

Basically, this is what cseechk does: It auto runs a series of specially crafted game scenarios. Every run yields a lua.log file, which is stripped of its date/time and other special particulars, and captured in a test-specific .out (output) file. The .out files are diff'ed vs. some known-good .ref (reference output) files in the cslint directory. If there are any diff's, this indicates issues -- maybe real issues, i.e., bugs, else inconsequential testing artifacts.

Here is a small portion of the LuaFunctionsTest2.lua file:

---

------------------------------------------------------------------------------------------------------------------------

function on_startup () -- DO NOT REMOVE

log (LUALOG, LOG_DEBUG, "startup")

end

------------------------------------------------------------------------------------------------------------------------

function on_resume () -- DO NOT REMOVE



end

------------------------------------------------------------------------------------------------------------------------

function on_shutdown () -- DO NOT REMOVE

log (LUALOG, LOG_DEBUG, "shutdown")

end

------------------------------------------------------------------------------------------------------------------------

function on_next_turn (turn) -- DO NOT REMOVE

if turn == 1 then

countersa = counters_all("a")
countersb = counters_all("b")
hold(countersa)
hold(countersb)

log (LUALOG, LOG_DEBUG, "----")

log (LUALOG, LOG_DEBUG, (is_clear_hex ("49,56") and 1 or 0) .. " is_clear_hex ()")
log (LUALOG, LOG_DEBUG, (is_clear_hex ("60,57") and 1 or 0) .. " is_clear_hex ()")

log (LUALOG, LOG_DEBUG, (is_water_hex ("82,28") and 1 or 0) .. " is_water_hex ()")
log (LUALOG, LOG_DEBUG, (is_water_hex ("82,29") and 1 or 0) .. " is_water_hex ()")

log (LUALOG, LOG_DEBUG, (is_forest_hex ("0,0") and 1 or 0) .. " is_forest_hex ()")
log (LUALOG, LOG_DEBUG, (is_forest_hex ("0,0") and 1 or 0) .. " is_forest_hex ()")

log (LUALOG, LOG_DEBUG, (is_marsh_hex ("36,230") and 1 or 0) .. " is_marsh_hex ()")
log (LUALOG, LOG_DEBUG, (is_marsh_hex ("36,229") and 1 or 0) .. " is_marsh_hex ()")

log (LUALOG, LOG_DEBUG, (is_building_hex ("43,60") and 1 or 0) .. " is_building_hex ()")
log (LUALOG, LOG_DEBUG, (is_building_hex ("41,56") and 1 or 0) .. " is_building_hex ()")

log (LUALOG, LOG_DEBUG, (is_village_hex ("52,53") and 1 or 0) .. " is_village_hex ()")
log (LUALOG, LOG_DEBUG, (is_village_hex ("49,51") and 1 or 0) .. " is_village_hex ()")

...

log (LUALOG, LOG_DEBUG, (is_unpaved_side ("45,182", UPLEFTDIR) and 1 or 0) .. " is_unpaved_side ()")
log (LUALOG, LOG_DEBUG, (is_unpaved_side ("45,182", UPRIGHTDIR) and 1 or 0) .. " is_unpaved_side ()")

log (LUALOG, LOG_DEBUG, (has_minefield ("47,53") and 1 or 0) .. " has_minefield ()")
log (LUALOG, LOG_DEBUG, (has_minefield ("47,52") and 1 or 0) .. " has_minefield ()")

...

end

log (LUALOG, LOG_DEBUG, "----")

end

...

---

The point being to log (to lua.log) output for every CSEE function, to monitor its effects (also to syntax check and otherwise QA check the whole shebang).

Here is a recent cseechk test run, just the Cygwin terminal session (with the game screens etc. omitted):

---

rober@Rob10rto ~/cslint
$ ./cseechk -R

LuaFunctionsTest1

289,290c289,290
< [DEBUG ID 10] (lua.cpp, l_log()) 59 strength ()
< [DEBUG ID 10] (lua.cpp, l_log()) 59 total_strength ()
---
> [DEBUG ID 10] (lua.cpp, l_log()) 65 strength ()
> [DEBUG ID 10] (lua.cpp, l_log()) 65 total_strength ()

LuaFunctionsTest2

0a1,92
> [DEBUG ID 10] (lua.cpp, l_log()) startup
> [DEBUG ID 10] (lua.cpp, l_log()) ----
> [DEBUG ID 10] (lua.cpp, l_log()) 1 is_clear_hex ()
> [DEBUG ID 10] (lua.cpp, l_log()) 0 is_clear_hex ()
> [DEBUG ID 10] (lua.cpp, l_log()) 1 is_water_hex ()
> [DEBUG ID 10] (lua.cpp, l_log()) 0 is_water_hex ()
> [DEBUG ID 10] (lua.cpp, l_log()) 0 is_forest_hex ()
> [DEBUG ID 10] (lua.cpp, l_log()) 0 is_forest_hex ()
> [DEBUG ID 10] (lua.cpp, l_log()) 1 is_marsh_hex ()
> [DEBUG ID 10] (lua.cpp, l_log()) 0 is_marsh_hex ()
> [DEBUG ID 10] (lua.cpp, l_log()) 1 is_building_hex ()
> [DEBUG ID 10] (lua.cpp, l_log()) 0 is_building_hex ()
> [DEBUG ID 10] (lua.cpp, l_log()) 1 is_village_hex ()
> [DEBUG ID 10] (lua.cpp, l_log()) 0 is_village_hex ()
...
> [DEBUG ID 10] (lua.cpp, l_log()) 1 is_unpaved_side ()
> [DEBUG ID 10] (lua.cpp, l_log()) 0 is_unpaved_side ()
> [DEBUG ID 10] (lua.cpp, l_log()) 1 has_minefield ()
> [DEBUG ID 10] (lua.cpp, l_log()) 0 has_minefield ()
> [DEBUG ID 10] (lua.cpp, l_log()) ----
> [DEBUG ID 10] (lua.cpp, l_log()) shutdown

ScriptedAITest1
[nil]

---

In the first test, for LuaFunctionsTest1, that output is inconsequential, is just a testing artifact (I still need to debug that in the cseechk setup and processing).

In the second test, for LuaFunctionsTest2, that is stripped lua.log output, diffed against the ~/cslint/LuaFunctionsTest2.ref. When I have implemented the new stuff for this LuaFunctionsTest2, and verified that all looks good, I will copy this .out over to the cslint directory as the known-good .ref file for this test.

In the third test, for ScriptedAITest1, there being no output (the "[nil]"), I infer from that there are no issues with that test -- i.e., the Scripted AI component of the CSEE is functioning well and is bug-free (AFAIK!).

Like so many other things I do on a routine basis -- run crash/freeze/error scenario AI vs. AI auto-tests just about daily; using CSlint, QA check the CS game data files every week or so -- I am in the habit of running cseechk quite often. Especially as the CSEE is so very much still an ongoing work-in-progress. Especially as the CSEE grows in complexity and the risk of bugs increases. Must do the regression tests religiously. Must. Stay. On. Top. Of. Things. Must keep those bugs in check!

Campaign Series Vietnam: ALPHA graphics. While doing some reading on the riverine fighting, it was determined that the My Tho master map needed to be expanded 10 kilometres to the west to encompass the "Snoopy's Nose" Area. The Cam Son Base area.

Noting the Song Nam Thon river channel in the above screenshot...

This area was the site of the "Halloween Massacre" on October 31, 1966 where a couple of PBR's (PBR 105 and PBR 107) under the command of James Williams spent the day sinking junks and sampans while being engaged from the riverbanks from machine gun fire. Seawolves and additional PBR's came to assist. Intelligence reports suggest the actual prevented a battalion sized river crossing, killed ~50 troops and sank/destroyed 28 sampans and 6 junks, damaging another 25.

This sounds like an interesting action to portray in a scenario, I'm just not sure how well it would work with the map scale.

In the CSEE (Campaign Series Event Engine), the latest Lua functions, nearly 350 of them, with more still to come:

---

TRIGGERS

on_air_attack (x, y, pid, name, side, nation, points, strength)
on_hex_attack (x, y, side, nation)
on_ied_attack (x, y, trackid, pid, name, side, nation, oid, orgname, points, strength, HQ, Leader)
on_mine_attack (x, y, trackid, pid, name, side, nation, oid, orgname, points, strength, HQ, Leader)
on_next_phase (turn, side)
on_next_turn (turn)
on_objective_capture (x, y, values, side)
on_resume ()
on_shutdown ()
on_startup ()
on_unit_attack (x, y, trackid, pid, name, side, nation, oid, orgname, points, strength, HQ, Leader)
on_unit_kill (x, y, trackid, pid, name, side, nation, oid, orgname, points, strength, HQ, Leader)
on_unit_reduce (x, y, trackid, pid, name, side, nation, oid, orgname, points, strength, HQ, Leader, loss)
on_unit_reinforce (x, y, trackid, pid, name, side, nation, oid, orgname, points, strength, HQ, Leader)
on_unit_release (trackid, pid, name, side, nation, oid, orgname, points, strength, HQ, Leader)
on_unit_remove (x, y, trackid, pid, name, side, nation, oid, orgname, points, strength, HQ, Leader)

AI

ai (side)
ai_index (parm)
ai_parameter (index)
adaptive_ai (side, nation, index)
inc_adaptive_ai (side, nation, index, increment)
is_ai (side)
max_ai_index ()
set_adaptive_ai (side, nation, index, value)

COUNTERS

counter_airlevel (trackid)
counter_assault (trackid)
counter_ctrackid (trackid)
counter_defend (trackid)
counter_exists (trackid)
counter_flags (trackid)
counter_hex (trackid)
counter_hq (trackid)
counter_is_airborne (trackid)
counter_is_hq (trackid)
counter_is_leader (trackid)
counter_leader (trackid)
counter_morale (trackid)
counter_more_flags (trackid)
counter_name (trackid)
counter_nation (trackid)
counter_oid (trackid)
counter_orgname (trackid)
counter_pid (trackid)
counter_points (trackid)
counter_side (trackid)
counter_strackid (trackid)
counter_strength (trackid)
counter_turns_to_outoffuel (trackid)
counter_type (trackid)
counter_x (trackid)
counter_y (trackid)

is_disrupted (trackids)
is_carried (trackids)
is_unloaded (trackids)
is_loaded (trackids)
is_concealed (trackids)
is_outofammo (trackids)
is_diggingin (trackids)
is_fatigued (trackids)
is_fixed (trackids)
is_lowonammo (trackids)
is_isolated (trackids)
is_reduced (trackids)
is_lowonfuel (trackids)
is_outoffuel (trackids)

counters_all (side)
counters_aorg (trackids)
counters_sorg (strackids)

map_trackid (hexcoor, number)
map_trackid_count (hexcoor)
map_trackids (hexcoor)
max_counters ()

GENERAL

first_side ()
current_side ()
other_side (side)

current_turn ()
next_turn ()
previous_turn ()
final_turn ()

current_visibility ()

night (turn)
fow (side)
is_fow (side)
is_night ()

HEXES

has_big_wrecks (hexcoor)
has_block (hexcoor)
has_bunker (hexcoor)
has_cave (hexcoor)
has_damage (hexcoor, dir)
has_ied (hexcoor)
has_ied1 (hexcoor)
has_ied2 (hexcoor)
has_ied3 (hexcoor)
has_improved_position (hexcoor)
has_landing_zone (hexcoor)
has_light_bridge (hexcoor)
has_minefield (hexcoor)
has_minefield1 (hexcoor)
has_minefield2 (hexcoor)
has_minefield3 (hexcoor)
has_obstacle (hexcoor)
has_pillbox (hexcoor)
has_pontoon_bridge (hexcoor)
has_rubble (hexcoor)
has_smoke (hexcoor)
has_trench (hexcoor)
has_tunnel (hexcoor)
has_vehicle_bridge (hexcoor)
has_wrecks (hexcoor)

is_sidea_aware (hexcoor)
is_sidea_exclude (hexcoor)
is_sideb_aware (hexcoor)
is_sideb_exclude (hexcoor)

is_airfield_hex (hexcoor)
is_beach_hex (hexcoor)
is_building_hex (hexcoor)
is_cactus_hex (hexcoor)
is_canal_hex (hexcoor)
is_canal_shallow_hex (hexcoor)
is_city_hex (hexcoor)
is_clear_hex (hexcoor)
is_colored_dirt_hex (hexcoor)
is_dense_jungle_hex (hexcoor)
is_dry_paddy_hex (hexcoor)
is_forest_hex (hexcoor)
is_grain_field_hex (hexcoor)
is_hammada_hex (hexcoor)
is_impass_hex (hexcoor)
is_industrial_hex (hexcoor)
is_installation_hex (hexcoor)
is_light_jungle_hex (hexcoor)
is_major_canal_hex (hexcoor)
is_major_canal_shallow_hex (hexcoor)
is_major_river_hex (hexcoor)
is_major_river_shallow_hex (hexcoor)
is_marsh_hex (hexcoor)
is_meadow_hex (hexcoor)
is_orchard_hex (hexcoor)
is_palm_tree_hex (hexcoor)
is_produce_field_hex (hexcoor)
is_river_hex (hexcoor)
is_river_shallow_hex (hexcoor)
is_rough_hex (hexcoor)
is_scrub_hex (hexcoor)
is_shallow_hex (hexcoor)
is_soft_sand_hex (hexcoor)
is_suburb_hex (hexcoor)
is_swamp_hex (hexcoor)
is_tall_grass_hex (hexcoor)
is_thicket_hex (hexcoor)
is_village_hex (hexcoor)
is_vineyard_hex (hexcoor)
is_wadi_hex (hexcoor)
is_water_hex (hexcoor)
is_wet_paddy_hex (hexcoor)

LUAVs

luav (index)
inc_luav (index, increment)
max_luav_index ()
set_luav (index, value)

MAP

on_map (hexcoor)

map_center (x, y)
map_height ()
map_slice (x, y)
map_up ()
map_width ()

map_up_half (x, y)
map_low_half (x, y)
map_left_half (x, y)
map_right_half (x, y)
map_up_left_quadrant (x, y)
map_up_right_quadrant (x, y)
map_low_right_quadrant (x, y)
map_low_left_quadrant (x, y)
map_nw_quadrant (x, y)
map_ne_quadrant (x, y)
map_se_quadrant (x, y)
map_sw_quadrant (x, y)
map_north_half (x, y)
map_south_half (x, y)
map_east_half (x, y)
map_west_half (x, y)
map_above (row, side)
map_below (row, side)
map_left_of (col, side)
map_right_of (col, side)

map_above_count (row, side)
map_below_count (row, side)
map_left_of_count (col, side)
map_right_of_count (col, side)

map_side (hexcoor)

hexcoor (x, y)
x (hexcoor)
y (hexcoor)

range (from, to)
within (trackids, hexcoor, distance)
units_within_count (hexcoor, distance, side)

MESSAGING

_message (title, text)
message (humanonly, title, text)
message_once (humanonly, title, text, index)
_note (title, text)
note (humanonly, title, text)
note_once (humanonly, title, text, index)
log (logfile, loglevel, text)
debug (text)

MISC

ordinal (number)
random (x)

has_flag (flags, flag)

join (lists)

OBJECTIVES

objective_owner (hexcoor)
objective_points ()
objective_values (hexcoor)

set_objective (hexcoor, values, side)
set_objective_values (hexcoor, values)

REINFORCEMENTS

reinforcement_flags (id)
reinforcement_hex (id)
reinforcement_prob (id)
reinforcement_scatter (id)
reinforcement_turn (id)
reinforcement_x (id)
reinforcement_y (id)

set_reinforcement (id, hexcoor, turn, prob, flags, scatter)
set_reinforcement_flags (id, flags)
set_reinforcement_hex (id, hexcoor)
set_reinforcement_prob (id, prob)
set_reinforcement_scatter (id, scatter)
set_reinforcement_turn (id, turn)
set_reinforcement_x (id, x)
set_reinforcement_y (id, y)

inc_reinforcement_prob (id, increment)

arrived (id)

RELEASES

release_prob (id)
release_turn (id)
released (id)

set_release (id, turn, prob)
set_release_prob (id, prob)
set_release_turn (id, turn)

inc_release_prob (id, increment)

SCENARIO

event_points (side)
set_event_points (side, value)
inc_event_points (side, increment)

strength (side)
total_points ()
total_strength (side)
losses (side)
loss_points (side)

average_morale (side)
morale_shift (nation)
set_morale_shift (nation, value)
inc_morale_shift (nation, increment)

advantage ()
aggressiveness (side)
air_support (side)
ammo_level (side)
arty_ammo_level (side)

set_advantage (value)
set_aggressiveness (side, value)
set_air_support (side, value)
set_ammo_level (side, value)
set_arty_ammo_level (side, value)

inc_advantage (increment)
inc_aggressiveness (side, increment)
inc_air_support (side, increment)
inc_ammo_level (side, increment)
inc_arty_ammo_level (side, increment)

major_defeat ()
major_victory ()
minor_defeat ()
minor_victory ()

set_major_defeat (value)
set_major_victory (value)
set_minor_defeat (value)
set_minor_victory (value)

set_victory (majordefeat, minordefeat, minorvictory, majorvictory)

smoke_ammo (side)
star_shells (side)

set_smoke_ammo (side, value)
set_star_shells (side, value)

inc_smoke_ammo (side, increment)
inc_star_shells (side, increment)

SIDES

is_bocage_side (hexcoor, dir)
is_cliff_side (hexcoor, dir)
is_crest_side (hexcoor, dir)
is_ditch_side (hexcoor, dir)
is_dune_side (hexcoor, dir)
is_embank_side (hexcoor, dir)
is_escarpment_side (hexcoor, dir)
is_ford_side (hexcoor, dir)
is_gully_side (hexcoor, dir)
is_heavy_bridge_side (hexcoor, dir)
is_hedge_side (hexcoor, dir)
is_high_side (hexcoor, dir)
is_light_bridge_side (hexcoor, dir)
is_medium_bridge_side (hexcoor, dir)
is_minor_river_side (hexcoor, dir)
is_path_side (hexcoor, dir)
is_rail_side (hexcoor, dir)
is_reef_side (hexcoor, dir)
is_road_side (hexcoor, dir)
is_stone_side (hexcoor, dir)
is_stream_side (hexcoor, dir)
is_unpaved_side (hexcoor, dir)

SCRIPTED AI

at (trackids, hexcoor)
defend_weak (trackids, hexcoor)
defend_strong (trackids, hexcoor)
move_norush (trackids, hexcoor)
move_rush (trackids, hexcoor)
attack_weak (trackids, hexcoor)
attack_strong (trackids, hexcoor)
attack_banzai (trackids, hexcoor)
load (trackids, hexcoor)
unload (trackids, hexcoor)
take_off (trackids, hexcoor)
land (trackids, hexcoor)
ascend (trackids, hexcoor)
ascend_ground (trackids, hexcoor)
ascend_noe (trackids, hexcoor)
ascend_low (trackids, hexcoor)
ascend_high (trackids, hexcoor)
descend (trackids, hexcoor)
descend_low (trackids, hexcoor)
descend_noe (trackids, hexcoor)
descend_ground (trackids, hexcoor)
descend_underground (trackids, hexcoor)
ascend_move (trackids, hexcoor)
move_descend (trackids, hexcoor)
exit (trackids, hexcoor)
dig_in (trackids, hexcoor)
reconnoiter (trackids, hexcoor)
build_light_bridge (trackids, hexcoor, dir)
build_vehicle_bridge (trackids, hexcoor, dir)
lay_minefield (trackids, hexcoor)
set_ied (trackids, hexcoor)
build_barrier (trackids, hexcoor)
damage (trackids, hexcoor, dir)
clear_lz (trackids, hexcoor)

hold (trackids)
halt (trackids)
unleash (trackids)

move_way_point (trackids, hexcoors)

---

Watch out, Berto- don't code those fingers down to the point you will need a giant, room sized keyboard upon which to hop/type upon, not unlike the character in that Tom Hanks film. You might only get the work of 10 coders done, rather than the 20 you seem to have inside your head. Keep on rockin'.