Sneak Peeks, Coming Attractions, Works-In-Progress

[LittleBen]

Many thanks for the explanation. I didn't know it was hard to pass from bitmap to png, I thought most computer could easily do that

[Jason Petho]

Campaign Series Vietnam: ALPHA Graphics.

Map progress in the NW II Corps area. Here is a screenshot of the Camp Enari/Dragon Mountain area prior to me adding the vegetation. Lots of progress lately on the map itself, I am hoping to wrap it up by the end of the month. This will be the master map for a dozen or so scenarios, at least!

[Jason Petho]

Campaign Series Vietnam: ALPHA GRAPHICS

Here is an area 18 kilometres north of Pleiku in the Central Highlands that reveals the extent of the mountainous terrain being represented in the game. This is a screenshot before I add the vegetation and shows a good presentation of why helicopters are essential in this terrain.

[berto]

A Tale of Two AutoPlaytests


This post will tell the tale of two automated AI vs. AI playtests of the CSVN VN_600325_Vinh_An scenario, the first with the LAI/SAI (Legacy AI, Scripted AI) working in tandem, the second employing the LAI only (no scripting).

In the historical battle of Vinh An (from the scenario briefing notes):

Early in 1960, Viet Cong activities had become more prevalent in the Mekong Delta region. It was commonplace for the ARVN military to conduct road clearing and sweeping operations in hopes of catching the Viet Cong in the open. Road sweeping operations typically meant clearing mines and roadblocks for supply traffic to move freely from district to another. While these were standard affairs, one such operation culminated into a full scale ambush by the newly created Viet Cong U Minh Main Force battalion. This battalion would be the bane of the ARVN divisions operating in the area for years to come. In this case, it is the 2nd Battalion, 31st Infantry Regiment, 21st ARVN Division that would have their teething experience on QL 12 during a road clearing and sweeping operation.

In short, this scenario is thus a basic convoy ambush type scenario.

In the screenshot following:



[*]The VC 1st Coy lies in wait in the vicinity of Vinh An.
[*]The VC 2nd Coy is directed to sit tight, then attack Xom Ben Luong if and when fighting erupts around Vinh An.
[*]The VC 3rd Coy is set to ambush any ARVN forces moving northwards up Highway 12.

[*]The ARVN 2 Coy, the road clearing convoy, is ordered to move northward up Highway 12, and clear any mines or roadblocks in its path, then veer eastward to Vinh An. Meanwhile, the mine clearing engineers are to continue up the road northward, eventually as far as Xom Ban Oi.
[*]Beginning at Turn 5 (or possibly sooner, if the ARVN 2 Coy is attacked), the ARVN 1st Coy is directed to load onto trucks, then motor up Highway 12 as far as Xom Ben Luong, also with the mission to clear any mines or roadblocks discovered along the way.
[*]Beginning at Turn 5 (or possibly sooner), the ARVN Weapons Coy is to load onto trucks, then proceed up along the left river bank as far northward as Kinh Song Trem Trem, there to provide fire support for ARVN 1st Coy. (Moving anywhere beyond that point is too slow going.)

With the SAI/LAI working in tandem, how did the first playtest play out? Let's see (the situation at the end of Turn 13):



[*]The ARVN 2nd Coy and VC 1st Coy are fighting to control Vinh An. The mine clearing engineers (with engineer trucks close behind them) continue on their primary mission.
[*]The VC 2nd Coy has taken Xom Ban Luong. If the fight for Vinh An goes too badly, the VC 2nd Coy is directed to help out the VC 1st Coy in that fight.
[*]After hitting a minefield along Highway 12 just beyond Xom Chac Bang, the ARVN 1st Coy was indeed ambushed by the VC 3rd Coy. The ARVN Weapons Coy assists from just across the river.
[*]A second ARVN engineer company has trucked northward to, hopefully, clear the minefield just northeast of Xom Chac Bang.

In other words, this scenario has pretty much developed as intended: an ambush, and a main fight around Vinh An.

Hmm, I wonder what would happen if we remove the SAI (Scripted AI) and let the LAI (Legacy AI) alone play itself. Let's find out:



[*]The VC1st & 2nd Coys operate about the same as in the first autoplaytest.
[*]The ARVN 2nd Coy abandons its road clearing mission and retreats back down Highway 12 to Xom Vam Chac Bang.
[*]The VC 3rd Coy moves cross country northeastward and away from Highway 12. There is no ambush!
[*]Leaving its trucks behind, The ARVN 1st Coy marches on foot up Highway 12 only as far Ap Vinh Dong.
[*]The ARVN Weapons Coy stays put, goes nowhere.

More or less the end result (also at the end of Turn 13; there is little change after that point):



[*]The VC are clustered around Xom Ben Luong and Vinh An to the north.
[*]The ARVN cower in fear midway along Highway 12.
[*]Many ARVN lie dormant to the southwest around Kien Long.
[*]Except for incidental clashes, there has been very little combat.
[*]In this unscripted autoplaytest, it played out entirely unhistorically, and with near total disregard of the scenario designer's intent.

Now imagine if you the human were to play one side or the other vs. the opposing (a) SAI/LAI tandem or (b) LAI only.

Here are some talking points shared with the Dev Team recently:

In all of the following, "LAI" means "Legacy AI", while "SAI" means "Scripted AI". CSEE means "Campaign Series Event Engine".

--CSVN introduces many special new features: helos, riverines, complex terrain, civilians, no-go zones, politics, unconventional warfare, search & destroy, search & rescue, tunnels, etc. Things difficult to impossible to program with the LAI. Without the CSEE/SAI, there is no Vietnam game.

--The LAI is entirely guided by Objectives, nothing else. With the SAI, we can direct units to move to, attack, defend, etc. any arbitrary hex, whether an Objective or not. We can now have scenarios without any formal Objective hexes whatsoever! (As in LA_690915_SAR_A.scn.)

--Since the SAI is no longer tied to Objectives, we can direct forces to do flanking attacks, end runarounds and attacks from rear, move to staging areas, assume temporary defensive positions, etc. All of this was impossible under the LAI.

--With the SAI, we can direct a series of waypoint movements.

--With the SAI, we can order any series of stop/go movements.

--With the SAI, we can order retreats for whatever reason (whether triggered at some turn, due to high casualties, because accomplished some assigned purpose, etc.).

--Thus, with the SAI, for the first time ever the AI can have strategy. Before, the LAI was only tactical.

--Although we can, with great difficulty, micromanage the AI tactics, tactics are still best guided by the LAI. We will continue to improve the LAI as best we can.

--With the SAI, battle plans can be rigid and inflexible, or dynamic, reacting to changing battlefield (or even political) conditions.

--There can be one battle plan per side, or several. Selected initially at random, or per some other consideration.

--There are limits to what, and when, the game engine communicates to, shares with, the event engine; and vice versa. Although walled off one from the other, we do our best to facilitate game engine/event engine data sharing in real time. With some exceptions (e.g., real-time hex-to-hex unit movement), it is usually best to assume that data is passed from one engine to the other in on_next_turn() and on_next_phase() only.

--The event engine does not have access to the detailed information processing in the game engine (LOS determination, for instance). In some sense, the event engine is "dumber" than the game engine. But we can offset that by "intelligent" scripting.

--SAI orders are processed only in on_next_phase() (which calls one or the other side's battle plan functions). Once given at phase beginning, they will not change in mid phase; orders remain fixed until the next phase comes around. There are practical limits to how nimble the SAI can be. (Which is "realistic", if you think about it.)

--A unit can be assigned more than one SAI order, but a later order in the processing sequence overrides any earlier order(s). Only the last given order applies (until the next phase comes around).

--The SAI sometimes wrestles with the LAI for control. Sometimes, the LAI will block the SAI from doing some intended action. In programming the SAI, there are the occasional "gotchas" AKA bugs. We will continue to fix these as we go along.

--Often, the LAI will do seemingly stupid moves. We can rationalize that as being due to bad intelligence, misinformation, enemy misdirection (spies), inaccurate maps, missing roadway signs, or just simply getting lost. SNAFUs are normal, and to be expected.

--In complicated map situations (e.g., a complicated river network), the LAI path finding can be poor. Forces can go around and around in circles, get lost, get stuck. The LAI cannot "see" past rivers, only *maybe* "see" across bridges, fords, etc., but there are practical limits (time, CPU cycles) to how far and circuitous it can "see". In such cases, through appropriate SAI scripting, we might need to nudge the LAI, even micromanage movements as needed.

--With the SAI, can we cheat? Yes. For example, by setting verified_only inputs to false, we can have the SAI be all knowing. But should we cheat? With few exceptions, and except for practical reasons, the answer should be: no! Scenario scripters should avoid giving the SAI unfair advantages in an attempt to make it more competitive.

--We can and should aim to have a competent, competitive AI. But the higher goal is to achieve a more human-like AI, to give the human player the illusion he is playing against a real, live human opponent, not against some robotic, lifeless algorithm.

--Military history is filled with a wide range of military leadership, the good, the bad, and everything in between. The SAI/LAI should not, and cannot, play like Napoleon or Alexander each and every game. And even history's greatest commanders made mistakes, had their bad days. We should not, and cannot, expect infallibility from the computer opponent. There will be mistakes.

--Does this serve to excuse, to rationalize the SAI/LAI shortcomings? Yes, to some extent it does. But the above is no less true. Real-life human commanders are by varying degrees "intelligent". Sub-par AI is as much a feature as it is a bug.

--Thus far, our scenario battle plans have tended to be inflexibly choreographed, proceeding according to some more or less fixed series of steps. As much as possible, we should make the battle plans more dynamic, adapting in real time to changing battlefield conditions.

--Micromanaging the LAI is hard. The SAI decision trees can quickly become quite complex, with lots and lots of deeply nested if-elseif-else's. Overly complex battle plans are buggy battle plans. The trick is to KISS the AI as much as possible.

--The CSEE/SAI are based on the embedded scripting language Lua (embedded within the game engine). Lua "scripting" is still programming. Programming at any level is hard. Scenario scripters are generally not programmers, in many cases are complete newbies. They will struggle and make mistakes (bugs). Another reason to KISS the CSEE/SAI as much as possible. And to be forgiving, not so harsh in judging the scripters' work.

--Achieving the "perfect" battle plan is quite time consuming, assuming it is even at all possible. With so many scenarios, with a limited amount of time until game's release, we must not let perfection be the enemy of the good. We must be pragmatic. Good enough is just that.

--The CSEE, the SAI, and the LAI will continue to evolve, and to improve. (And we will continue to discover and to fix bugs.) We must acknowledge the practical impossibility of revisiting and revising earlier scripting efforts. Hindsight is 20/20. But again, good enough is good enough.

--The bottom line: When judging the game's AI, we should not solely consider: Can it beat me? We should also judge whether: Is it life-like, imaginative, interesting, engaging, entertaining?

Will this game's AI be perfect? No. Will it be better than ever? We think so!

[Andrea G]

Fascinating!

[Jason Petho]

Campaign Series Vietnam: ALPHA GRAPHICS: Mapping

After six months, the Northwest II Corps map is finally complete. This master map will be included in the game for those who enjoy making their own scenarios. This is a large map that covers from Dak To in the north, to Plei Me in the south.

At 220 x 560, the map represents 123,200 hexes of accurate, historical mapping!

[Big Ivan]

Jason,

That's just tit's my friend!!![:D]

God's speed mister!

Big Ivan[;)]

[Jason Petho]

Campaign Series Vietnam: ALPHA GRAPHICS

Here are the starting positions for the 1st RAR (Royal Australian Regiment) prior to their adventures into Ho Bo Woods during Operation Crimp, January 1966.

[Jugger]

Awesome work on the Aussie infantry right down to the somewhat faded green uniforms. Using US chopper/logistics support was not uncommon during the early part of Australia's involvement in the Vietnam war. Obviously the "battle of Long Tan" will be included as one of the more well know battles between Australian/North Vietnamese infantry. Keep up the good work.[8D][&o]

[Jason Petho]

Thank you, Jugger! Muchly appreciated!

[Warhorse]

Thanks Jugger, I spent a lot of time on those Aussies!!

[Jason Petho]

Campaign Series Vietnam: ALPHA Graphics: SCENARIO CREATION.

Quiz time! What battle do you think this screenshot is from?

[Big Ivan]

Super wild guess here![&:][&:]

Siege of Plei Me?


Big Ivan[;)]

[Jason Petho]

Excellent guess!

That is the train element of the ARVN Task Force that was sent to relieve Plei Me.

Here is the main column.

[Big Ivan]

Woo Hoo Thanks Jason![&o]

[Jason Petho]

Campaign Series Vietnam: ALPHA Graphics.

With the NW II Corps master map completed, mapping attention has returned to the DMZ map (northern I Corps) This has been expanded to the south to include Hue and to the west to include Tchepone. Not far from Khe Sanh on the route to Tchepone is this well known Special Forces Camp.

[76mm]

Your 3D view is the only one I ever use in any game, usually I hate the 3D crap--yours really work well.

My only request for 3D (for EFII, cuz I'm not buying Vietnam) is that you have an option for plain, monocolor unit bases in addition to the fancy ones with national symbols. I expect this will be easy enough to mod anyway, but would be nice if it were an option out of the box.

[Jason Petho]

Great suggestion!

[Jason Petho]

Here is the Khe Sanh Combat Base

[berto]

The latest CSEE functions roster, 460+ functions and growing:

---

TRIGGERS

on_air_attack (hc, pid, name, side, nation, points, strength)
on_arty_attack (hc, trackid, pid, name, side, nation, oid, orgname, points, strength, HQ, Leader)
on_build_barrier (hc, trackid, pid, name, side, nation, oid, orgname)
on_build_light_bridge (hc, dir, trackid, pid, name, side, nation, oid, orgname)
on_build_vehicle_bridge (hc, dir, trackid, pid, name, side, nation, oid, orgname)
on_clear_hex (hc)
on_clear_lz (hc, trackid, pid, name, side, nation, oid, orgname)
on_damage (hc, trackid, pid, name, side, nation, oid, orgname)
on_entrench_hex (hc, trackid, pid, name, side, nation, oid, orgname)
on_hex_assault (hc, side)
on_hex_attack (hc, side, nation)
on_ied_attack (hc, trackid, pid, name, side, nation, oid, orgname, points, strength, HQ, Leader)
on_improve_hex (hc, trackid, pid, name, side, nation, oid, orgname)
on_lay_mine_field (hc, trackid, pid, name, side, nation, oid, orgname)
on_mine_attack (hc, trackid, pid, name, side, nation, oid, orgname, points, strength, HQ, Leader)
on_next_phase (turn, side)
on_next_turn (turn)
on_objective_capture (hc, values, side)
on_resume ()
on_set_ied (hc, trackid, pid, name, side, nation, oid, orgname)
on_shutdown ()
on_startup ()
on_unit_arty_fire (hc, trackid, pid, name, side, nation, oid, orgname, strength)
on_unit_attack (hc, trackid, pid, name, side, nation, oid, orgname, points, strength, HQ, Leader)
on_unit_fire (hc, trackid, pid, name, side, nation, oid, orgname, strength)
on_unit_kill (hc, trackid, pid, name, side, nation, oid, orgname, points, strength, HQ, Leader)
on_unit_move (hc_from, hc_to, trackid)
on_unit_reduce (hc, trackid, pid, name, side, nation, oid, orgname, points, strength, HQ, Leader, loss)
on_unit_reinforce (hc, 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 (hc, 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_on_map (trackid, verified_only)

counter_is_airborne (trackid)
counter_is_air_transport (trackid)
counter_is_hq (trackid)
counter_is_leader (trackid)
counter_is_transport (trackid)

counter_leader (trackid)
counter_losses (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_until_refuel (trackid)
counter_type (trackid)
counter_x (trackid)
counter_y (trackid)

counter_unit_carry_flags (trackid)
counter_unit_fire_flags (trackid)
counter_unit_more_flags (trackid)
counter_unit_move_flags (trackid)
counter_unit_other_flags (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_buybullet (trackids)
is_buywheel (trackids)
is_fixed (trackids)
is_lowonammo (trackids)
is_isolated (trackids)
is_buyrecon (trackids)
is_reduced (trackids)
is_lowonfuel (trackids)
is_outoffuel (trackids)
is_refueled (trackids)
is_attacked (trackids)

is_not_disrupted (trackids)
is_not_carried (trackids)
is_not_unloaded (trackids)
is_not_loaded (trackids)
is_not_concealed (trackids)
is_not_outofammo (trackids)
is_not_diggingin (trackids)
is_not_fatigued (trackids)
is_not_buybullet (trackids)
is_not_buywheel (trackids)
is_not_fixed (trackids)
is_not_lowonammo (trackids)
is_not_isolated (trackids)
is_not_buyrecon (trackids)
is_not_reduced (trackids)
is_not_lowonfuel (trackids)
is_not_outoffuel (trackids)
is_not_refueled (trackids)
is_not_attacked (trackids)

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

hexes_aorg (trackids, onmap_only)

map_trackid (hc, number)
map_trackid_count (hc)
map_trackids (hc)
max_counters ()
max_turns_until_refuel (nation)

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)
set_fow (side, switch)
is_night ()

HEXES

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

function hexes_minefield (hcs, side)
function hexes_ied (hcs, side)
function hexes_block (hcs, side)
function hexes_tunnel (hcs, side)
function hexes_cave (hcs, side)
function hexes_fortification (hcs)
function hexes_landing_zone (hcs)
function hexes_wrecks (hcs)

function hexes_terrain (hcs, terrain)

empty_transports_count (hc)
has_empty_air_transport (hc)
has_empty_transport (hc)
has_transport (hc)
max_transport_strength (hc)

is_sidea_aware (hc)
is_sidea_exclude (hc)
is_sideb_aware (hc)
is_sideb_exclude (hc)

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

MAP

on_map (hc)

map_center (x, y)
map_height ()
map_sector (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)

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

map_side (hc)

hexes_all ()
hex_box (hc_upleft, hc_lowright)
hexes_within (hc, extent)
hex_adjacent (hc, dir)
hex_random (hc, extent)

hexes_nearest (hc, hcs)
hexes_farthest (hc, hcs)

range (from, to)

MESSAGING

_message (title, text)
message (title, text, human_only)
message_once (title, text, human_only)
_note (title, text)
note (title, text, human_only)
note_once (title, text, human_only)
_report (title, text)
report (title, text, human_only)
report_once (title, text, human_only)
log (logfile, loglevel, text)

DEBUGGING

trace (event, line)
traceon ()
traceoff ()

MISC

upper_case (text)
lower_case (text)

ordinal (number)

dieroll (x)
random ()
random_index (l, u)
random_pick (list)

even (x)
odd (x)

round (x)

dir_from (origin, point)
hexdir_from (origin, point)

has_flag (flags, flag)

join (lists)

member (trackid, trackids)
members (trackids_part, trackids_whole)

is_move_tracking ()
move_tracking ()
set_move_tracking ()
unset_move_tracking ()

is_qa_testing ()
qa_testing ()
set_qa_testing ()
unset_qa_testing ()

OBJECTIVES

objective_owner (hc)
objective_points ()
objective_values (hc)

set_objective (hc, values, side)
set_objective_values (hc, 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, hc, turn, prob, flags, scatter)
set_reinforcement_flags (id, flags)
set_reinforcement_hex (id, hc)
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

options ()
set_options (value)
set_option (value)
unset_option (value)

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

total_points ()

total_strength (side, verified_only)
strength (trackids, verified_only)

total_losses (side)
losses (trackids, verified_only)

total_loss_rate (side, verified_only)
loss_rate (trackids, verified_only)

total_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 (hc, dir)
is_cliff_side (hc, dir)
is_crest_side (hc, dir)
is_ditch_side (hc, dir)
is_dune_side (hc, dir)
is_embank_side (hc, dir)
is_escarpment_side (hc, dir)
is_ford_side (hc, dir)
is_gully_side (hc, dir)
is_heavy_bridge_side (hc, dir)
is_hedge_side (hc, dir)
is_high_side (hc, dir)
is_light_bridge_side (hc, dir)
is_medium_bridge_side (hc, dir)
is_minor_river_side (hc, dir)
is_path_side (hc, dir)
is_rail_side (hc, dir)
is_reef_side (hc, dir)
is_road_side (hc, dir)
is_stone_side (hc, dir)
is_stream_side (hc, dir)
is_unpaved_side (hc, dir)

UNITS

in_box (trackids, hc_upleft, hc_lowright, verified_only)
within (trackids, hc, extent, verified_only)

units_in_box (hc_upleft, hc_lowright, side, verified_only)
units_in_box_count (hc_upleft, hc_lowright, side, verified_only)

units_within (hc, extent, side, verified_only)
units_within_count (hc, extent, side, verified_only)

above (trackids, row, verified_only)
below (trackids, row, verified_only)
left_of (trackids, col, verified_only)
right_of (trackids, col, verified_only)

units_above (row, side, verified_only)
units_below (row, side, verified_only)
units_left_of (col, side, verified_only)
units_right_of (col, side, verified_only)

units_above_count (row, side, verified_only)
units_below_count (row, side, verified_only)
units_left_of_count (col, side, verified_only)
units_right_of_count (col, side, verified_only)

units_extent (trackids, verified_only)
units_nearest (hc, side, verified_only)

SCRIPTED AI

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

hold (trackids, hc)
halt (trackids, hc)
unleash (trackids, hc)

move_way_point (trackids, hcs)

function land_transport_passengers (trackids, loadpt, unloadpt, assemblypt)
function land_transport_carriers (trackids, loadpt, unloadpt, roundtrip)
function move_land_transport (ptrackids, ctrackids, loadpt, unloadpt, assemblypt, roundtrip)
function column_move (trackids, hc, dir, radius)
function water_transport_passengers (trackids, embarkpt, loadpt, disembarkpt, unloadpt, assemblypt)
function water_transport_carriers (trackids, loadpt, unloadpt, roundtrip)
function move_water_transport (ptrackids, ctrackids, embarkpt, loadpt, disembarkpt, unloadpt, assemblypt, roundtrip)
function air_transport_passengers (trackids, loadpt, unloadpt, assemblypt, airlevel)
function air_transport_carriers (trackids, loadpt, unloadpt, roundtrip, airlevel)
function move_air_transport (ptrackids, ctrackids, loadpt, unloadpt, assemblypt, roundtrip, airlevel)
function air_mission_fire (trackids, basept, targetpt, proximity, airlevel)
function air_mission_spot (trackids, basept, targetpt, proximity, airlevel)

---