Preliminar support for assault

diff --git a/qcsrc/server/assault.qc b/qcsrc/server/assault.qc
index 85009dd830967c11f8b9d1a3c08953db803f970d..77d7d36fc8773858f02120a697a3f2fa484c0f75 100644 (file)
--- a/qcsrc/server/assault.qc
+++ b/qcsrc/server/assault.qc
@@ -103,7 +103,7 @@ void assault_objective_decrease_use() {
                                                centerprint(player, s);
                                        }
                                }
-                                       
+
                                oldactivator = activator;
                                activator = oldself;
                                        SUB_UseTargets();
@@ -207,6 +207,9 @@ void spawnfunc_func_assault_destructible() {
                return;
        }
        self.spawnflags = 3;
+       self.classname = "func_assault_destructible";
+       self.takedamage = TRUE;
+       self.bot_attack = TRUE;
        if(assault_attacker_team == COLOR_TEAM1) {
                self.team = COLOR_TEAM2;
        } else {
@@ -271,7 +274,7 @@ void assault_roundstart_use() {
        activator = self;
        SUB_UseTargets();
 
-       
+
 #ifdef TTURRETS_ENABLED
        entity ent, oldself;
 
@@ -315,7 +318,7 @@ void spawnfunc_target_assault_roundstart() {
 // reset objectives, toggle spawnpoints, reset triggers, ...
 void vehicles_clearrturn();
 void vehicles_spawn();
-void assault_new_round() 
+void assault_new_round()
 {
     entity oldself;
        //bprint("ASSAULT: new round\n");
@@ -325,9 +328,9 @@ void assault_new_round()
     FOR_EACH_PLAYER(self)
     {
         if(self.vehicle)
-            vehicles_exit(VHEF_RELESE);        
+            vehicles_exit(VHEF_RELESE);
     }
-    
+
     self = findchainflags(vehicle_flags, VHF_ISVEHICLE);
     while(self)
     {
@@ -360,7 +363,7 @@ void assault_new_round()
                                ent.team_saved = COLOR_TEAM1;
                }
        }
-       
+
        // reset the level with a countdown
        cvar_set("timelimit", ftos(ceil(time - game_starttime) / 60));
        ReadyRestartForce(); // sets game_starttime

diff --git a/qcsrc/server/bot/havocbot/havocbot.qc b/qcsrc/server/bot/havocbot/havocbot.qc
index 7c2f986346677e73b2cefc533cf45651ebd18cf0..56ab872085cbd4af7162847ee93ab72b51ddc081 100644 (file)
--- a/qcsrc/server/bot/havocbot/havocbot.qc
+++ b/qcsrc/server/bot/havocbot/havocbot.qc
@@ -4,6 +4,7 @@
 #include "role_keyhunt.qc"
 #include "role_freezetag.qc"
 #include "role_keepaway.qc"
+#include "role_assault.qc"
 #include "roles.qc"
 
 void havocbot_ai()

diff --git a/qcsrc/server/bot/havocbot/role_assault.qc b/qcsrc/server/bot/havocbot/role_assault.qc
new file mode 100644 (file)
index 0000000..e5e3bdb
--- /dev/null
+++ b/qcsrc/server/bot/havocbot/role_assault.qc
@@ -0,0 +1,206 @@
+#define HAVOCBOT_AST_ROLE_NONE                 0
+#define HAVOCBOT_AST_ROLE_DEFENSE      2
+#define HAVOCBOT_AST_ROLE_OFFENSE      8
+
+.float havocbot_role_flags;
+.float havocbot_attack_time;
+
+.void() havocbot_role;
+.void() havocbot_previous_role;
+
+void() havocbot_role_ast_defense;
+void() havocbot_role_ast_offense;
+.entity havocbot_ast_target;
+
+void(entity bot) havocbot_ast_reset_role;
+
+void(float ratingscale, vector org, float sradius) havocbot_goalrating_items;
+void(float ratingscale, vector org, float sradius) havocbot_goalrating_enemyplayers;
+.entity assault_decreaser;
+
+void havocbot_goalrating_ast_targets(float ratingscale)
+{
+       entity ad, best, pl, wp, tod;
+       float radius, found, bestvalue, c;
+       vector p;
+
+       ad = findchain(classname, "func_assault_destructible");
+
+       for (; ad; ad = ad.chain)
+       {
+               if (ad.target == "")
+                       continue;
+
+               found = FALSE;
+               for(tod = world; (tod = find(tod, targetname, ad.target)); )
+               {
+                       if(tod.classname == "target_objective_decrease")
+                       {
+                               if(tod.enemy.health < ASSAULT_VALUE_INACTIVE)
+                               {
+                                       found = TRUE;
+                                       break;
+                               }
+                       }
+               }
+
+               if(!found)
+                       continue;
+
+               p = 0.5 * (ad.absmin + ad.absmax);
+       //      dprint(vtos(ad.origin), " ", vtos(ad.absmin), " ", vtos(ad.absmax),"\n");
+               te_knightspike(p);
+               te_lightning2(world, '0 0 0', p);
+
+               // Find and rate waypoints around it
+               found = FALSE;
+               best = world;
+               bestvalue = 99999999999;
+               for(radius=0; radius<1000 && !found; radius+=500)
+               {
+                       for(wp=findradius(p, radius); wp; wp=wp.chain)
+                       {
+                               if(!(wp.wpflags & WAYPOINTFLAG_GENERATED))
+                               if(wp.classname=="waypoint")
+                               if(checkpvs(wp.origin, ad))
+                               {
+                                       found = TRUE;
+                                       if(wp.cnt<bestvalue)
+                                       {
+                                               best = wp;
+                                               bestvalue = wp.cnt;
+                                       }
+                               }
+                       }
+               }
+
+               if(best)
+               {
+                       dprint("waypoints around target were found\n");
+               //      te_lightning2(world, '0 0 0', best.origin);
+               //      te_knightspike(best.origin);
+
+                       navigation_routerating(best, ratingscale, 10000);
+                       best.cnt += 1;
+
+                       self.havocbot_attack_time = 0;
+
+                       if(checkpvs(self.view_ofs,ad))
+                       if(checkpvs(self.view_ofs,best))
+                               self.havocbot_attack_time = time + 2;
+               }
+       }
+}
+
+void havocbot_role_ast_offense()
+{
+       if(self.deadflag != DEAD_NO)
+       {
+               self.havocbot_attack_time = 0;
+               havocbot_ast_reset_role(self);
+               return;
+       }
+
+       // Set the role timeout if necessary
+       if (!self.havocbot_role_timeout)
+               self.havocbot_role_timeout = time + 120;
+
+       if (time > self.havocbot_role_timeout)
+       {
+               havocbot_ast_reset_role(self);
+               return;
+       }
+
+       if(self.havocbot_attack_time>time)
+               return;
+
+       if (self.bot_strategytime < time)
+       {
+               navigation_goalrating_start();
+       ///     havocbot_goalrating_enemyplayers(20000, self.origin, 650);
+
+       //      if(!havocbot_goalrating_ast_generator_attack(20000))
+       //              havocbot_goalrating_ast_controlpoints_attack(20000);
+       //      havocbot_goalrating_ast_offenseitems(10000, self.origin, 10000);
+
+               havocbot_goalrating_ast_targets(20000);
+       ///     havocbot_goalrating_items(10000, self.origin, 10000);
+               navigation_goalrating_end();
+
+               self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
+       }
+};
+
+void havocbot_role_ast_defense()
+{
+       if(self.deadflag != DEAD_NO)
+       {
+               self.havocbot_attack_time = 0;
+               havocbot_ast_reset_role(self);
+               return;
+       }
+
+       // Set the role timeout if necessary
+       if (!self.havocbot_role_timeout)
+               self.havocbot_role_timeout = time + 120;
+
+       if (time > self.havocbot_role_timeout)
+       {
+               havocbot_ast_reset_role(self);
+               return;
+       }
+
+       if(self.havocbot_attack_time>time)
+               return;
+
+       if (self.bot_strategytime < time)
+       {
+               navigation_goalrating_start();
+               havocbot_goalrating_enemyplayers(20000, self.origin, 650);
+       //      if(!havocbot_goalrating_ast_generator_attack(20000))
+       //              havocbot_goalrating_ast_controlpoints_attack(20000);
+       //      havocbot_goalrating_ast_offenseitems(10000, self.origin, 10000);
+               havocbot_goalrating_items(10000, self.origin, 10000);
+               navigation_goalrating_end();
+
+               self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
+       }
+};
+
+void havocbot_role_ast_setrole(entity bot, float role)
+{
+       switch(role)
+       {
+               case HAVOCBOT_AST_ROLE_DEFENSE:
+                       bot.havocbot_role = havocbot_role_ast_defense;
+                       bot.havocbot_role_flags = HAVOCBOT_AST_ROLE_DEFENSE;
+                       bot.havocbot_role_timeout = 0;
+                       break;
+               case HAVOCBOT_AST_ROLE_OFFENSE:
+                       bot.havocbot_role = havocbot_role_ast_offense;
+                       bot.havocbot_role_flags = HAVOCBOT_AST_ROLE_OFFENSE;
+                       bot.havocbot_role_timeout = 0;
+                       break;
+       }
+};
+
+void havocbot_ast_reset_role(entity bot)
+{
+       local entity head;
+       local float c;
+
+       if(self.deadflag != DEAD_NO)
+               return;
+
+       bot.havocbot_ast_target = world;
+
+       if(bot.team==assault_attacker_team)
+               havocbot_role_ast_setrole(bot, HAVOCBOT_AST_ROLE_OFFENSE);
+       else
+               havocbot_role_ast_setrole(bot, HAVOCBOT_AST_ROLE_DEFENSE);
+};
+
+void havocbot_chooserole_ast()
+{
+       havocbot_ast_reset_role(self);
+};

diff --git a/qcsrc/server/bot/havocbot/roles.qc b/qcsrc/server/bot/havocbot/roles.qc
index ac52c698f6cdb10c6387799898f9f400ebc5ef54..9f17c0a8c4c573a7abc9e4ea73cfe2741c4bdfc6 100644 (file)
--- a/qcsrc/server/bot/havocbot/roles.qc
+++ b/qcsrc/server/bot/havocbot/roles.qc
@@ -310,6 +310,8 @@ void havocbot_chooserole()
                havocbot_chooserole_ka();
        else if (g_freezetag)
                havocbot_chooserole_ft();
+       else if (g_assault)
+               havocbot_chooserole_ast();
        else // assume anything else is deathmatch
                havocbot_chooserole_dm();
 };