267 lines
6.6 KiB
Text
267 lines
6.6 KiB
Text
/**** LEAPFROG SYSTEM ****
|
|
|
|
Thread maps\_leapfrog::leapfrog() on any AI that uses a chain of nodes.
|
|
Make sure to check the NOT_CHAIN check box on each node in the chain to allow chains to merge or loop.
|
|
You need at least two chains for this to look good.
|
|
level.leap_delay_min and max determines how fast they try to advance.
|
|
set script_delay on a node to have the ai use a delay instead of waiting for a leap notify.
|
|
script_delay = 0 will make them run past that node before going to the next one.
|
|
|
|
*************************/
|
|
|
|
#include maps\_utility;
|
|
|
|
main()
|
|
{
|
|
// Set delays to tweak how fast the advance should be.
|
|
level.leap_delay_min = 6;
|
|
level.leap_delay_max = 14;
|
|
level.leap_delay_override = false;
|
|
|
|
// there will never be more ai on one leap node then what this is set to.
|
|
level.leapfrog_max_node_ai = 6;
|
|
|
|
level.leap_node_array = [];
|
|
level.leapfrog_random_int = randomint(5);
|
|
|
|
// lower threat threatbias group for when leaping.
|
|
createthreatbiasgroup("leapfrog");
|
|
setthreatbiasagainstall("leapfrog", -200);
|
|
|
|
level thread leapfrog_masterthread();
|
|
}
|
|
|
|
leapfrog_masterthread()
|
|
{
|
|
while ( true )
|
|
{
|
|
if ( !level.leap_delay_override )
|
|
wait ( randomFloatRange( level.leap_delay_min, level.leap_delay_max ) );
|
|
else
|
|
wait .05;
|
|
|
|
level.leap_delay_override = false;
|
|
|
|
// used to make ai take the same fork in a path when script_delay is set.
|
|
level.leapfrog_random_int = randomint(5);
|
|
|
|
node_arr = [];
|
|
high_weight = -1000000;
|
|
|
|
if ( !level.leap_node_array.size )
|
|
continue;
|
|
|
|
for ( i=0; i<level.leap_node_array.size; i++ )
|
|
{
|
|
weight = level.leap_node_array[i].leap_weight;
|
|
if ( !isdefined(node_arr[weight]) )
|
|
node_arr[weight] = [];
|
|
node_arr[weight][ node_arr[weight].size ] = level.leap_node_array[i];
|
|
if ( weight > high_weight )
|
|
high_weight = weight;
|
|
}
|
|
|
|
assertEx( isdefined(node_arr[high_weight]), "high_weight is: " + high_weight );
|
|
assertEx( isdefined(high_weight >= 0), "high_weight is below zero: " + high_weight );
|
|
|
|
node = node_arr[high_weight][ randomint( node_arr[high_weight].size ) ];
|
|
|
|
assert ( isdefined(node.target) ); // there should always be a new node or it shouldn't be in the array.
|
|
|
|
node_arr = getnodearray(node.target,"targetname");
|
|
next_node = node_arr[ randomint(node_arr.size) ];
|
|
|
|
// reset future ai count
|
|
if ( isdefined( next_node.leapfrog_ai_count ) )
|
|
next_node.leapfrog_future_ai_count = next_node.leapfrog_ai_count;
|
|
else
|
|
next_node.leapfrog_future_ai_count = 0;
|
|
|
|
// increase the weight of all none chosen nodes.
|
|
array_thread( level.leap_node_array, ::increment_leap_weight, node );
|
|
|
|
new_weight = int(node.leap_weight * -.25);
|
|
|
|
if (isdefined(next_node.leap_weight))
|
|
new_weight += next_node.leap_weight;
|
|
|
|
add_leap_node(next_node, new_weight);
|
|
|
|
node notify("leapfrog", next_node);
|
|
remove_leap_node(node);
|
|
}
|
|
}
|
|
|
|
increment_leap_weight(node)
|
|
{
|
|
if (self == node)
|
|
return;
|
|
|
|
diff_weight = node.leap_weight - self.leap_weight;
|
|
|
|
self.leap_weight += (int (diff_weight * 0.5) + 1); // old .75;
|
|
}
|
|
|
|
leapfrog()
|
|
{
|
|
self endon("death");
|
|
self endon("stop_leapfrog");
|
|
self notify("stop_going_to_node");
|
|
|
|
// get first node
|
|
node_arr = getnodearray(self.target,"targetname");
|
|
node = node_arr[ randomint(node_arr.size) ];
|
|
|
|
while ( true )
|
|
{
|
|
if (node.radius != 0)
|
|
self.goalradius = node.radius;
|
|
if ( isdefined(node.height) )
|
|
self.goalheight = node.height;
|
|
self setgoalnode(node);
|
|
|
|
old_maxsightdistsqrd = self.maxsightdistsqrd;
|
|
self.maxsightdistsqrd = 350*350;
|
|
old_group = self getthreatbiasgroup();
|
|
self setthreatbiasgroup("leapfrog");
|
|
|
|
self waittill("goal");
|
|
|
|
// Notify the node and pass the guy. Might be good for something
|
|
node notify("trigger",self);
|
|
|
|
self.maxsightdistsqrd = old_maxsightdistsqrd;
|
|
self setthreatbiasgroup(old_group);
|
|
|
|
self thread leapfrog_on_death(node);
|
|
|
|
if ( !isdefined(node.target) )
|
|
break;
|
|
|
|
if ( isdefined(node.script_delay) )
|
|
{
|
|
node script_delay();
|
|
node_arr = getnodearray(node.target,"targetname");
|
|
next_node = node_arr[ level.leapfrog_random_int % node_arr.size ];
|
|
}
|
|
else
|
|
{
|
|
if ( !add_leap_node(node) )
|
|
break;
|
|
|
|
node waittill("leapfrog", next_node);
|
|
|
|
next_node.leapfrog_future_ai_count++;
|
|
|
|
max_node_ai = level.leapfrog_max_node_ai;
|
|
if ( isdefined(node.script_noteworthy) )
|
|
max_node_ai = int( node.script_noteworthy );
|
|
|
|
if (next_node.leapfrog_future_ai_count > max_node_ai)
|
|
{
|
|
level.leap_delay_override = true;
|
|
if ( isdefined(next_node.leap_weight) )
|
|
{
|
|
next_node.leap_weight += 1; // make the full node more likely to leap.
|
|
}
|
|
next_node = node; // stay on old node.
|
|
}
|
|
}
|
|
|
|
node = next_node;
|
|
}
|
|
|
|
// notify level and pass the guy that reached his final leapfrog node.
|
|
level notify("leapfrog_completed", self);
|
|
}
|
|
|
|
leapfrog_on_death(node)
|
|
{
|
|
node endon("leapfrog");
|
|
|
|
if ( !isdefined( node.leapfrog_ai_count ) )
|
|
node.leapfrog_ai_count = 0;
|
|
node.leapfrog_ai_count++;
|
|
|
|
self waittill("death");
|
|
|
|
node.leapfrog_ai_count--;
|
|
|
|
if ( isdefined(node.leap_weight) )
|
|
{
|
|
new_weight = node.leap_weight - 1;
|
|
if (new_weight < 1)
|
|
new_weight = 1;
|
|
node.leap_weight = new_weight;
|
|
}
|
|
|
|
if (!node.leapfrog_ai_count)
|
|
remove_leap_node(node);
|
|
}
|
|
|
|
add_leap_node(node, weight)
|
|
{
|
|
if ( !isdefined(node.target) || isdefined(node.script_delay))
|
|
return false;
|
|
|
|
if ( getdvar("debug") == "1")
|
|
node thread debug_leap_node();
|
|
|
|
if ( !is_in_array (level.leap_node_array, node) )
|
|
{
|
|
level.leap_node_array = array_add(level.leap_node_array, node);
|
|
node.leap_weight = 0;
|
|
}
|
|
|
|
if ( isdefined(weight) )
|
|
node.leap_weight = weight;
|
|
else
|
|
node.leap_weight += 2;
|
|
|
|
return true;
|
|
}
|
|
|
|
remove_leap_node(node)
|
|
{
|
|
node.leap_weight = undefined;
|
|
node.leapfrog_ai_count = undefined;
|
|
|
|
level.leap_node_array = array_remove(level.leap_node_array, node);
|
|
}
|
|
|
|
/* debug stuff */
|
|
|
|
debug_leap_node()
|
|
{
|
|
if ( isdefined(self.debug_leapnode) )
|
|
return;
|
|
self.debug_leapnode = true;
|
|
|
|
while (true)
|
|
{
|
|
if ( isdefined(self.leap_weight) )
|
|
self thread print3Dmessage(self.leap_weight, .5);
|
|
if ( isdefined(self.leapfrog_ai_count) )
|
|
self thread print3Dmessage(self.leapfrog_ai_count, 0.5 , (1,0,0), (0,0,128) , 3);
|
|
wait .5;
|
|
}
|
|
}
|
|
|
|
print3Dmessage(message, show_time, color, offset, scale)
|
|
{
|
|
if ( !isdefined(color) )
|
|
color = (0.5,1,0.5);
|
|
|
|
if ( !isdefined(offset) )
|
|
offset = (0,0,56);
|
|
|
|
if ( !isdefined(scale) )
|
|
scale = 6;
|
|
|
|
show_time = gettime() + (show_time * 1000);
|
|
while ( gettime() < show_time)
|
|
{
|
|
print3d (self.origin + offset, message, color, 1, scale);
|
|
wait (0.05);
|
|
}
|
|
}
|