qcsrc/server/bot/havocbot/role_freezetag.qc

   1 void() havocbot_role_ft_freeing;
   2 void() havocbot_role_ft_offense;
   3
   4 void havocbot_goalrating_kh(float ratingscale_team, float ratingscale_dropped, float ratingscale_enemy)
   5 {
   6         local entity head;
   7         for (head = kh_worldkeylist; head; head = head.kh_worldkeynext)
   8         {
   9                 if(head.owner == self)
  10                         continue;
  11                 if(!kh_tracking_enabled)
  12                 {
  13                         // if it's carried by our team we know about it
  14                         // otherwise we have to see it to know about it
  15                         if(!head.owner || head.team != self.team)
  16                         {
  17                                 traceline(self.origin + self.view_ofs, head.origin, MOVE_NOMONSTERS, self);
  18                                 if (trace_fraction < 1 && trace_ent != head)
  19                                         continue; // skip what I can't see
  20                         }
  21                 }
  22                 if(!head.owner)
  23                         navigation_routerating(head, ratingscale_dropped * BOT_PICKUP_RATING_HIGH, 100000);
  24                 else if(head.team == self.team)
  25                         navigation_routerating(head.owner, ratingscale_team * BOT_PICKUP_RATING_HIGH, 100000);
  26                 else
  27                         navigation_routerating(head.owner, ratingscale_enemy * BOT_PICKUP_RATING_HIGH, 100000);
  28         }
  29
  30         havocbot_goalrating_items(1, self.origin, 10000);
  31 };
  32
  33 void havocbot_role_kh_carrier()
  34 {
  35         if(self.deadflag != DEAD_NO)
  36                 return;
  37
  38         if (!(self.kh_next))
  39         {
  40                 dprint("changing role to freelancer\n");
  41                 self.havocbot_role = havocbot_role_kh_freelancer;
  42                 self.havocbot_role_timeout = 0;
  43                 return;
  44         }
  45
  46         if (self.bot_strategytime < time)
  47         {
  48                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
  49                 navigation_goalrating_start();
  50
  51                 if(kh_Key_AllOwnedByWhichTeam() == self.team)
  52                         havocbot_goalrating_kh(10, 0.1, 0.1); // bring home
  53                 else
  54                         havocbot_goalrating_kh(4, 4, 1); // play defensively
  55
  56                 navigation_goalrating_end();
  57         }
  58 }
  59
  60 void havocbot_role_kh_defense()
  61 {
  62         if(self.deadflag != DEAD_NO)
  63                 return;
  64
  65         if (self.kh_next)
  66         {
  67                 dprint("changing role to carrier\n");
  68                 self.havocbot_role = havocbot_role_kh_carrier;
  69                 self.havocbot_role_timeout = 0;
  70                 return;
  71         }
  72
  73         if (!self.havocbot_role_timeout)
  74                 self.havocbot_role_timeout = time + random() * 10 + 20;
  75         if (time > self.havocbot_role_timeout)
  76         {
  77                 dprint("changing role to freelancer\n");
  78                 self.havocbot_role = havocbot_role_kh_freelancer;
  79                 self.havocbot_role_timeout = 0;
  80                 return;
  81         }
  82
  83         if (self.bot_strategytime < time)
  84         {
  85                 float key_owner_team;
  86                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
  87                 navigation_goalrating_start();
  88
  89                 key_owner_team = kh_Key_AllOwnedByWhichTeam();
  90                 if(key_owner_team == self.team)
  91                         havocbot_goalrating_kh(10, 0.1, 0.1); // defend key carriers
  92                 else if(key_owner_team == -1)
  93                         havocbot_goalrating_kh(4, 1, 0.1); // play defensively
  94                 else
  95                         havocbot_goalrating_kh(0.1, 0.1, 10); // ATTACK ANYWAY
  96
  97                 navigation_goalrating_end();
  98         }
  99 };
 100
 101 void havocbot_role_kh_offense()
 102 {
 103         if(self.deadflag != DEAD_NO)
 104                 return;
 105
 106         if (self.kh_next)
 107         {
 108                 dprint("changing role to carrier\n");
 109                 self.havocbot_role = havocbot_role_kh_carrier;
 110                 self.havocbot_role_timeout = 0;
 111                 return;
 112         }
 113
 114         if (!self.havocbot_role_timeout)
 115                 self.havocbot_role_timeout = time + random() * 10 + 20;
 116         if (time > self.havocbot_role_timeout)
 117         {
 118                 dprint("changing role to freelancer\n");
 119                 self.havocbot_role = havocbot_role_kh_freelancer;
 120                 self.havocbot_role_timeout = 0;
 121                 return;
 122         }
 123
 124         if (self.bot_strategytime < time)
 125         {
 126                 float key_owner_team;
 127
 128                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 129                 navigation_goalrating_start();
 130
 131                 key_owner_team = kh_Key_AllOwnedByWhichTeam();
 132                 if(key_owner_team == self.team)
 133                         havocbot_goalrating_kh(10, 0.1, 0.1); // defend anyway
 134                 else if(key_owner_team == -1)
 135                         havocbot_goalrating_kh(0.1, 1, 4); // play offensively
 136                 else
 137                         havocbot_goalrating_kh(0.1, 0.1, 10); // ATTACK! EMERGENCY!
 138
 139                 navigation_goalrating_end();
 140         }
 141 };
 142
 143 void havocbot_role_kh_freelancer()
 144 {
 145         if(self.deadflag != DEAD_NO)
 146                 return;
 147
 148         if (self.kh_next)
 149         {
 150                 dprint("changing role to carrier\n");
 151                 self.havocbot_role = havocbot_role_kh_carrier;
 152                 self.havocbot_role_timeout = 0;
 153                 return;
 154         }
 155
 156         if (!self.havocbot_role_timeout)
 157                 self.havocbot_role_timeout = time + random() * 10 + 10;
 158         if (time > self.havocbot_role_timeout)
 159         {
 160                 if (random() < 0.5)
 161                 {
 162                         dprint("changing role to offense\n");
 163                         self.havocbot_role = havocbot_role_kh_offense;
 164                 }
 165                 else
 166                 {
 167                         dprint("changing role to defense\n");
 168                         self.havocbot_role = havocbot_role_kh_defense;
 169                 }
 170                 self.havocbot_role_timeout = 0;
 171                 return;
 172         }
 173
 174         if (self.bot_strategytime < time)
 175         {
 176                 float key_owner_team;
 177
 178                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 179                 navigation_goalrating_start();
 180
 181                 key_owner_team = kh_Key_AllOwnedByWhichTeam();
 182                 if(key_owner_team == self.team)
 183                         havocbot_goalrating_kh(10, 0.1, 0.1); // defend anyway
 184                 else if(key_owner_team == -1)
 185                         havocbot_goalrating_kh(1, 10, 4); // prefer dropped keys
 186                 else
 187                         havocbot_goalrating_kh(0.1, 0.1, 10); // ATTACK ANYWAY
 188
 189                 navigation_goalrating_end();
 190         }
 191 };
 192
 193 void havocbot_chooserole_ft()
 194 {
 195         if(self.deadflag != DEAD_NO)
 196                 return;
 197
 198         self.havocbot_role = havocbot_role_ft_offensive;
 199 };