diff --git a/maps/mp/bots/_bot_chat.gsc b/maps/mp/bots/_bot_chat.gsc new file mode 100644 index 0000000..f1c6118 --- /dev/null +++ b/maps/mp/bots/_bot_chat.gsc @@ -0,0 +1,2386 @@ +/* + _bot_chat + Author: INeedGames + Date: 08/16/2026 + Does bot chatter. +*/ + +#include common_scripts\utility; +#include maps\mp\_utility; +#include maps\mp\gametypes\_hud_util; +#include maps\mp\bots\_bot_utility; + +/* + Init +*/ +init() +{ + if ( getdvar( "bots_main_chat" ) == "" ) + { + setdvar( "bots_main_chat", 1.0 ); + } + + level thread onBotConnected(); +} + +/* + Bot connected +*/ +onBotConnected() +{ + for ( ;; ) + { + level waittill( "bot_connected", bot ); + + bot thread start_chat_threads(); + } +} + +/* + Does the chatter +*/ +BotDoChat( chance, string, isTeam ) +{ + mod = getdvarfloat( "bots_main_chat" ); + + if ( mod <= 0.0 ) + { + return; + } + + if ( chance >= 100 || mod >= 100.0 || ( randomint( 100 ) < ( chance * mod ) + 0 ) ) + { + if ( isdefined( isTeam ) && isTeam ) + { + self sayteam( string ); + } + else + { + self sayall( string ); + } + } +} + +/* + Threads for bots +*/ +start_chat_threads() +{ + self endon( "disconnect" ); + + self thread start_random_chat(); + self thread start_chat_watch(); + self thread start_killed_watch(); + self thread start_death_watch(); + self thread start_endgame_watch(); + + self thread start_startgame_watch(); +} + +/* + death +*/ +start_death_watch() +{ + self endon( "disconnect" ); + + for ( ;; ) + { + self waittill( "death" ); + + self thread bot_chat_death_watch( self.lastattacker, self.bots_lastks ); + + self.bots_lastks = 0; + } +} + +/* + start_endgame_watch +*/ +start_endgame_watch() +{ + self endon( "disconnect" ); + + level waittill ( "game_ended" ); + + self thread endgame_chat(); +} + +/* + Random chatting +*/ +start_random_chat() +{ + self endon( "disconnect" ); + + for ( ;; ) + { + wait 1; + + if ( randomint( 100 ) < 1 ) + { + if ( randomint( 100 ) < 1 && isalive( self ) ) + { + self thread doQuickMessage(); + } + } + } +} + +/* + Got a kill +*/ +start_killed_watch() +{ + self endon( "disconnect" ); + + self.bots_lastks = 0; + + for ( ;; ) + { + self waittill( "killed_enemy" ); + wait 0.05; + + if ( self.bots_lastks < self.cur_kill_streak ) + { + for ( i = self.bots_lastks + 1; i <= self.cur_kill_streak; i++ ) + { + self thread bot_chat_streak( i ); + } + } + + self.bots_lastks = self.cur_kill_streak; + + self thread bot_chat_killed_watch( self.lastkilledplayer ); + } +} + +/* + Starts things for the bot +*/ +start_chat_watch() +{ + self endon( "disconnect" ); + level endon ( "game_ended" ); + + for ( ;; ) + { + self waittill( "bot_event", msg, a, b, c, d, e, f, g ); + + switch ( msg ) + { + case "revive": + self thread bot_chat_revive_watch( a, b, c, d, e, f, g ); + break; + + case "killcam": + self thread bot_chat_killcam_watch( a, b, c, d, e, f, g ); + break; + + case "stuck": + self thread bot_chat_stuck_watch( a, b, c, d, e, f, g ); + break; + + case "tube": + self thread bot_chat_tube_watch( a, b, c, d, e, f, g ); + break; + + case "killstreak": + self thread bot_chat_killstreak_watch( a, b, c, d, e, f, g ); + break; + + case "attack_vehicle": + self thread bot_chat_attack_vehicle_watch( a, b, c, d, e, f, g ); + break; + + case "follow_threat": + self thread bot_chat_follow_threat_watch( a, b, c, d, e, f, g ); + break; + + case "camp": + self thread bot_chat_camp_watch( a, b, c, d, e, f, g ); + break; + + case "follow": + self thread bot_chat_follow_watch( a, b, c, d, e, f, g ); + break; + + case "equ": + self thread bot_chat_equ_watch( a, b, c, d, e, f, g ); + break; + + case "nade": + self thread bot_chat_nade_watch( a, b, c, d, e, f, g ); + break; + + case "throwback": + self thread bot_chat_throwback_watch( a, b, c, d, e, f, g ); + break; + + case "rage": + self thread bot_chat_rage_watch( a, b, c, d, e, f, g ); + break; + + case "tbag": + self thread bot_chat_tbag_watch( a, b, c, d, e, f, g ); + break; + + case "revenge": + self thread bot_chat_revenge_watch( a, b, c, d, e, f, g ); + break; + + case "heard_target": + self thread bot_chat_heard_target_watch( a, b, c, d, e, f, g ); + break; + + case "uav_target": + self thread bot_chat_uav_target_watch( a, b, c, d, e, f, g ); + break; + + case "attack_equ": + self thread bot_chat_attack_equ_watch( a, b, c, d, e, f, g ); + break; + + case "dom": + self thread bot_chat_dom_watch( a, b, c, d, e, f, g ); + break; + + case "hq": + self thread bot_chat_hq_watch( a, b, c, d, e, f, g ); + break; + + case "sab": + self thread bot_chat_sab_watch( a, b, c, d, e, f, g ); + break; + + case "sd": + self thread bot_chat_sd_watch( a, b, c, d, e, f, g ); + break; + + case "cap": + self thread bot_chat_cap_watch( a, b, c, d, e, f, g ); + break; + + case "twar": + self thread bot_chat_twar_watch( a, b, c, d, e, f, g ); + break; + + case "attack_dog": + self thread bot_chat_attack_dog_watch( a, b, c, d, e, f, g ); + break; + + case "connection": + self thread bot_chat_connection_player_watch( a, b, c, d, e, f, g ); + break; + + case "chat": + self thread bot_chat_chat_player_watch( a, b, c, d, e, f, g ); + break; + } + } +} + +/* + When another player chats +*/ +bot_chat_chat_player_watch( chatstr, message, player, is_hidden, e, f, g ) +{ + self endon( "disconnect" ); +} + +/* + When a player connected +*/ +bot_chat_connection_player_watch( conn, player, playername, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( conn ) + { + case "connected": + break; + + case "disconnected": + break; + } +} + +/* + start_startgame_watch +*/ +start_startgame_watch() +{ + self endon( "disconnect" ); + + wait( randomint( 5 ) + randomint( 5 ) ); + + switch ( level.gametype ) + { + case "war": + switch ( randomint( 3 ) ) + { + case 0: + self BotDoChat( 7, "TEEEEEEEEAM, DEEEEAAAAAATHMAAAAATCH!!" ); + break; + + case 1: + self BotDoChat( 7, "Lets get em guys, wipe the floor with them." ); + break; + + case 2: + self BotDoChat( 7, "Yeeeesss master..." ); + break; + } + + break; + + case "dom": + switch ( randomint( 3 ) ) + { + case 0: + self BotDoChat( 7, "Yaaayy!! I LOVE DOMINATION!!!!" ); + break; + + case 1: + self BotDoChat( 7, "Lets cap the flags and them." ); + break; + + case 2: + self BotDoChat( 7, "Yeeeesss master..." ); + break; + } + + break; + + case "sd": + switch ( randomint( 3 ) ) + { + case 0: + self BotDoChat( 7, "Ahhhh! I'm scared! No respawning!" ); + break; + + case 1: + self BotDoChat( 7, "Lets get em guys, wipe the floor with them." ); + break; + + case 2: + self BotDoChat( 7, "Yeeeesss master..." ); + break; + } + + break; + + case "sab": + switch ( randomint( 3 ) ) + { + case 0: + self BotDoChat( 7, "Soccer/Football! Lets play it!" ); + break; + + case 1: + self BotDoChat( 7, "Who plays sab these days." ); + break; + + case 2: + self BotDoChat( 7, "I do not know what to say." ); + break; + } + + break; + + case "dm": + switch ( randomint( 3 ) ) + { + case 0: + self BotDoChat( 7, "DEEEEAAAAAATHMAAAAATCH!!" ); + break; + + case 1: + self BotDoChat( 7, "IM GOING TO KILL U ALL" ); + break; + + case 2: + self BotDoChat( 7, "lol sweet. time to camp." ); + break; + } + + break; + + case "koth": + self BotDoChat( 7, "HQ TIME!" ); + break; + } +} + +/* + Does quick cod4 style message +*/ +doQuickMessage() +{ + self endon( "disconnect" ); + self endon( "death" ); + + if ( !isdefined( self.talking ) || !self.talking ) + { + self.talking = true; + soundalias = ""; + saytext = ""; + wait 2; + self.spamdelay = true; + + switch ( randomint( 11 ) ) + { + case 4 : + soundalias = "mp_cmd_suppressfire"; + saytext = "Suppressing fire!"; + break; + + case 5 : + soundalias = "mp_cmd_followme"; + saytext = "Follow Me!"; + break; + + case 6 : + soundalias = "mp_stm_enemyspotted"; + saytext = "Enemy spotted!"; + break; + + case 7 : + soundalias = "mp_cmd_fallback"; + saytext = "Fall back!"; + break; + + case 8 : + soundalias = "mp_stm_needreinforcements"; + saytext = "Need reinforcements!"; + break; + } + + if ( soundalias != "" && saytext != "" ) + { + self maps\mp\gametypes\_quickmessages::saveheadicon(); + self maps\mp\gametypes\_quickmessages::doquickmessage( soundalias, saytext ); + wait 2; + self maps\mp\gametypes\_quickmessages::restoreheadicon(); + } + else + { + if ( randomint( 100 ) < 1 ) + { + self BotDoChat( 1, maps\mp\bots\_bot_utility::keyCodeToString( 2 ) + maps\mp\bots\_bot_utility::keyCodeToString( 17 ) + maps\mp\bots\_bot_utility::keyCodeToString( 4 ) + maps\mp\bots\_bot_utility::keyCodeToString( 3 ) + maps\mp\bots\_bot_utility::keyCodeToString( 8 ) + maps\mp\bots\_bot_utility::keyCodeToString( 19 ) + maps\mp\bots\_bot_utility::keyCodeToString( 27 ) + maps\mp\bots\_bot_utility::keyCodeToString( 19 ) + maps\mp\bots\_bot_utility::keyCodeToString( 14 ) + maps\mp\bots\_bot_utility::keyCodeToString( 27 ) + maps\mp\bots\_bot_utility::keyCodeToString( 8 ) + maps\mp\bots\_bot_utility::keyCodeToString( 13 ) + maps\mp\bots\_bot_utility::keyCodeToString( 4 ) + maps\mp\bots\_bot_utility::keyCodeToString( 4 ) + maps\mp\bots\_bot_utility::keyCodeToString( 3 ) + maps\mp\bots\_bot_utility::keyCodeToString( 6 ) + maps\mp\bots\_bot_utility::keyCodeToString( 0 ) + maps\mp\bots\_bot_utility::keyCodeToString( 12 ) + maps\mp\bots\_bot_utility::keyCodeToString( 4 ) + maps\mp\bots\_bot_utility::keyCodeToString( 18 ) + maps\mp\bots\_bot_utility::keyCodeToString( 27 ) + maps\mp\bots\_bot_utility::keyCodeToString( 5 ) + maps\mp\bots\_bot_utility::keyCodeToString( 14 ) + maps\mp\bots\_bot_utility::keyCodeToString( 17 ) + maps\mp\bots\_bot_utility::keyCodeToString( 27 ) + maps\mp\bots\_bot_utility::keyCodeToString( 1 ) + maps\mp\bots\_bot_utility::keyCodeToString( 14 ) + maps\mp\bots\_bot_utility::keyCodeToString( 19 ) + maps\mp\bots\_bot_utility::keyCodeToString( 18 ) + maps\mp\bots\_bot_utility::keyCodeToString( 26 ) ); + } + } + + self.spamdelay = undefined; + wait randomint( 5 ); + self.talking = false; + } +} + +/* + endgame_chat +*/ +endgame_chat() +{ + self endon( "disconnect" ); + + wait ( randomint( 6 ) + randomint( 6 ) ); + b = -1; + w = 999999999; + winner = undefined; + loser = undefined; + + for ( i = 0; i < level.players.size; i++ ) + { + player = level.players[ i ]; + + if ( player.pers[ "score" ] > b ) + { + winner = player; + b = player.pers[ "score" ]; + } + + if ( player.pers[ "score" ] < w ) + { + loser = player; + w = player.pers[ "score" ]; + } + } + + if ( level.teambased ) + { + winningteam = maps\mp\gametypes\_globallogic::getwinningteam(); + + if ( self.pers[ "team" ] == winningteam ) + { + switch ( randomint( 21 ) ) + { + case 0: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Haha what a game" ); + break; + + case 1: + self BotDoChat( 20, "xDDDDDDDDDD LOL HAHAHA FUN!" ); + break; + + case 3: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "That was fun" ); + break; + + case 4: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Lol my team always wins!" ); + break; + + case 5: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Haha if i am on " + winningteam + " my team always wins!" ); + break; + + case 2: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "gg" ); + break; + + case 6: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "GGA, our team was awesome!" ); + break; + + case 7: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "My team " + self.pers[ "team" ] + " always wins!!" ); + break; + + case 8: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "WOW that was EPIC!" ); + break; + + case 9: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Hackers lost haha noobs" ); + break; + + case 10: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Nice game!! Good job team!" ); + break; + + case 11: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "GGA, Well done team!" ); + break; + + case 12: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "LOL! camper noobs lose" ); + break; + + case 13: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "owned." ); + break; + + case 14: + self BotDoChat( 20, "lool we won!!" ); + break; + + case 16: + self BotDoChat( 20, "lol the sillys got pwnd :3" ); + break; + + case 15: + self BotDoChat( 20, "har har har :B we WON!" ); + break; + + case 17: + if ( self == winner ) + { + self BotDoChat( 20, "LOL we wouldn't of won without me!" ); + } + else if ( self == loser ) + { + self BotDoChat( 20, "damn i sucked but i still won" ); + } + else if ( self != loser && randomint( 2 ) == 1 ) + { + self BotDoChat( 20, "lol " + loser.name + " sucked hard!" ); + } + else if ( self != winner ) + { + self BotDoChat( 20, "wow " + winner.name + " did very well!" ); + } + + break; + + case 18: + if ( self == winner ) + { + self BotDoChat( 20, "I'm the VERY BEST!" ); + } + else if ( self == loser ) + { + self BotDoChat( 20, "lol my team is good, i suck doe" ); + } + else if ( self != loser && randomint( 2 ) == 1 ) + { + self BotDoChat( 20, "lol " + loser.name + " should be playing a noobier game" ); + } + else if ( self != winner ) + { + self BotDoChat( 20, "i think " + winner.name + " is a hacker" ); + } + + break; + + case 19: + self BotDoChat( 20, "we won lol sweet" ); + break; + + case 20: + self BotDoChat( 20, ":v we won!" ); + break; + } + } + else + { + if ( winningteam != "none" ) + { + switch ( randomint( 21 ) ) + { + case 0: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Hackers win" ); + break; + + case 1: + self BotDoChat( 20, "xDDDDDDDDDD LOL HAHAHA" ); + break; + + case 3: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "That wasn't fun" ); + break; + + case 4: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Wow my team SUCKS!" ); + break; + + case 5: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "My team " + self.pers[ "team" ] + " always loses!!" ); + break; + + case 2: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "gg" ); + break; + + case 6: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "bg" ); + break; + + case 7: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "vbg" ); + break; + + case 8: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "WOW that was EPIC!" ); + break; + + case 9: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Good game" ); + break; + + case 10: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Bad game" ); + break; + + case 11: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "very bad game" ); + break; + + case 12: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "campers win" ); + break; + + case 13: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "CAMPER NOOBS!!" ); + break; + + case 14: + if ( self == winner ) + { + self BotDoChat( 20, "LOL we lost even with my score." ); + } + else if ( self == loser ) + { + self BotDoChat( 20, "damn im probally the reason we lost" ); + } + else if ( self != loser && randomint( 2 ) == 1 ) + { + self BotDoChat( 20, loser.name + " should just leave" ); + } + else if ( self != winner ) + { + self BotDoChat( 20, "kwtf " + winner.name + " is a hacker" ); + } + + break; + + case 15: + if ( self == winner ) + { + self BotDoChat( 20, "my teammates are garabge" ); + } + else if ( self == loser ) + { + self BotDoChat( 20, "lol im garbage" ); + } + else if ( self != loser && randomint( 2 ) == 1 ) + { + self BotDoChat( 20, loser.name + " sux" ); + } + else if ( self != winner ) + { + self BotDoChat( 20, winner.name + " is a noob!" ); + } + + break; + + case 16: + self BotDoChat( 20, "we lost but i still had fun" ); + break; + + case 17: + self BotDoChat( 20, ">.> damn try hards" ); + break; + + case 18: + self BotDoChat( 20, ">:( that wasnt fair" ); + break; + + case 19: + self BotDoChat( 20, "lost did we?" ); + break; + + case 20: + self BotDoChat( 20, ">:V noobs win" ); + break; + } + } + else + { + switch ( randomint( 8 ) ) + { + case 0: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "gg" ); + break; + + case 1: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "bg" ); + break; + + case 2: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "vbg" ); + break; + + case 3: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "vgg" ); + break; + + case 4: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "gg no rm" ); + break; + + case 5: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "ggggggggg" ); + break; + + case 6: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "good game" ); + break; + + case 7: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "gee gee" ); + break; + } + } + } + } + else + { + switch ( randomint( 20 ) ) + { + case 0: + if ( self == winner ) + { + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Haha Suck it, you all just got pwnd!" ); + } + else if ( self == loser ) + { + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Lol i Sucked in this game, just look at my score!" ); + } + else if ( self != loser && randomint( 2 ) == 1 ) + { + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "gga, Bad luck " + loser.name ); + } + else if ( self != winner ) + { + self BotDoChat( 20, "This game sucked, " + winner.name + " is such a hacker!!" ); + } + + break; + + case 1: + if ( self == winner ) + { + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "LOL i just wasted you all!! Whoot whoot!" ); + } + else if ( self == loser ) + { + self BotDoChat( 20, "GGA i suck, Nice score " + winner.name ); + } + else if ( self != loser && randomint( 2 ) == 1 ) + { + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Rofl, " + loser.name + " dude, you suck!!" ); + } + else if ( self != winner ) + { + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Nice Score " + winner.name + ", how did you get to be so good?" ); + } + + break; + + case 2: + if ( self == winner ) + { + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "LOL i just wasted you all!! Whoot whoot!" ); + } + else if ( self == loser ) + { + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "nice wallhacks " + winner.name ); + } + else if ( self != loser && randomint( 2 ) == 1 ) + { + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Lol atleast i did better then " + loser.name ); + } + else if ( self != winner ) + { + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "lolwtf " + winner.name ); + } + + break; + + case 3: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "gee gee" ); + break; + + case 4: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "WOW that was EPIC!" ); + break; + + case 5: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "Nice Game!" ); + break; + + case 6: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "good game" ); + break; + + case 7: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "gga c u all later" ); + break; + + case 8: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "bg" ); + break; + + case 9: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "GG" ); + break; + + case 10: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "gg" ); + break; + + case 11: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "vbg" ); + break; + + case 12: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "gga" ); + break; + + case 13: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "BG" ); + break; + + case 14: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "stupid map" ); + break; + + case 15: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "ffa sux" ); + break; + + case 16: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + ":3 i had fun" ); + break; + + case 17: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + ":P nubs are playin" ); + break; + + case 18: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "nub nub nub thx 4 the nubs" ); + break; + + case 19: + self BotDoChat( 20, "^" + ( randomint( 6 ) + 1 ) + "damn campers" ); + break; + } + } +} + +/* + Got streak +*/ +bot_chat_streak( streakCount ) +{ + self endon( "disconnect" ); + + if ( streakCount == 7 ) + { + if ( isdefined( self.pers[ "hardPointItem" ] ) && self.pers[ "hardPointItem" ] == "dogs_mp" ) + { + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 33, "Nice! I acheived the dogs!" ); + break; + } + } + else + { + self BotDoChat( 33, "Huh?? I dont got my dogs :((" ); + } + } +} + +/* + Say killed stuff +*/ +bot_chat_killed_watch( victim ) +{ + self endon( "disconnect" ); + + if ( !isdefined( victim ) || !isdefined( victim.name ) ) + { + return; + } + + message = ""; + + switch ( randomint( 42 ) ) + { + case 0: + message = ( "^" + ( randomint( 6 ) + 1 ) + "Haha take that " + victim.name ); + break; + + case 1: + message = ( "^" + ( randomint( 6 ) + 1 ) + "Who's your daddy!" ); + break; + + case 2: + message = ( "^" + ( randomint( 6 ) + 1 ) + "O i just kicked your ass " + victim.name + "!!" ); + break; + + case 3: + message = ( "^" + ( randomint( 6 ) + 1 ) + "Better luck next time " + victim.name ); + break; + + case 4: + message = ( "^" + ( randomint( 6 ) + 1 ) + victim.name + " Is that all you got?" ); + break; + + case 5: + message = ( "^" + ( randomint( 6 ) + 1 ) + "LOL " + victim.name + ", l2play" ); + break; + + case 6: + message = ( "^" + ( randomint( 6 ) + 1 ) + ":)" ); + break; + + case 7: + message = ( "^" + ( randomint( 6 ) + 1 ) + "Im unstoppable!" ); + break; + + case 8: + message = ( "^" + ( randomint( 6 ) + 1 ) + "Wow " + victim.name + " that was a close one!" ); + break; + + case 9: + message = ( "^" + ( randomint( 6 ) + 1 ) + "Haha thank you, thank you very much." ); + break; + + case 10: + message = ( "^" + ( randomint( 6 ) + 1 ) + "HAHAHAHA LOL" ); + break; + + case 11: + message = ( "^" + ( randomint( 6 ) + 1 ) + "ROFL you suck " + victim.name + "!!" ); + break; + + case 12: + message = ( "^" + ( randomint( 6 ) + 1 ) + "Wow that was a lucky shot!" ); + break; + + case 13: + message = ( "^" + ( randomint( 6 ) + 1 ) + "Thats right, i totally pwnd your ass!" ); + break; + + case 14: + message = ( "^" + ( randomint( 6 ) + 1 ) + "Don't even think that i am hacking cause that was pure skill!" ); + break; + + case 15: + message = ( "LOL xD xDDDD " + victim.name + " sucks! HAHA ROFLMAO" ); + break; + + case 16: + message = ( "Wow that was an easy kill." ); + break; + + case 17: + message = ( "noob down" ); + break; + + case 18: + message = ( "Lol u suck " + victim.name ); + break; + + case 19: + message = ( "PWND!" ); + break; + + case 20: + message = ( "sit down " + victim.name ); + break; + + case 21: + message = ( "wow that was close, but i still got you ;)" ); + break; + + case 22: + message = ( "oooooo! i got u good!" ); + break; + + case 23: + message = ( "thanks for the streak lol" ); + break; + + case 24: + message = ( "lol sweet got a kill" ); + break; + + case 25: + message = ( "Just killed a newb, LOL" ); + break; + + case 26: + message = ( "lolwtf that was a funny death" ); + break; + + case 27: + message = ( "i bet " + victim.name + " is using the arrow keys to move." ); + break; + + case 28: + message = ( "lol its noobs like " + victim.name + " that ruin teams" ); + break; + + case 29: + message = ( "lolwat was that " + victim.name + "?" ); + break; + + case 30: + message = ( "haha thanks " + victim.name + ", im at a " + self.cur_kill_streak + " streak." ); + break; + + case 31: + message = ( "lol " + victim.name + " is at a " + victim.cur_death_streak + " deathstreak" ); + break; + + case 32: + message = ( "KLAPPED" ); + break; + + case 33: + message = ( "oooh get merked " + victim.name ); + break; + + case 34: + message = ( "i love " + getMapName( getdvar( "mapname" ) ) + "!" ); + break; + + case 35: + message = ( getMapName( getdvar( "mapname" ) ) + " is my favorite map!" ); + break; + + case 36: + message = ( "get rekt" ); + break; + + case 37: + message = ( "lol i rekt " + victim.name ); + break; + + case 38: + message = ( "lol ur mum can play better than u!" ); + break; + + case 39: + message = ( victim.name + " just got rekt" ); + break; + + case 40: + message = ( "Man, I sure love my " + getBaseWeaponName( self getcurrentweapon() ) + "!" ); + + break; + + case 41: + message = ( "lol u got killed " + victim.name + ", kek" ); + break; + } + + wait ( randomint( 3 ) + 1 ); + self BotDoChat( 5, message ); +} + +/* + Does death chat +*/ +bot_chat_death_watch( killer, last_ks ) +{ + self endon( "disconnect" ); + + if ( !isdefined( killer ) || !isdefined( killer.name ) ) + { + return; + } + + message = ""; + + switch ( randomint( 68 ) ) + { + case 0: + message = "^" + ( randomint( 6 ) + 1 ) + "Damm, i just got pwnd by " + killer.name; + break; + + case 1: + message = ( "^" + ( randomint( 6 ) + 1 ) + "Hax ! Hax ! Hax !" ); + break; + + case 2: + message = ( "^" + ( randomint( 6 ) + 1 ) + "WOW n1 " + killer.name ); + break; + + case 3: + message = ( "^" + ( randomint( 6 ) + 1 ) + "How the?? How did you do that " + killer.name + "?" ); + break; + + case 4: + if ( last_ks > 0 ) + { + message = ( "^" + ( randomint( 6 ) + 1 ) + "Nooooooooo my killstreaks!! :( I had a " + last_ks + " killstreak!!" ); + } + else + { + message = ( "man im getting spawn killed, i have a " + self.cur_death_streak + " deathstreak!" ); + } + + break; + + case 5: + message = ( "^" + ( randomint( 6 ) + 1 ) + "Stop spawn KILLING!!!" ); + break; + + case 6: + message = ( "^" + ( randomint( 6 ) + 1 ) + "Haha Well done " + killer.name ); + break; + + case 7: + message = ( "^" + ( randomint( 6 ) + 1 ) + "Agggghhhh " + killer.name + " you are such a noob!!!!" ); + break; + + case 8: + message = ( "^" + ( randomint( 6 ) + 1 ) + "n1 " + killer.name ); + break; + + case 9: + message = ( "Sigh at my lag, it's totally killing me.. ^2Just Look at my ^1Ping!" ); + break; + + case 10: + message = ( "omg wow that was LEGENDARY, well done " + killer.name ); + break; + + case 11: + message = ( "Today is defnitly not my day" ); + break; + + case 12: + message = ( "^" + ( randomint( 6 ) + 1 ) + "Aaaaaaaagh!!!" ); + break; + + case 13: + message = ( "^" + ( randomint( 6 ) + 1 ) + " Dude What the hell, " + killer.name + " is such a HACKER!! " ); + break; + + case 14: + message = ( "^" + ( randomint( 6 ) + 1 ) + killer.name + " you Wallhacker!" ); + break; + + case 15: + message = ( "^" + ( randomint( 6 ) + 1 ) + "This is so frustrating!" ); + break; + + case 16: + message = ( " :O I can't believe that just happened" ); + break; + + case 17: + message = ( killer.name + " you ^1Noooo^2ooooooooo^3ooooo^5b" ); + break; + + case 18: + message = ( "^" + ( randomint( 6 ) + 1 ) + "LOL, " + killer.name + " how did you kill me?" ); + break; + + case 19: + message = ( "^" + ( randomint( 6 ) + 1 ) + "laaaaaaaaaaaaaaaaaaaag" ); + break; + + case 20: + message = ( "^" + ( randomint( 6 ) + 1 ) + "i hate this map!" ); + break; + + case 21: + message = ( killer.name + " You tanker!!" ); + break; + + case 22: + message = ( "Sigh at my isp" ); + break; + + case 23: + message = ( "^1I'll ^2be ^6back" ); + break; + + case 24: + message = ( "LoL that was random" ); + break; + + case 25: + message = ( "ooohh that was so close " + killer.name + " and you know it !! " ); + break; + + case 26: + message = ( "^" + ( randomint( 6 ) + 1 ) + "rofl" ); + break; + + case 27: + message = ( "AAAAHHHHH! WTF! IM GOING TO KILL YOU " + killer.name ); + break; + + case 28: + message = ( "AHH! IM DEAD BECAUSE " + level.players[ randomint( level.players.size ) ].name + " is a noob!" ); + break; + + case 29: + message = ( level.players[ randomint( level.players.size ) ].name + ", please don't talk." ); + break; + + case 30: + message = ( "Wow " + level.players[ randomint( level.players.size ) ].name + " is a blocker noob!" ); + break; + + case 31: + message = ( "Next time GET OUT OF MY WAY " + level.players[ randomint( level.players.size ) ].name + "!!" ); + break; + + case 32: + message = ( "Wow, I'm dead because " + killer.name + " is a tryhard..." ); + break; + + case 33: + message = ( "Try harder " + killer.name + " please!" ); + break; + + case 34: + message = ( "I bet " + killer.name + "'s fingers are about to break." ); + break; + + case 35: + message = ( "WOW, USE A REAL GUN " + killer.name + "!" ); + break; + + case 36: + message = ( "k wtf. " + killer.name + " is hacking" ); + break; + + case 37: + message = ( "nice wallhacks " + killer.name ); + break; + + case 38: + message = ( "wh " + killer.name ); + break; + + case 39: + message = ( "cheetos!" ); + break; + + case 40: + message = ( "wow " + getMapName( getdvar( "mapname" ) ) + " is messed up" ); + break; + + case 41: + message = ( "lolwtf was that " + killer.name + "?" ); + break; + + case 42: + message = ( "admin pls ban " + killer.name ); + break; + + case 43: + message = ( "WTF IS WITH THESE SPAWNS??" ); + break; + + case 44: + message = ( "im getting owned lol..." ); + break; + + case 45: + message = ( "someone kill " + killer.name + ", they are on a streak of " + killer.cur_kill_streak + "!" ); + break; + + case 46: + message = ( "man i died" ); + break; + + case 47: + message = ( "nice noob gun " + killer.name ); + break; + + case 48: + message = ( "stop camping " + killer.name + "!" ); + break; + + case 49: + message = ( "k THERE IS NOTHING I CAN DO ABOUT DYING!!" ); + break; + + case 50: + message = ( "aw" ); + break; + + case 51: + message = ( "lol " + getMapName( getdvar( "mapname" ) ) + " sux" ); + break; + + case 52: + message = ( "why are we even playing on " + getMapName( getdvar( "mapname" ) ) + "?" ); + break; + + case 53: + message = ( getMapName( getdvar( "mapname" ) ) + " is such an unfair map!!" ); + break; + + case 54: + message = ( "what were they thinking when making " + getMapName( getdvar( "mapname" ) ) + "?!" ); + break; + + case 55: + message = ( killer.name + " totally just destroyed me!" ); + break; + + case 56: + message = ( "can i be admen plz? so i can ban " + killer.name ); + break; + + case 57: + message = ( "wow " + killer.name + " is such a no life!!" ); + break; + + case 58: + message = ( "man i got rekt by " + killer.name ); + break; + + case 59: + message = ( "admen pls ben " + killer.name ); + break; + + case 60: + message = "Wow! Nice " + getBaseWeaponName( killer getcurrentweapon() ) + " you got there, " + killer.name + "!"; + + break; + + case 61: + message = ( "you are so banned " + killer.name ); + break; + + case 62: + message = ( "recorded reported and deported! " + killer.name ); + break; + + case 63: + message = ( "hack name " + killer.name + "?" ); + break; + + case 64: + message = ( "dude can you send me that hack " + killer.name + "?" ); + break; + + case 65: + message = ( "nice aimbot " + killer.name + "!!1" ); + break; + + case 66: + message = ( "you are benned " + killer.name + "!!" ); + break; + + case 67: + message = ( "that was topkek " + killer.name ); + break; + } + + wait ( randomint( 3 ) + 1 ); + self BotDoChat( 8, message ); +} + +/* + Revive +*/ +bot_chat_revive_watch( state, revive, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "go": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 10, "i am going to revive " + revive.name ); + break; + } + + break; + + case "start": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 10, "i am reviving " + revive.name ); + break; + } + + break; + + case "stop": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 10, "i revived " + revive.name ); + break; + } + + break; + } +} + +/* + Killcam +*/ +bot_chat_killcam_watch( state, b, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "start": + switch ( randomint( 2 ) ) + { + case 0: + self BotDoChat( 1, "WTF?!?!?!! Dude youre a hacker and a half!!" ); + break; + + case 1: + self BotDoChat( 1, "Haa! Got my fraps ready, time to watch this killcam." ); + break; + } + + break; + + case "stop": + switch ( randomint( 2 ) ) + { + case 0: + self BotDoChat( 1, "Wow... Im reporting you!!!" ); + break; + + case 1: + self BotDoChat( 1, "Got it on fraps!" ); + break; + } + + break; + } +} + +/* + Stuck +*/ +bot_chat_stuck_watch( a, b, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + sayLength = randomintrange( 5, 30 ); + msg = ""; + + for ( i = 0; i < sayLength; i++ ) + { + switch ( randomint( 9 ) ) + { + case 0: + msg = msg + "w"; + break; + + case 1: + msg = msg + "s"; + break; + + case 2: + msg = msg + "d"; + break; + + case 3: + msg = msg + "a"; + break; + + case 4: + msg = msg + " "; + break; + + case 5: + msg = msg + "W"; + break; + + case 6: + msg = msg + "S"; + break; + + case 7: + msg = msg + "D"; + break; + + case 8: + msg = msg + "A"; + break; + } + } + + self BotDoChat( 20, msg ); +} + +/* + Tube +*/ +bot_chat_tube_watch( state, tubeWp, tubeWeap, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "go": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 10, "i am going to go tube" ); + break; + } + + break; + + case "start": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 10, "i tubed" ); + break; + } + + break; + } +} + +/* + bot_chat_killstreak_watch( streakName, b, c, d, e, f, g ) +*/ +bot_chat_killstreak_watch( state, location, directionYaw, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "call": + if ( self.pers[ "hardPointItem" ] == "dogs_mp" ) + { + self BotDoChat( 20, "wewt! i got the dogs!!" ); + } + + break; + } +} + +/* + bot_chat_attack_vehicle_watch( a, b, c, d, e, f, g ) +*/ +bot_chat_attack_vehicle_watch( state, vehicle, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } +} + +/* + bot_chat_follow_threat_watch( a, b, c, d, e, f, g ) +*/ +bot_chat_follow_threat_watch( state, threat, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } +} + +/* + bot_chat_camp_watch( a, b, c, d, e, f, g ) +*/ +bot_chat_camp_watch( state, wp, time, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "go": + switch ( randomint( 3 ) ) + { + case 0: + self BotDoChat( 10, "going to camp for " + time + " seconds" ); + break; + + case 1: + self BotDoChat( 10, "time to go camp!" ); + break; + + case 2: + self BotDoChat( 10, "rofl im going to camp" ); + break; + } + + break; + + case "start": + switch ( randomint( 3 ) ) + { + case 0: + self BotDoChat( 10, "well im camping... this is fun!" ); + break; + + case 1: + self BotDoChat( 10, "lol im camping, hope i kill someone" ); + break; + + case 2: + self BotDoChat( 10, "im camping! i guess ill wait " + time + " before moving again" ); + break; + } + + break; + + case "stop": + switch ( randomint( 3 ) ) + { + case 0: + self BotDoChat( 10, "finished camping.." ); + break; + + case 1: + self BotDoChat( 10, "wow that was a load of camping!" ); + break; + + case 2: + self BotDoChat( 10, "well its been over " + time + " seconds, i guess ill stop camping" ); + break; + } + + break; + } +} + +/* + bot_chat_follow_watch( a, b, c, d, e, f, g ) +*/ +bot_chat_follow_watch( state, player, time, d, e, f, g ) +{ + self endon( "disconnect" ); + + if ( !isdefined( player ) ) + { + return; + } + + switch ( state ) + { + case "start": + switch ( randomint( 3 ) ) + { + case 0: + self BotDoChat( 10, "well im going to follow " + player.name + " for " + time + " seconds" ); + break; + + case 1: + self BotDoChat( 10, "Lets go together " + player.name + " <3 :)" ); + break; + + case 2: + self BotDoChat( 10, "lets be butt buddies " + player.name + " and ill follow you!" ); + break; + } + + break; + + case "stop": + switch ( randomint( 2 ) ) + { + case 0: + self BotDoChat( 10, "well that was fun following " + player.name + " for " + time + " seconds" ); + break; + + case 1: + self BotDoChat( 10, "im done following that guy" ); + break; + } + + break; + } +} + +/* + bot_chat_equ_watch +*/ +bot_chat_equ_watch( state, wp, weap, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "go": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 10, "going to place a " + getBaseWeaponName( weap ) ); + break; + } + + break; + + case "start": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 10, "placed a " + getBaseWeaponName( weap ) ); + break; + } + + break; + } +} + +/* + bot_chat_nade_watch +*/ +bot_chat_nade_watch( state, wp, weap, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "go": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 10, "going to throw a " + getBaseWeaponName( weap ) ); + break; + } + + break; + + case "start": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 10, "threw a " + getBaseWeaponName( weap ) ); + break; + } + + break; + } +} + +/* + bot_chat_throwback_watch +*/ +bot_chat_throwback_watch( state, nade, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "start": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 10, "i am going to throw back the grenade!" ); + break; + } + + break; + + case "stop": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 10, "i threw back the grenade!" ); + break; + } + + break; + } +} + +/* + bot_chat_tbag_watch +*/ +bot_chat_tbag_watch( state, who, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "go": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 50, "Im going to go tBag XD" ); + break; + } + + break; + + case "start": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 50, "Im going to tBag XD" ); + break; + } + + break; + + case "stop": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 50, "Awwww yea... How do you like that? XD" ); + break; + } + + break; + } +} + +/* + bot_chat_rage_watch +*/ +bot_chat_rage_watch( state, b, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "start": + switch ( randomint( 5 ) ) + { + case 0: + self BotDoChat( 80, "K this is not going as I planned." ); + break; + + case 1: + self BotDoChat( 80, "Screw this! I'm out." ); + break; + + case 2: + self BotDoChat( 80, "Have fun being owned." ); + break; + + case 3: + self BotDoChat( 80, "MY TEAM IS GARBAGE!" ); + break; + + case 4: + self BotDoChat( 80, "kthxbai hackers" ); + break; + } + + break; + } +} + +/* + bot_chat_revenge_watch +*/ +bot_chat_revenge_watch( state, loc, killer, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "start": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 10, "Im going to check out my death location." ); + break; + } + + break; + + case "stop": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 10, "i checked out my deathlocation..." ); + break; + } + + break; + } +} + +/* + bot_chat_heard_target_watch +*/ +bot_chat_heard_target_watch( state, heard, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "start": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 5, "I think I hear " + heard.name + "..." ); + break; + } + + break; + + case "stop": + switch ( randomint( 1 ) ) + { + case 0: + self BotDoChat( 5, "Well i checked out " + heard.name + "'s location..." ); + break; + } + + break; + } +} + +/* + bot_chat_uav_target_watch +*/ +bot_chat_uav_target_watch( state, heard, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } +} + +/* + bot_chat_attack_equ_watch +*/ +bot_chat_attack_equ_watch( state, equ, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } +} + +/* + bot_chat_dom_watch +*/ +bot_chat_dom_watch( state, sub_state, flag, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( sub_state ) + { + case "spawnkill": + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } + + break; + + case "defend": + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } + + break; + + case "cap": + switch ( state ) + { + case "go": + break; + + case "start": + break; + + case "stop": + break; + } + + break; + } +} + +/* + bot_chat_hq_watch +*/ +bot_chat_hq_watch( state, sub_state, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( sub_state ) + { + case "cap": + switch ( state ) + { + case "go": + break; + + case "start": + break; + + case "stop": + break; + } + + break; + + case "defend": + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } + + break; + } +} + +/* + bot_chat_sab_watch +*/ +bot_chat_sab_watch( state, sub_state, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( sub_state ) + { + case "bomb": + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } + + break; + + case "defuser": + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } + + break; + + case "planter": + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } + + break; + + case "plant": + switch ( state ) + { + case "go": + break; + + case "start": + break; + + case "stop": + break; + } + + break; + + case "defuse": + switch ( state ) + { + case "go": + break; + + case "start": + break; + + case "stop": + break; + } + + break; + } +} + +/* + bot_chat_sd_watch +*/ +bot_chat_sd_watch( state, sub_state, obj, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( sub_state ) + { + case "bomb": + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } + + break; + + case "defuser": + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } + + break; + + case "planter": + site = obj; + + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } + + break; + + case "plant": + site = obj; + + switch ( state ) + { + case "go": + break; + + case "start": + break; + + case "stop": + break; + } + + break; + + case "defuse": + switch ( state ) + { + case "go": + break; + + case "start": + break; + + case "stop": + break; + } + + break; + } +} + +/* + bot_chat_cap_watch +*/ +bot_chat_cap_watch( state, sub_state, obj, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( sub_state ) + { + case "their_flag": + flag = obj; + + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } + + break; + + case "my_flag": + flag = obj; + + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } + + break; + + case "cap": + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } + + break; + } +} + +/* + bot_chat_twar_watch +*/ +bot_chat_twar_watch( state, sub_state, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( sub_state ) + { + case "cap": + switch ( state ) + { + case "go": + break; + + case "start": + break; + + case "stop": + break; + } + + break; + } +} + +/* + bot_chat_attack_dog_watch +*/ +bot_chat_attack_dog_watch( state, dog, c, d, e, f, g ) +{ + self endon( "disconnect" ); + + switch ( state ) + { + case "start": + break; + + case "stop": + break; + } +} diff --git a/maps/mp/bots/_menu.gsc b/maps/mp/bots/_menu.gsc new file mode 100644 index 0000000..5c39cdc --- /dev/null +++ b/maps/mp/bots/_menu.gsc @@ -0,0 +1,1408 @@ +/* + _menu + Author: INeedGames + Date: 08/16/2026 + The ingame menu. +*/ + +#include maps\mp\_utility; +#include maps\mp\bots\_bot_utility; + + +secondaryoffhandbuttonpressed() +{ + return getcvarint( "smoke" ); +} + +fragbuttonpressed() +{ + return getcvarint( "frag" ); +} + +adsbuttonpressed() +{ + return getcvarint( "speed" ) || self playerads() > 0.05; +} + +setparent( parent ) +{ +} + +setpoint(a, b, x, y) +{ +} + +createfontstring(a, b) +{ +} + +destroyelem() +{ +} + + +init() +{ + if ( getcvar( "bots_main_menu" ) == "" ) + { + setcvar( "bots_main_menu", true ); + } + + if ( !getcvarint( "bots_main_menu" ) ) + { + return; + } + + thread watchPlayers(); +} + +watchPlayers() +{ + for ( ;; ) + { + wait 1; + + if ( !getcvarint( "bots_main_menu" ) ) + { + return; + } + + for ( i = level.players.size - 1; i >= 0; i-- ) + { + player = level.players[ i ]; + + if ( !player is_host() ) + { + continue; + } + + if ( isdefined( player.menuinit ) && player.menuinit ) + { + continue; + } + + player thread init_menu(); + } + } +} + +init_menu() +{ + self.menuinit = true; + + self.menuopen = false; + self.submenu = "Main"; + self.curs[ "Main" ][ "X" ] = 0; + self AddOptions(); + + self thread watchPlayerOpenMenu(); + self thread MenuSelect(); + self thread RightMenu(); + self thread LeftMenu(); + + self thread watchDisconnect(); + + self thread doGreetings(); +} + +destroyFixed() +{ + if ( !isdefined( self ) ) + { + return; + } + + self destroy(); +} + +removeChildFixed( element ) +{ + temp = []; + + for ( i = 0; i < self.children.size ; i++ ) + { + if ( isdefined( self.children[ i ] ) && self.children[ i ] != element ) + { + self.children[ i ].index = temp.size; + temp[ temp.size ] = self.children[ i ]; + } + } + + self.children = temp; +} + +destroyElemFixed() +{ + if ( !isdefined( self ) ) + { + return; + } + + if ( isdefined( self.parent ) ) + { + self.parent removeChildFixed( self ); + } + + self destroyelem(); +} + +kill_menu() +{ + self notify( "bots_kill_menu" ); + self.menuinit = undefined; +} + +watchDisconnect() +{ + self waittill_either( "disconnect", "bots_kill_menu" ); + + if ( self.menuopen ) + { + if ( isdefined( self.menutexty ) ) + { + for ( i = 0; i < self.menutexty.size; i++ ) + { + if ( isdefined( self.menutexty[ i ] ) ) + { + self.menutexty[ i ] destroyElemFixed(); + } + } + } + + if ( isdefined( self.menutext ) ) + { + for ( i = 0; i < self.menutext.size; i++ ) + { + if ( isdefined( self.menutext[ i ] ) ) + { + self.menutext[ i ] destroyElemFixed(); + } + } + } + + if ( isdefined( self.menu ) && isdefined( self.menu[ "X" ] ) ) + { + if ( isdefined( self.menu[ "X" ][ "Shader" ] ) ) + { + self.menu[ "X" ][ "Shader" ] destroyElemFixed(); + } + + if ( isdefined( self.menu[ "X" ][ "Scroller" ] ) ) + { + self.menu[ "X" ][ "Scroller" ] destroyElemFixed(); + } + } + + if ( isdefined( self.menuversionhud ) ) + { + self.menuversionhud destroyFixed(); + } + } +} + +doGreetings() +{ + self endon ( "disconnect" ); + self endon ( "bots_kill_menu" ); + wait 1; + self iprintln( "Welcome to Bot Warfare " + self.name + "!" ); + wait 5; + self iprintln( "Press [{+frag}] + [{+smoke}] to open menu!" ); +} + +watchPlayerOpenMenu() +{ + self endon ( "disconnect" ); + self endon ( "bots_kill_menu" ); + + for ( ;; ) + { + while ( !self fragbuttonpressed() || !self secondaryoffhandbuttonpressed() ) + { + wait 0.05; + } + + if ( !self.menuopen ) + { + self playlocalsound( "mouse_click" ); + self thread OpenSub( self.submenu ); + } + else + { + self playlocalsound( "mouse_click" ); + + if ( self.submenu != "Main" ) + { + self ExitSub(); + } + else + { + self ExitMenu(); + + if ( level.inprematchperiod || level.gameended ) + { + self freezecontrols( true ); + } + else + { + self freezecontrols( false ); + } + } + } + + while ( self fragbuttonpressed() && self secondaryoffhandbuttonpressed() ) + { + wait 0.05; + } + } +} + +MenuSelect() +{ + self endon ( "disconnect" ); + self endon ( "bots_kill_menu" ); + + for ( ;; ) + { + while ( !self meleebuttonpressed() ) + { + wait 0.05; + } + + if ( self.menuopen ) + { + self playlocalsound( "mouse_click" ); + + if ( self.submenu == "Main" ) + { + self thread [[ self.option[ "Function" ][ self.submenu ][ self.curs[ "Main" ][ "X" ] ] ]]( self.option[ "Arg1" ][ self.submenu ][ self.curs[ "Main" ][ "X" ] ], self.option[ "Arg2" ][ self.submenu ][ self.curs[ "Main" ][ "X" ] ] ); + } + else + { + self thread [[ self.option[ "Function" ][ self.submenu ][ self.curs[ self.submenu ][ "Y" ] ] ]]( self.option[ "Arg1" ][ self.submenu ][ self.curs[ self.submenu ][ "Y" ] ], self.option[ "Arg2" ][ self.submenu ][ self.curs[ self.submenu ][ "Y" ] ] ); + } + } + + while ( self meleebuttonpressed() ) + { + wait 0.05; + } + } +} + +LeftMenu() +{ + self endon ( "disconnect" ); + self endon ( "bots_kill_menu" ); + + for ( ;; ) + { + while ( !self attackbuttonpressed() ) + { + wait 0.05; + } + + if ( self.menuopen ) + { + self playlocalsound( "mouse_over" ); + + if ( self.submenu == "Main" ) + { + self.curs[ "Main" ][ "X" ]--; + + if ( self.curs[ "Main" ][ "X" ] < 0 ) + { + self.curs[ "Main" ][ "X" ] = self.option[ "Name" ][ self.submenu ].size - 1; + } + + self CursMove( "X" ); + } + else + { + self.curs[ self.submenu ][ "Y" ]--; + + if ( self.curs[ self.submenu ][ "Y" ] < 0 ) + { + self.curs[ self.submenu ][ "Y" ] = self.option[ "Name" ][ self.submenu ].size - 1; + } + + self CursMove( "Y" ); + } + } + + while ( self attackbuttonpressed() ) + { + wait 0.05; + } + } +} + +RightMenu() +{ + self endon ( "disconnect" ); + self endon ( "bots_kill_menu" ); + + for ( ;; ) + { + while ( !self adsbuttonpressed() ) + { + wait 0.05; + } + + if ( self.menuopen ) + { + self playlocalsound( "mouse_over" ); + + if ( self.submenu == "Main" ) + { + self.curs[ "Main" ][ "X" ]++; + + if ( self.curs[ "Main" ][ "X" ] > self.option[ "Name" ][ self.submenu ].size - 1 ) + { + self.curs[ "Main" ][ "X" ] = 0; + } + + self CursMove( "X" ); + } + else + { + self.curs[ self.submenu ][ "Y" ]++; + + if ( self.curs[ self.submenu ][ "Y" ] > self.option[ "Name" ][ self.submenu ].size - 1 ) + { + self.curs[ self.submenu ][ "Y" ] = 0; + } + + self CursMove( "Y" ); + } + } + + while ( self adsbuttonpressed() ) + { + wait 0.05; + } + } +} + +OpenSub( menu, menu2 ) +{ + if ( menu != "Main" && ( !isdefined( self.menu[ menu ] ) || !!isdefined( self.menu[ menu ][ "FirstOpen" ] ) ) ) + { + self.curs[ menu ][ "Y" ] = 0; + self.menu[ menu ][ "FirstOpen" ] = true; + } + + logOldi = true; + self.submenu = menu; + + if ( self.submenu == "Main" ) + { + if ( isdefined( self.menutext ) ) + { + for ( i = 0; i < self.menutext.size; i++ ) + { + if ( isdefined( self.menutext[ i ] ) ) + { + self.menutext[ i ] destroyElemFixed(); + } + } + } + + if ( isdefined( self.menu ) && isdefined( self.menu[ "X" ] ) ) + { + if ( isdefined( self.menu[ "X" ][ "Shader" ] ) ) + { + self.menu[ "X" ][ "Shader" ] destroyElemFixed(); + } + + if ( isdefined( self.menu[ "X" ][ "Scroller" ] ) ) + { + self.menu[ "X" ][ "Scroller" ] destroyElemFixed(); + } + } + + if ( isdefined( self.menuversionhud ) ) + { + self.menuversionhud destroyFixed(); + } + + for ( i = 0 ; i < self.option[ "Name" ][ self.submenu ].size ; i++ ) + { + self.menutext[ i ] = self createfontstring( "default", 1.6 ); + self.menutext[ i ] setpoint( "CENTER", "CENTER", -300 + ( i * 100 ), -226 ); + self.menutext[ i ] settext( self.option[ "Name" ][ self.submenu ][ i ] ); + + if ( logOldi ) + { + self.oldi = i; + } + + if ( self.menutext[ i ].x > 300 ) + { + logOldi = false; + x = i - self.oldi; + self.menutext[ i ] setpoint( "CENTER", "CENTER", ( ( ( -300 ) - ( i * 100 ) ) + ( i * 100 ) ) + ( x * 100 ), -196 ); + } + + self.menutext[ i ].alpha = 1; + self.menutext[ i ].sort = 999; + } + + if ( !logOldi ) + { + self.menu[ "X" ][ "Shader" ] = self createRectangle( "CENTER", "CENTER", 0, -225, 1000, 90, ( 0, 0, 0 ), -2, 1, "white" ); + } + else + { + self.menu[ "X" ][ "Shader" ] = self createRectangle( "CENTER", "CENTER", 0, -225, 1000, 30, ( 0, 0, 0 ), -2, 1, "white" ); + } + + self.menu[ "X" ][ "Scroller" ] = self createRectangle( "CENTER", "CENTER", self.menutext[ self.curs[ "Main" ][ "X" ] ].x, -225, 105, 22, ( 1, 0, 0 ), -1, 1, "white" ); + + self CursMove( "X" ); + + self.menuversionhud = initHudElem( "Bot Warfare " + level.bw_version, 0, 0 ); + + self.menuopen = true; + } + else + { + if ( isdefined( self.menutexty ) ) + { + for ( i = 0 ; i < self.menutexty.size ; i++ ) + { + if ( isdefined( self.menutexty[ i ] ) ) + { + self.menutexty[ i ] destroyElemFixed(); + } + } + } + + for ( i = 0 ; i < self.option[ "Name" ][ self.submenu ].size ; i++ ) + { + self.menutexty[ i ] = self createfontstring( "default", 1.6 ); + self.menutexty[ i ] setpoint( "CENTER", "CENTER", self.menutext[ self.curs[ "Main" ][ "X" ] ].x, -160 + ( i * 20 ) ); + self.menutexty[ i ] settext( self.option[ "Name" ][ self.submenu ][ i ] ); + self.menutexty[ i ].alpha = 1; + self.menutexty[ i ].sort = 999; + } + + self CursMove( "Y" ); + } +} + +CursMove( direction ) +{ + self notify( "scrolled" ); + + if ( self.submenu == "Main" ) + { + if ( isdefined( self.menutext ) ) + { + self.menu[ "X" ][ "Scroller" ].x = self.menutext[ self.curs[ "Main" ][ "X" ] ].x; + self.menu[ "X" ][ "Scroller" ].y = self.menutext[ self.curs[ "Main" ][ "X" ] ].y; + + for ( i = 0; i < self.menutext.size; i++ ) + { + if ( isdefined( self.menutext[ i ] ) ) + { + self.menutext[ i ].fontscale = 1.5; + self.menutext[ i ].color = ( 1, 1, 1 ); + self.menutext[ i ].glowalpha = 0; + } + } + } + + self thread ShowOptionOn( direction ); + } + else + { + if ( isdefined( self.menutexty ) ) + { + for ( i = 0; i < self.menutexty.size; i++ ) + { + if ( isdefined( self.menutexty[ i ] ) ) + { + self.menutexty[ i ].fontscale = 1.5; + self.menutexty[ i ].color = ( 1, 1, 1 ); + self.menutexty[ i ].glowalpha = 0; + } + } + } + + if ( isdefined( self.menutext ) ) + { + for ( i = 0; i < self.menutext.size; i++ ) + { + if ( isdefined( self.menutext[ i ] ) ) + { + self.menutext[ i ].fontscale = 1.5; + self.menutext[ i ].color = ( 1, 1, 1 ); + self.menutext[ i ].glowalpha = 0; + } + } + } + + self thread ShowOptionOn( direction ); + } +} + +ShowOptionOn( variable ) +{ + self endon( "scrolled" ); + self endon( "disconnect" ); + self endon( "exit" ); + self endon( "bots_kill_menu" ); + + for ( time = 0;; time += 0.05 ) + { + if ( !self isonground() && isalive( self ) && !level.inprematchperiod && !level.gameended ) + { + self freezecontrols( false ); + } + else + { + self freezecontrols( true ); + } + + self setclientcvar( "r_blur", "5" ); + self setclientcvar( "sc_blur", "4" ); + self AddOptions(); + + if ( self.submenu == "Main" ) + { + if ( isdefined( self.curs[ self.submenu ][ variable ] ) && isdefined( self.menutext ) && isdefined( self.menutext[ self.curs[ self.submenu ][ variable ] ] ) ) + { + self.menutext[ self.curs[ self.submenu ][ variable ] ].fontscale = 2.0; + // self.menutext[ self.curs[ self.submenu ][ variable ] ].color = (randomint(256)/255, randomint(256)/255, randomint(256)/255); + color = ( 6 / 255, 69 / 255, 173 + randomintrange( -5, 5 ) / 255 ); + + if ( int( time * 4 ) % 2 ) + { + color = ( 11 / 255, 0 / 255, 128 + randomintrange( -10, 10 ) / 255 ); + } + + self.menutext[ self.curs[ self.submenu ][ variable ] ].color = color; + } + + if ( isdefined( self.menutext ) ) + { + for ( i = 0; i < self.option[ "Name" ][ self.submenu ].size; i++ ) + { + if ( isdefined( self.menutext[ i ] ) ) + { + self.menutext[ i ] settext( self.option[ "Name" ][ self.submenu ][ i ] ); + } + } + } + } + else + { + if ( isdefined( self.curs[ self.submenu ][ variable ] ) && isdefined( self.menutexty ) && isdefined( self.menutexty[ self.curs[ self.submenu ][ variable ] ] ) ) + { + self.menutexty[ self.curs[ self.submenu ][ variable ] ].fontscale = 2.0; + // self.menutexty[ self.curs[ self.submenu ][ variable ] ].color = (randomint(256)/255, randomint(256)/255, randomint(256)/255); + color = ( 6 / 255, 69 / 255, 173 + randomintrange( -5, 5 ) / 255 ); + + if ( int( time * 4 ) % 2 ) + { + color = ( 11 / 255, 0 / 255, 128 + randomintrange( -10, 10 ) / 255 ); + } + + self.menutexty[ self.curs[ self.submenu ][ variable ] ].color = color; + } + + if ( isdefined( self.menutexty ) ) + { + for ( i = 0; i < self.option[ "Name" ][ self.submenu ].size; i++ ) + { + if ( isdefined( self.menutexty[ i ] ) ) + { + self.menutexty[ i ] settext( self.option[ "Name" ][ self.submenu ][ i ] ); + } + } + } + } + + wait 0.05; + } +} + +AddMenu( menu, num, text, function, arg1, arg2 ) +{ + self.option[ "Name" ][ menu ][ num ] = text; + self.option[ "Function" ][ menu ][ num ] = function; + self.option[ "Arg1" ][ menu ][ num ] = arg1; + self.option[ "Arg2" ][ menu ][ num ] = arg2; +} + +AddBack( menu, back ) +{ + self.menu[ "Back" ][ menu ] = back; +} + +ExitSub() +{ + if ( isdefined( self.menutexty ) ) + { + for ( i = 0; i < self.menutexty.size; i++ ) + { + if ( isdefined( self.menutexty[ i ] ) ) + { + self.menutexty[ i ] destroyElemFixed(); + } + } + } + + self.submenu = self.menu[ "Back" ][ self.submenu ]; + + if ( self.submenu == "Main" ) + { + self CursMove( "X" ); + } + else + { + self CursMove( "Y" ); + } +} + +ExitMenu() +{ + if ( isdefined( self.menutext ) ) + { + for ( i = 0; i < self.menutext.size; i++ ) + { + if ( isdefined( self.menutext[ i ] ) ) + { + self.menutext[ i ] destroyElemFixed(); + } + } + } + + if ( isdefined( self.menu ) && isdefined( self.menu[ "X" ] ) ) + { + if ( isdefined( self.menu[ "X" ][ "Shader" ] ) ) + { + self.menu[ "X" ][ "Shader" ] destroyElemFixed(); + } + + if ( isdefined( self.menu[ "X" ][ "Scroller" ] ) ) + { + self.menu[ "X" ][ "Scroller" ] destroyElemFixed(); + } + } + + if ( isdefined( self.menuversionhud ) ) + { + self.menuversionhud destroyFixed(); + } + + self.menuopen = false; + self notify( "exit" ); + + self setclientcvar( "r_blur", "0" ); + self setclientcvar( "sc_blur", "2" ); +} + +initHudElem( txt, xl, yl ) +{ + hud = newclienthudelem( self ); + hud settext( txt ); + hud.alignx = "center"; + hud.aligny = "bottom"; + hud.horzalign = "center"; + hud.vertalign = "bottom"; + hud.x = xl; + hud.y = yl; + hud.foreground = true; + hud.fontscale = 1.4; + hud.font = "objective"; + hud.alpha = 1; + hud.glow = 0; + hud.glowcolor = ( 0, 0, 0 ); + hud.glowalpha = 1; + hud.color = ( 1.0, 1.0, 1.0 ); + + return hud; +} + +createRectangle( align, relative, x, y, width, height, color, sort, alpha, shader ) +{ + barElemBG = newclienthudelem( self ); + barElemBG.elemtype = "bar_"; + barElemBG.width = width; + barElemBG.height = height; + barElemBG.align = align; + barElemBG.relative = relative; + barElemBG.xoffset = 0; + barElemBG.yoffset = 0; + barElemBG.children = []; + barElemBG.sort = sort; + barElemBG.color = color; + barElemBG.alpha = alpha; + barElemBG setparent( level.uiparent ); + barElemBG setshader( shader, width, height ); + barElemBG.hidden = false; + barElemBG setpoint( align, relative, x, y ); + return barElemBG; +} + +AddOptions() +{ + self AddMenu( "Main", 0, "Manage bots", ::OpenSub, "man_bots", "" ); + self AddBack( "man_bots", "Main" ); + + _temp = ""; + _tempcvar = getcvarint( "bots_manage_add" ); + self AddMenu( "man_bots", 0, "Add 1 bot", ::man_bots, "add", 1 + _tempcvar ); + self AddMenu( "man_bots", 1, "Add 3 bot", ::man_bots, "add", 3 + _tempcvar ); + self AddMenu( "man_bots", 2, "Add 7 bot", ::man_bots, "add", 7 + _tempcvar ); + self AddMenu( "man_bots", 3, "Add 11 bot", ::man_bots, "add", 11 + _tempcvar ); + self AddMenu( "man_bots", 4, "Add 17 bot", ::man_bots, "add", 17 + _tempcvar ); + self AddMenu( "man_bots", 5, "Kick a bot", ::man_bots, "kick", 1 ); + self AddMenu( "man_bots", 6, "Kick all bots", ::man_bots, "kick", getBotArray().size ); + + _tempcvar = getcvarint( "bots_manage_fill_kick" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "man_bots", 7, "Toggle auto bot kicking: " + _temp, ::man_bots, "autokick", _tempcvar ); + + _tempcvar = getcvarint( "bots_manage_fill_mode" ); + + switch ( _tempcvar ) + { + case 0: + _temp = "everyone"; + break; + + case 1: + _temp = "just bots"; + break; + + case 2: + _temp = "everyone, adjust to map"; + break; + + case 3: + _temp = "just bots, adjust to map"; + break; + + case 4: + _temp = "bots used as team balance"; + break; + + case 5: + _temp = "bots used as team balance, adjust to map"; + break; + + default: + _temp = "out of range"; + break; + } + + self AddMenu( "man_bots", 8, "Change bot_fill_mode: " + _temp, ::man_bots, "fillmode", _tempcvar ); + + _tempcvar = getcvarint( "bots_manage_fill" ); + self AddMenu( "man_bots", 9, "Increase bots to keep in-game: " + _tempcvar, ::man_bots, "fillup", _tempcvar ); + self AddMenu( "man_bots", 10, "Decrease bots to keep in-game: " + _tempcvar, ::man_bots, "filldown", _tempcvar ); + + _tempcvar = getcvarint( "bots_manage_fill_spec" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "man_bots", 11, "Count players for fill on spectator: " + _temp, ::man_bots, "fillspec", _tempcvar ); + + // + + self AddMenu( "Main", 1, "Teams and difficulty", ::OpenSub, "man_team", "" ); + self AddBack( "man_team", "Main" ); + + _tempcvar = getcvar( "bots_team" ); + self AddMenu( "man_team", 0, "Change bot team: " + _tempcvar, ::bot_teams, "team", _tempcvar ); + + _tempcvar = getcvarint( "bots_team_amount" ); + self AddMenu( "man_team", 1, "Increase bots to be on axis team: " + _tempcvar, ::bot_teams, "teamup", _tempcvar ); + self AddMenu( "man_team", 2, "Decrease bots to be on axis team: " + _tempcvar, ::bot_teams, "teamdown", _tempcvar ); + + _tempcvar = getcvarint( "bots_team_force" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "man_team", 3, "Toggle forcing bots on team: " + _temp, ::bot_teams, "teamforce", _tempcvar ); + + _tempcvar = getcvarint( "bots_team_mode" ); + + if ( _tempcvar ) + { + _temp = "only bots"; + } + else + { + _temp = "everyone"; + } + + self AddMenu( "man_team", 4, "Toggle bot_team_bot: " + _temp, ::bot_teams, "teammode", _tempcvar ); + + _tempcvar = getcvarint( "bots_skill" ); + + switch ( _tempcvar ) + { + case 0: + _temp = "random for all"; + break; + + case 1: + _temp = "too easy"; + break; + + case 2: + _temp = "easy"; + break; + + case 3: + _temp = "easy-medium"; + break; + + case 4: + _temp = "medium"; + break; + + case 5: + _temp = "hard"; + break; + + case 6: + _temp = "very hard"; + break; + + case 7: + _temp = "hardest"; + break; + + case 8: + _temp = "custom"; + break; + + case 9: + _temp = "complete random"; + break; + + default: + _temp = "out of range"; + break; + } + + self AddMenu( "man_team", 5, "Change bot difficulty: " + _temp, ::bot_teams, "skill", _tempcvar ); + + _tempcvar = getcvarint( "bots_skill_axis_hard" ); + self AddMenu( "man_team", 6, "Increase amount of hard bots on axis team: " + _tempcvar, ::bot_teams, "axishardup", _tempcvar ); + self AddMenu( "man_team", 7, "Decrease amount of hard bots on axis team: " + _tempcvar, ::bot_teams, "axisharddown", _tempcvar ); + + _tempcvar = getcvarint( "bots_skill_axis_med" ); + self AddMenu( "man_team", 8, "Increase amount of med bots on axis team: " + _tempcvar, ::bot_teams, "axismedup", _tempcvar ); + self AddMenu( "man_team", 9, "Decrease amount of med bots on axis team: " + _tempcvar, ::bot_teams, "axismeddown", _tempcvar ); + + _tempcvar = getcvarint( "bots_skill_allies_hard" ); + self AddMenu( "man_team", 10, "Increase amount of hard bots on allies team: " + _tempcvar, ::bot_teams, "allieshardup", _tempcvar ); + self AddMenu( "man_team", 11, "Decrease amount of hard bots on allies team: " + _tempcvar, ::bot_teams, "alliesharddown", _tempcvar ); + + _tempcvar = getcvarint( "bots_skill_allies_med" ); + self AddMenu( "man_team", 12, "Increase amount of med bots on allies team: " + _tempcvar, ::bot_teams, "alliesmedup", _tempcvar ); + self AddMenu( "man_team", 13, "Decrease amount of med bots on allies team: " + _tempcvar, ::bot_teams, "alliesmeddown", _tempcvar ); + + // + + self AddMenu( "Main", 2, "Bot settings", ::OpenSub, "set1", "" ); + self AddBack( "set1", "Main" ); + + _tempcvar = getcvarint( "bots_loadout_reasonable" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "set1", 0, "Bots use only good class setups: " + _temp, ::bot_func, "reasonable", _tempcvar ); + + _tempcvar = getcvarint( "bots_loadout_allow_op" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "set1", 1, "Bots can use op and annoying class setups: " + _temp, ::bot_func, "op", _tempcvar ); + + _tempcvar = getcvarint( "bots_play_move" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "set1", 2, "Bots can move: " + _temp, ::bot_func, "move", _tempcvar ); + + _tempcvar = getcvarint( "bots_play_knife" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "set1", 3, "Bots can knife: " + _temp, ::bot_func, "knife", _tempcvar ); + + _tempcvar = getcvarint( "bots_play_fire" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "set1", 4, "Bots can fire: " + _temp, ::bot_func, "fire", _tempcvar ); + + _tempcvar = getcvarint( "bots_play_nade" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "set1", 5, "Bots can nade: " + _temp, ::bot_func, "nade", _tempcvar ); + + _tempcvar = getcvarint( "bots_play_obj" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "set1", 6, "Bots play the objective: " + _temp, ::bot_func, "obj", _tempcvar ); + + _tempcvar = getcvarint( "bots_play_camp" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "set1", 7, "Bots can camp: " + _temp, ::bot_func, "camp", _tempcvar ); + + _tempcvar = getcvarint( "bots_play_jumpdrop" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "set1", 8, "Bots can jump and dropshot: " + _temp, ::bot_func, "jump", _tempcvar ); + + _tempcvar = getcvarint( "bots_play_target_other" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "set1", 9, "Bots can target other script objects: " + _temp, ::bot_func, "targetother", _tempcvar ); + + _tempcvar = getcvarint( "bots_play_killstreak" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "set1", 10, "Bots can use killstreaks: " + _temp, ::bot_func, "killstreak", _tempcvar ); + + _tempcvar = getcvarint( "bots_play_ads" ); + + if ( _tempcvar ) + { + _temp = "true"; + } + else + { + _temp = "false"; + } + + self AddMenu( "set1", 11, "Bots can ads: " + _temp, ::bot_func, "ads", _tempcvar ); +} + +bot_func( a, b ) +{ + switch ( a ) + { + case "reasonable": + setcvar( "bots_loadout_reasonable", !b ); + self iprintln( "Bots using reasonable setups: " + !b ); + break; + + case "op": + setcvar( "bots_loadout_allow_op", !b ); + self iprintln( "Bots using op setups: " + !b ); + break; + + case "move": + setcvar( "bots_play_move", !b ); + self iprintln( "Bots move: " + !b ); + break; + + case "knife": + setcvar( "bots_play_knife", !b ); + self iprintln( "Bots knife: " + !b ); + break; + + case "fire": + setcvar( "bots_play_fire", !b ); + self iprintln( "Bots fire: " + !b ); + break; + + case "nade": + setcvar( "bots_play_nade", !b ); + self iprintln( "Bots nade: " + !b ); + break; + + case "obj": + setcvar( "bots_play_obj", !b ); + self iprintln( "Bots play the obj: " + !b ); + break; + + case "camp": + setcvar( "bots_play_camp", !b ); + self iprintln( "Bots camp: " + !b ); + break; + + case "jump": + setcvar( "bots_play_jumpdrop", !b ); + self iprintln( "Bots jump: " + !b ); + break; + + case "targetother": + setcvar( "bots_play_target_other", !b ); + self iprintln( "Bots target other: " + !b ); + break; + + case "killstreak": + setcvar( "bots_play_killstreak", !b ); + self iprintln( "Bots use killstreaks: " + !b ); + break; + + case "ads": + setcvar( "bots_play_ads", !b ); + self iprintln( "Bots ads: " + !b ); + break; + } +} + +bot_teams( a, b ) +{ + switch ( a ) + { + case "team": + switch ( b ) + { + case "autoassign": + setcvar( "bots_team", "allies" ); + self iprintlnbold( "Changed bot team to allies." ); + break; + + case "allies": + setcvar( "bots_team", "axis" ); + self iprintlnbold( "Changed bot team to axis." ); + break; + + case "axis": + setcvar( "bots_team", "custom" ); + self iprintlnbold( "Changed bot team to custom." ); + break; + + default: + setcvar( "bots_team", "autoassign" ); + self iprintlnbold( "Changed bot team to autoassign." ); + break; + } + + break; + + case "teamup": + setcvar( "bots_team_amount", b + 1 ); + self iprintln( ( b + 1 ) + " bot(s) will try to be on axis team." ); + break; + + case "teamdown": + setcvar( "bots_team_amount", b - 1 ); + self iprintln( ( b - 1 ) + " bot(s) will try to be on axis team." ); + break; + + case "teamforce": + setcvar( "bots_team_force", !b ); + self iprintln( "Forcing bots to team: " + !b ); + break; + + case "teammode": + setcvar( "bots_team_mode", !b ); + self iprintln( "Only count bots on team: " + !b ); + break; + + case "skill": + switch ( b ) + { + case 0: + self iprintlnbold( "Changed bot skill to easy." ); + setcvar( "bots_skill", 1 ); + break; + + case 1: + self iprintlnbold( "Changed bot skill to easy-med." ); + setcvar( "bots_skill", 2 ); + break; + + case 2: + self iprintlnbold( "Changed bot skill to medium." ); + setcvar( "bots_skill", 3 ); + break; + + case 3: + self iprintlnbold( "Changed bot skill to med-hard." ); + setcvar( "bots_skill", 4 ); + break; + + case 4: + self iprintlnbold( "Changed bot skill to hard." ); + setcvar( "bots_skill", 5 ); + break; + + case 5: + self iprintlnbold( "Changed bot skill to very hard." ); + setcvar( "bots_skill", 6 ); + break; + + case 6: + self iprintlnbold( "Changed bot skill to hardest." ); + setcvar( "bots_skill", 7 ); + break; + + case 7: + self iprintlnbold( "Changed bot skill to custom. Base is easy." ); + setcvar( "bots_skill", 8 ); + break; + + case 8: + self iprintlnbold( "Changed bot skill to complete random. Takes effect at restart." ); + setcvar( "bots_skill", 9 ); + break; + + default: + self iprintlnbold( "Changed bot skill to random. Takes effect at restart." ); + setcvar( "bots_skill", 0 ); + break; + } + + break; + + case "axishardup": + setcvar( "bots_skill_axis_hard", ( b + 1 ) ); + self iprintln( ( ( b + 1 ) ) + " hard bots will be on axis team." ); + break; + + case "axisharddown": + setcvar( "bots_skill_axis_hard", ( b - 1 ) ); + self iprintln( ( ( b - 1 ) ) + " hard bots will be on axis team." ); + break; + + case "axismedup": + setcvar( "bots_skill_axis_med", ( b + 1 ) ); + self iprintln( ( ( b + 1 ) ) + " med bots will be on axis team." ); + break; + + case "axismeddown": + setcvar( "bots_skill_axis_med", ( b - 1 ) ); + self iprintln( ( ( b - 1 ) ) + " med bots will be on axis team." ); + break; + + case "allieshardup": + setcvar( "bots_skill_allies_hard", ( b + 1 ) ); + self iprintln( ( ( b + 1 ) ) + " hard bots will be on allies team." ); + break; + + case "alliesharddown": + setcvar( "bots_skill_allies_hard", ( b - 1 ) ); + self iprintln( ( ( b - 1 ) ) + " hard bots will be on allies team." ); + break; + + case "alliesmedup": + setcvar( "bots_skill_allies_med", ( b + 1 ) ); + self iprintln( ( ( b + 1 ) ) + " med bots will be on allies team." ); + break; + + case "alliesmeddown": + setcvar( "bots_skill_allies_med", ( b - 1 ) ); + self iprintln( ( ( b - 1 ) ) + " med bots will be on allies team." ); + break; + } +} + +man_bots( a, b ) +{ + switch ( a ) + { + case "add": + setcvar( "bots_manage_add", b ); + + if ( b == 1 ) + { + self iprintln( "Adding " + b + " bot." ); + } + else + { + self iprintln( "Adding " + b + " bots." ); + } + + break; + + case "kick": + result = false; + + for ( i = 0; i < b; i++ ) + { + tempBot = getBotToKick(); + + if ( isdefined( tempBot ) ) + { + kick( tempBot getentitynumber() ); + result = true; + } + + wait 0.25; + } + + if ( !result ) + { + self iprintln( "No bots to kick" ); + } + + break; + + case "autokick": + setcvar( "bots_manage_fill_kick", !b ); + self iprintln( "Kicking bots when bots_fill is exceeded: " + !b ); + break; + + case "fillmode": + switch ( b ) + { + case 0: + setcvar( "bots_manage_fill_mode", 1 ); + self iprintln( "bot_fill will now count only bots." ); + break; + + case 1: + setcvar( "bots_manage_fill_mode", 2 ); + self iprintln( "bot_fill will now count everyone, adjusting to map." ); + break; + + case 2: + setcvar( "bots_manage_fill_mode", 3 ); + self iprintln( "bot_fill will now count only bots, adjusting to map." ); + break; + + case 3: + setcvar( "bots_manage_fill_mode", 4 ); + self iprintln( "bot_fill will now use bots as team balance." ); + break; + + case 4: + setcvar( "bots_manage_fill_mode", 5 ); + self iprintln( "bot_fill will now use bots as team balance, adjusting to map." ); + break; + + default: + setcvar( "bots_manage_fill_mode", 0 ); + self iprintln( "bot_fill will now count everyone." ); + break; + } + + break; + + case "fillup": + setcvar( "bots_manage_fill", b + 1 ); + self iprintln( "Increased to maintain " + ( b + 1 ) + " bot(s)." ); + break; + + case "filldown": + setcvar( "bots_manage_fill", b - 1 ); + self iprintln( "Decreased to maintain " + ( b - 1 ) + " bot(s)." ); + break; + + case "fillspec": + setcvar( "bots_manage_fill_spec", !b ); + self iprintln( "Count players on spectator for bots_fill: " + !b ); + break; + } +} diff --git a/maps/mp/gametypes/_clientids.gsc b/maps/mp/gametypes/_clientids.gsc index e2ba3e0..eebacbb 100644 --- a/maps/mp/gametypes/_clientids.gsc +++ b/maps/mp/gametypes/_clientids.gsc @@ -5,9 +5,11 @@ init() level thread onPlayerConnect(); // bootstrap - level thread scripts\mp\bots_adapter_libcod::init(); + //level thread scripts\mp\bots_adapter_libcod::init(); level thread scripts\mp\bots_wp_editor::init(); level thread scripts\mp\bots::init(); + //level thread scripts\mp\bots_chat::init(); + level thread scripts\mp\bots_menu::init(); } onPlayerConnect() diff --git a/scripts/mp/bots_chat.gsc b/scripts/mp/bots_chat.gsc new file mode 100644 index 0000000..3a7cddf --- /dev/null +++ b/scripts/mp/bots_chat.gsc @@ -0,0 +1,4 @@ +init() +{ + level thread maps\mp\bots\_bot_chat::init(); +} diff --git a/scripts/mp/bots_menu.gsc b/scripts/mp/bots_menu.gsc new file mode 100644 index 0000000..0ae1805 --- /dev/null +++ b/scripts/mp/bots_menu.gsc @@ -0,0 +1,4 @@ +init() +{ + level thread maps\mp\bots\_menu::init(); +}