data/qcsrc/server/bot/bot.qc

   1 #include "bot.qh"
   2 #include "aim.qh"
   3 #include "navigation.qh"
   4 #include "waypoints.qh"
   5
   6 #include "aim.qc"
   7 #include "navigation.qc"
   8 #include "waypoints.qc"
   9 #include "scripting.qc"
  10
  11 #include "havocbot/havocbot.qc"
  12
  13 entity bot_spawn()
  14 {
  15         local entity oldself, bot;
  16         bot = spawnclient();
  17         if (bot)
  18         {
  19                 currentbots = currentbots + 1;
  20                 oldself = self;
  21                 self = bot;
  22                 bot_setnameandstuff();
  23                 ClientConnect();
  24                 PutClientInServer();
  25                 self = oldself;
  26         }
  27         return bot;
  28 };
  29
  30 void bot_think()
  31 {
  32         if (self.bot_nextthink > time)
  33                 return;
  34
  35         self.flags &~= FL_GODMODE;
  36         if(cvar("bot_god"))
  37                 self.flags |= FL_GODMODE;
  38
  39         self.bot_nextthink = self.bot_nextthink + cvar("bot_ai_thinkinterval") * pow(0.5, self.bot_aiskill);
  40         //if (self.bot_painintensity > 0)
  41         //      self.bot_painintensity = self.bot_painintensity - (skill + 1) * 40 * frametime;
  42
  43         //self.bot_painintensity = self.bot_painintensity + self.bot_oldhealth - self.health;
  44         //self.bot_painintensity = bound(0, self.bot_painintensity, 100);
  45
  46         if(time < game_starttime || ((cvar("g_campaign") && !campaign_bots_may_start)))
  47         {
  48                 self.nextthink = time + 0.5;
  49                 return;
  50         }
  51
  52         if (self.fixangle)
  53         {
  54                 self.v_angle = self.angles;
  55                 self.v_angle_z = 0;
  56                 self.fixangle = FALSE;
  57         }
  58
  59         self.dmg_take = 0;
  60         self.dmg_save = 0;
  61         self.dmg_inflictor = world;
  62
  63         // calculate an aiming latency based on the skill setting
  64         // (simulated network latency + naturally delayed reflexes)
  65         //self.ping = 0.7 - bound(0, 0.05 * skill, 0.5); // moved the reflexes to bot_aimdir (under the name 'think')
  66         // minimum ping 20+10 random
  67         self.ping = bound(0,0.07 - bound(0, (skill + self.bot_pingskill) * 0.005,0.05)+random()*0.01,0.65); // Now holds real lag to server, and higer skill players take a less laggy server
  68         // skill 10 = ping 0.2 (adrenaline)
  69         // skill 0 = ping 0.7 (slightly drunk)
  70
  71         // clear buttons
  72         self.BUTTON_ATCK = 0;
  73         self.button1 = 0;
  74         self.BUTTON_JUMP = 0;
  75         self.BUTTON_ATCK2 = 0;
  76         self.BUTTON_ZOOM = 0;
  77         self.BUTTON_CROUCH = 0;
  78         self.BUTTON_HOOK = 0;
  79         self.BUTTON_INFO = 0;
  80         self.button8 = 0;
  81         self.BUTTON_CHAT = 0;
  82         self.BUTTON_USE = 0;
  83
  84         // if dead, just wait until we can respawn
  85         if (self.deadflag)
  86         {
  87                 if (self.deadflag == DEAD_DEAD)
  88                 {
  89                         self.BUTTON_JUMP = 1; // press jump to respawn
  90                         self.bot_strategytime = 0;
  91                 }
  92         }
  93
  94         // now call the current bot AI (havocbot for example)
  95         self.bot_ai();
  96 };
  97
  98 void bot_setnameandstuff()
  99 {
 100         string readfile, s;
 101         float file, tokens, prio;
 102         entity p;
 103
 104         string bot_name, bot_model, bot_skin, bot_shirt, bot_pants;
 105         string name, prefix, suffix;
 106
 107         if(cvar("g_campaign"))
 108         {
 109                 prefix = "";
 110                 suffix = "";
 111         }
 112         else
 113         {
 114                 prefix = cvar_string("bot_prefix");
 115                 suffix = cvar_string("bot_suffix");
 116         }
 117
 118         file = fopen(cvar_string("bot_config_file"), FILE_READ);
 119
 120         if(file < 0)
 121                 print(strcat("Error: Can not open the bot configuration file '",cvar_string("bot_config_file"),"'\n"));
 122         else
 123         {
 124                 RandomSelection_Init();
 125                 for(;;)
 126                 {
 127                         readfile = fgets(file);
 128                         if(!readfile)
 129                                 break;
 130                         if(substring(readfile, 0, 2) == "//")
 131                                 continue;
 132                         if(substring(readfile, 0, 1) == "#")
 133                                 continue;
 134                         tokens = tokenizebyseparator(readfile, "\t");
 135                         s = argv(0);
 136                         prio = 1;
 137                         FOR_EACH_CLIENT(p)
 138                         {
 139                                 if(strcat(prefix, s, suffix) == p.netname)
 140                                 {
 141                                         prio = 0;
 142                                         break;
 143                                 }
 144                         }
 145                         RandomSelection_Add(world, 0, readfile, 1, prio);
 146                 }
 147                 readfile = RandomSelection_chosen_string;
 148                 fclose(file);
 149         }
 150
 151         tokens = tokenizebyseparator(readfile, "\t");
 152         if(argv(0) != "") bot_name = argv(0);
 153         else bot_name = "Bot";
 154
 155         if(argv(1) != "") bot_model = argv(1);
 156         else bot_model = "marine";
 157
 158         if(argv(2) != "") bot_skin = argv(2);
 159         else bot_skin = "0";
 160
 161         if(argv(3) != "" && stof(argv(3)) >= 0) bot_shirt = argv(3);
 162         else bot_shirt = ftos(floor(random() * 15));
 163
 164         if(argv(4) != "" && stof(argv(4)) >= 0) bot_pants = argv(4);
 165         else bot_pants = ftos(floor(random() * 15));
 166
 167         self.bot_forced_team = stof(argv(5));
 168
 169         prio = 6;
 170 #define READSKILL(f,w,r) if(argv(prio) != "") self.f = stof(argv(prio)) * (w); else self.f = (!cvar("g_campaign")) * (2 * random() - 1) * (r) * (w); ++prio
 171         //print(bot_name, ": ping=", argv(9), "\n");
 172
 173         READSKILL(havocbot_keyboardskill, 0.5, 0.5); // keyboards kill
 174         READSKILL(bot_moveskill, 2, 0); // moves kill
 175         READSKILL(bot_dodgeskill, 2, 0); // dodges kill
 176
 177         READSKILL(bot_pingskill, 0.5, 0); // pings kill
 178
 179         READSKILL(bot_weaponskill, 2, 0); // weapons kill
 180         READSKILL(bot_aggresskill, 1, 0); // aggres kill
 181         READSKILL(bot_rangepreference, 1, 0); // reads kill
 182
 183         READSKILL(bot_aimskill, 2, 0); // aims kill
 184         READSKILL(bot_offsetskill, 2, 0.5); // offsets kill
 185         READSKILL(bot_mouseskill, 1, 0.5); // mouses kill
 186
 187         READSKILL(bot_thinkskill, 1, 0.5); // thinks kill
 188         READSKILL(bot_aiskill, 2, 0); // "ai"s kill
 189
 190         self.bot_config_loaded = TRUE;
 191
 192         // this is really only a default, JoinBestTeam is called later
 193         setcolor(self, stof(bot_shirt) * 16 + stof(bot_pants));
 194         self.bot_preferredcolors = self.clientcolors;
 195
 196         // pick the name
 197         if (cvar("bot_usemodelnames"))
 198                 name = bot_model;
 199         else
 200                 name = bot_name;
 201
 202         // pick the model and skin
 203         if(substring(bot_model, -4, 1) != ".")
 204                 bot_model = strcat(bot_model, ".zym");
 205         self.playermodel = self.playermodel_freeme = strzone(strcat("models/player/", bot_model));
 206         self.playerskin = self.playerskin_freeme = strzone(bot_skin);
 207
 208         self.netname = self.netname_freeme = strzone(strcat(prefix, name, suffix));
 209 };
 210
 211 void bot_custom_weapon_priority_setup()
 212 {
 213         local float tokens, i, c, w;
 214
 215         bot_custom_weapon = FALSE;
 216
 217         if(     cvar_string("bot_ai_custom_weapon_priority_far") == "" ||
 218                 cvar_string("bot_ai_custom_weapon_priority_mid") == "" ||
 219                 cvar_string("bot_ai_custom_weapon_priority_close") == "" ||
 220                 cvar_string("bot_ai_custom_weapon_priority_distances") == ""
 221         )
 222                 return;
 223
 224         // Parse distances
 225         tokens = tokenizebyseparator(cvar_string("bot_ai_custom_weapon_priority_distances")," ");
 226
 227         if (tokens!=2)
 228                 return;
 229
 230         bot_distance_far = stof(argv(0));
 231         bot_distance_close = stof(argv(1));
 232
 233         if(bot_distance_far < bot_distance_close){
 234                 bot_distance_far = stof(argv(1));
 235                 bot_distance_close = stof(argv(0));
 236         }
 237
 238         // Initialize list of weapons
 239         bot_weapons_far[0] = -1;
 240         bot_weapons_mid[0] = -1;
 241         bot_weapons_close[0] = -1;
 242
 243         // Parse far distance weapon priorities
 244         tokens = tokenizebyseparator(cvar_string("bot_ai_custom_weapon_priority_far")," ");
 245
 246         c = 0;
 247         for(i=0; i < tokens && c < WEP_COUNT; ++i){
 248                 w = stof(argv(i));
 249                 if ( w >= WEP_FIRST && w <= WEP_LAST) {
 250                         bot_weapons_far[c] = w;
 251                         ++c;
 252                 }
 253         }
 254         if(c < WEP_COUNT)
 255                 bot_weapons_far[c] = -1;
 256
 257         // Parse mid distance weapon priorities
 258         tokens = tokenizebyseparator(cvar_string("bot_ai_custom_weapon_priority_mid")," ");
 259
 260         c = 0;
 261         for(i=0; i < tokens && c < WEP_COUNT; ++i){
 262                 w = stof(argv(i));
 263                 if ( w >= WEP_FIRST && w <= WEP_LAST) {
 264                         bot_weapons_mid[c] = w;
 265                         ++c;
 266                 }
 267         }
 268         if(c < WEP_COUNT)
 269                 bot_weapons_mid[c] = -1;
 270
 271         // Parse close distance weapon priorities
 272         tokens = tokenizebyseparator(cvar_string("bot_ai_custom_weapon_priority_close")," ");
 273
 274         c = 0;
 275         for(i=0; i < tokens && i < WEP_COUNT; ++i){
 276                 w = stof(argv(i));
 277                 if ( w >= WEP_FIRST && w <= WEP_LAST) {
 278                         bot_weapons_close[c] = w;
 279                         ++c;
 280                 }
 281         }
 282         if(c < WEP_COUNT)
 283                 bot_weapons_close[c] = -1;
 284
 285         bot_custom_weapon = TRUE;
 286 };
 287
 288 void bot_endgame()
 289 {
 290         local entity e;
 291         //dprint("bot_endgame\n");
 292         e = bot_list;
 293         while (e)
 294         {
 295                 setcolor(e, e.bot_preferredcolors);
 296                 e = e.nextbot;
 297         }
 298         // if dynamic waypoints are ever implemented, save them here
 299 };
 300
 301 void bot_relinkplayerlist()
 302 {
 303         local entity e;
 304         local entity prevbot;
 305         player_count = 0;
 306         currentbots = 0;
 307         player_list = e = findchainflags(flags, FL_CLIENT);
 308         bot_list = world;
 309         prevbot = world;
 310         while (e)
 311         {
 312                 player_count = player_count + 1;
 313                 e.nextplayer = e.chain;
 314                 if (clienttype(e) == CLIENTTYPE_BOT)
 315                 {
 316                         if (prevbot)
 317                                 prevbot.nextbot = e;
 318                         else
 319                         {
 320                                 bot_list = e;
 321                                 bot_list.nextbot = world;
 322                         }
 323                         prevbot = e;
 324                         currentbots = currentbots + 1;
 325                 }
 326                 e = e.chain;
 327         }
 328         dprint(strcat("relink: ", ftos(currentbots), " bots seen.\n"));
 329         bot_strategytoken = bot_list;
 330         bot_strategytoken_taken = TRUE;
 331 };
 332
 333 void bot_clientdisconnect()
 334 {
 335         if (clienttype(self) != CLIENTTYPE_BOT)
 336                 return;
 337         if(self.netname_freeme)
 338                 strunzone(self.netname_freeme);
 339         if(self.playermodel_freeme)
 340                 strunzone(self.playermodel_freeme);
 341         if(self.playerskin_freeme)
 342                 strunzone(self.playerskin_freeme);
 343         self.netname_freeme = string_null;
 344         self.playermodel_freeme = string_null;
 345         self.playerskin_freeme = string_null;
 346         remove(self.bot_cmd_current);
 347 }
 348
 349 void bot_clientconnect()
 350 {
 351         if (clienttype(self) != CLIENTTYPE_BOT)
 352                 return;
 353         self.bot_preferredcolors = self.clientcolors;
 354         self.bot_nextthink = time - random();
 355         self.lag_func = bot_lagfunc;
 356         self.isbot = TRUE;
 357         self.createdtime = self.nextthink;
 358
 359         if(!self.bot_config_loaded) // This is needed so team overrider doesn't break between matches
 360                 bot_setnameandstuff();
 361
 362         if(self.bot_forced_team==1)
 363                 self.team = COLOR_TEAM1;
 364         else if(self.bot_forced_team==2)
 365                 self.team = COLOR_TEAM2;
 366         else if(self.bot_forced_team==3)
 367                 self.team = COLOR_TEAM3;
 368         else if(self.bot_forced_team==4)
 369                 self.team = COLOR_TEAM4;
 370         else
 371                 JoinBestTeam(self, FALSE, TRUE);
 372
 373         havocbot_setupbot();
 374 };
 375
 376 void bot_removefromlargestteam()
 377 {
 378         local float besttime, bestcount, thiscount;
 379         local entity best, head;
 380         CheckAllowedTeams(world);
 381         GetTeamCounts(world);
 382         head = findchainfloat(isbot, TRUE);
 383         if (!head)
 384                 return;
 385         best = head;
 386         besttime = head.createdtime;
 387         bestcount = 0;
 388         while (head)
 389         {
 390                 if(head.team == COLOR_TEAM1)
 391                         thiscount = c1;
 392                 else if(head.team == COLOR_TEAM2)
 393                         thiscount = c2;
 394                 else if(head.team == COLOR_TEAM3)
 395                         thiscount = c3;
 396                 else if(head.team == COLOR_TEAM4)
 397                         thiscount = c4;
 398                 else
 399                         thiscount = 0;
 400                 if (thiscount > bestcount)
 401                 {
 402                         bestcount = thiscount;
 403                         besttime = head.createdtime;
 404                         best = head;
 405                 }
 406                 else if (thiscount == bestcount && besttime < head.createdtime)
 407                 {
 408                         besttime = head.createdtime;
 409                         best = head;
 410                 }
 411                 head = head.chain;
 412         }
 413         currentbots = currentbots - 1;
 414         dropclient(best);
 415 };
 416
 417 void bot_removenewest()
 418 {
 419         local float besttime;
 420         local entity best, head;
 421
 422         if(teams_matter)
 423         {
 424                 bot_removefromlargestteam();
 425                 return;
 426         }
 427
 428         head = findchainfloat(isbot, TRUE);
 429         if (!head)
 430                 return;
 431         best = head;
 432         besttime = head.createdtime;
 433         while (head)
 434         {
 435                 if (besttime < head.createdtime)
 436                 {
 437                         besttime = head.createdtime;
 438                         best = head;
 439                 }
 440                 head = head.chain;
 441         }
 442         currentbots = currentbots - 1;
 443         dropclient(best);
 444 };
 445
 446 void autoskill(float factor)
 447 {
 448         float bestbot;
 449         float bestplayer;
 450         entity head;
 451
 452         bestbot = -1;
 453         bestplayer = -1;
 454         FOR_EACH_PLAYER(head)
 455         {
 456                 if(clienttype(head) == CLIENTTYPE_REAL)
 457                         bestplayer = max(bestplayer, head.totalfrags - head.totalfrags_lastcheck);
 458                 else
 459                         bestbot = max(bestbot, head.totalfrags - head.totalfrags_lastcheck);
 460         }
 461
 462         dprint("autoskill: best player got ", ftos(bestplayer), ", ");
 463         dprint("best bot got ", ftos(bestbot), "; ");
 464         if(bestbot < 0 || bestplayer < 0)
 465         {
 466                 dprint("not doing anything\n");
 467                 // don't return, let it reset all counters below
 468         }
 469         else if(bestbot <= bestplayer * factor - 2)
 470         {
 471                 if(cvar("skill") < 17)
 472                 {
 473                         dprint("2 frags difference, increasing skill\n");
 474                         cvar_set("skill", ftos(cvar("skill") + 1));
 475                         bprint("^2SKILL UP!^7 Now at level ", ftos(cvar("skill")), "\n");
 476                 }
 477         }
 478         else if(bestbot >= bestplayer * factor + 2)
 479         {
 480                 if(cvar("skill") > 0)
 481                 {
 482                         dprint("2 frags difference, decreasing skill\n");
 483                         cvar_set("skill", ftos(cvar("skill") - 1));
 484                         bprint("^1SKILL DOWN!^7 Now at level ", ftos(cvar("skill")), "\n");
 485                 }
 486         }
 487         else
 488         {
 489                 dprint("not doing anything\n");
 490                 return;
 491                 // don't reset counters, wait for them to accumulate
 492         }
 493
 494         FOR_EACH_PLAYER(head)
 495                 head.totalfrags_lastcheck = head.totalfrags;
 496 }
 497
 498 void bot_serverframe()
 499 {
 500         float realplayers, bots, activerealplayers;
 501         entity head;
 502
 503         if (intermission_running)
 504                 return;
 505
 506         if (time < 2)
 507                 return;
 508
 509         stepheightvec = cvar("sv_stepheight") * '0 0 1';
 510         bot_navigation_movemode = ((cvar("bot_navigation_ignoreplayers")) ? MOVE_NOMONSTERS : MOVE_NORMAL);
 511
 512         if(time > autoskill_nextthink)
 513         {
 514                 float a;
 515                 a = cvar("skill_auto");
 516                 if(a)
 517                         autoskill(a);
 518                 autoskill_nextthink = time + 5;
 519         }
 520
 521         activerealplayers = 0;
 522         realplayers = 0;
 523
 524         FOR_EACH_REALCLIENT(head)
 525         {
 526                 if(head.classname == "player" || g_lms || g_arena)
 527                         ++activerealplayers;
 528                 ++realplayers;
 529         }
 530
 531         // add/remove bots if needed to make sure there are at least
 532         // minplayers+bot_number, or remove all bots if no one is playing
 533         // But don't remove bots immediately on level change, as the real players
 534         // usually haven't rejoined yet
 535         bots_would_leave = FALSE;
 536         if ((realplayers || cvar("bot_join_empty") || (currentbots > 0 && time < 5)))
 537         {
 538                 float realminplayers, minplayers;
 539                 realminplayers = cvar("minplayers");
 540                 minplayers = max(0, floor(realminplayers));
 541
 542                 float realminbots, minbots;
 543                 if(teamplay && cvar("bot_vs_human"))
 544                         realminbots = ceil(fabs(cvar("bot_vs_human")) * activerealplayers);
 545                 else
 546                         realminbots = cvar("bot_number");
 547                 minbots = max(0, floor(realminbots));
 548
 549                 bots = min(max(minbots, minplayers - activerealplayers), maxclients - realplayers);
 550                 if(bots > minbots)
 551                         bots_would_leave = TRUE;
 552         }
 553         else
 554         {
 555                 // if there are no players, remove bots
 556                 bots = 0;
 557         }
 558
 559         bot_ignore_bots = cvar("bot_ignore_bots");
 560
 561         // only add one bot per frame to avoid utter chaos
 562         if(time > botframe_nextthink)
 563         {
 564                 //dprint(ftos(bots), " ? ", ftos(currentbots), "\n");
 565                 while (currentbots < bots)
 566                 {
 567                         if (bot_spawn() == world)
 568                         {
 569                                 bprint("Can not add bot, server full.\n");
 570                                 botframe_nextthink = time + 10;
 571                                 break;
 572                         }
 573                 }
 574                 while (currentbots > bots)
 575                         bot_removenewest();
 576         }
 577
 578         if(botframe_spawnedwaypoints)
 579         {
 580                 if(cvar("waypoint_benchmark"))
 581                         localcmd("quit\n");
 582         }
 583
 584         if (currentbots > 0 || cvar("g_waypointeditor"))
 585         if (botframe_spawnedwaypoints)
 586         {
 587                 if(botframe_cachedwaypointlinks)
 588                 {
 589                         if(!botframe_loadedforcedlinks)
 590                                 waypoint_load_links_hardwired();
 591                 }
 592                 else
 593                 {
 594                         // TODO: Make this check cleaner
 595                         local entity wp = findchain(classname, "waypoint");
 596                         if(time - wp.nextthink > 10)
 597                                 waypoint_save_links();
 598                 }
 599         }
 600         else
 601         {
 602                 botframe_spawnedwaypoints = TRUE;
 603                 waypoint_loadall();
 604                 if(!waypoint_load_links())
 605                         waypoint_schedulerelinkall();
 606         }
 607
 608         if (bot_list)
 609         {
 610                 // cycle the goal token from one bot to the next each frame
 611                 // (this prevents them from all doing spawnfunc_waypoint searches on the same
 612                 //  frame, which causes choppy framerates)
 613                 if (bot_strategytoken_taken)
 614                 {
 615                         bot_strategytoken_taken = FALSE;
 616                         if (bot_strategytoken)
 617                                 bot_strategytoken = bot_strategytoken.nextbot;
 618                         if (!bot_strategytoken)
 619                                 bot_strategytoken = bot_list;
 620                 }
 621
 622                 if (botframe_nextdangertime < time)
 623                 {
 624                         local float interval;
 625                         interval = cvar("bot_ai_dangerdetectioninterval");
 626                         if (botframe_nextdangertime < time - interval * 1.5)
 627                                 botframe_nextdangertime = time;
 628                         botframe_nextdangertime = botframe_nextdangertime + interval;
 629                         botframe_updatedangerousobjects(cvar("bot_ai_dangerdetectionupdates"));
 630                 }
 631         }
 632
 633         if (cvar("g_waypointeditor"))
 634                 botframe_showwaypointlinks();
 635
 636         if(time > bot_cvar_nextthink)
 637         {
 638                 if(currentbots>0)
 639                         bot_custom_weapon_priority_setup();
 640                 bot_cvar_nextthink = time + 5;
 641         }
 642 };