X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Fcommon%2Fminigames%2Fminigame%2Fpong.qc;h=4bcb8c51446ee77020731131ee95bc2e9bc7ef9e;hb=cf1edea8694548556934b5b05f526bc192f576cb;hp=5ba05f7ebe917d4405d1283c6ff7ce9cff25c6e3;hpb=a1b328c05f71d4a2f54f9d743dd46c70f5b5e7c8;p=xonotic%2Fxonotic-data.pk3dir.git diff --git a/qcsrc/common/minigames/minigame/pong.qc b/qcsrc/common/minigames/minigame/pong.qc index 5ba05f7eb..4bcb8c514 100644 --- a/qcsrc/common/minigames/minigame/pong.qc +++ b/qcsrc/common/minigames/minigame/pong.qc @@ -1,3 +1,5 @@ +REGISTER_MINIGAME(pong, "Pong"); + // minigame flags const int PONG_STATUS_WAIT = 0x0010; // waiting for players to join const int PONG_STATUS_PLAY = 0x0020; // playing @@ -8,20 +10,33 @@ const int PONG_SF_PLAYERSCORE = MINIG_SF_CUSTOM; // (pong_ball) sent when changing team const int PONG_SF_BALLTEAM = MINIG_SF_CUSTOM; +// keys +const int PONG_KEY_INCREASE = 0x01; // Move down/right +const int PONG_KEY_DECREASE = 0x02; // Move up/left +const int PONG_KEY_BOTH = 0x03; // Player jamming keys at ramdom + // fields const int PONG_MAX_PLAYERS = 4; -.int pong_score; // (minigame_player) number of goals +.int pong_score; // (minigame_player) number of goals +.int pong_keys; // (client) pressed keys .entity pong_paddles[PONG_MAX_PLAYERS];// (minigame) paddles -.float pong_length; // (pong_paddle) size (0,1) +.float pong_length; // (pong_paddle/pong_ball) size (0,1) +.entity pong_ai_paddle; // (pong_ai) controlled paddle entity #ifdef SVQC -float autocvar_sv_minigames_pong_paddlesize = 0.3; -float autocvar_sv_minigames_pong_paddlespeed= 1; -float autocvar_sv_minigames_pong_ballwait = 1; -float autocvar_sv_minigames_pong_ballspeed = 1; +float autocvar_sv_minigames_pong_paddle_size; +float autocvar_sv_minigames_pong_paddle_speed; + +float autocvar_sv_minigames_pong_ball_wait; +float autocvar_sv_minigames_pong_ball_speed; +float autocvar_sv_minigames_pong_ball_radius; +float autocvar_sv_minigames_pong_ball_number; -void pong_ball_think(); +float autocvar_sv_minigames_pong_ai_thinkspeed; +float autocvar_sv_minigames_pong_ai_tolerance; + +void pong_ball_think(entity this); // Throws a ball in a random direction and sets the think function void pong_ball_throw(entity ball) @@ -29,18 +44,17 @@ void pong_ball_throw(entity ball) float angle; do angle = random()*M_PI*2; - while ( (angle > 0.44*M_PI && angle < 0.55*M_PI) || - (angle > 1.44*M_PI && angle < 1.55*M_PI) ); - ball.velocity_x = cos(angle)*autocvar_sv_minigames_pong_ballspeed; - ball.velocity_y = sin(angle)*autocvar_sv_minigames_pong_ballspeed; - ball.think = pong_ball_think; + while ( fabs(sin(angle)) < 0.17 || fabs(cos(angle)) < 0.17 ); + ball.velocity_x = cos(angle)*autocvar_sv_minigames_pong_ball_speed; + ball.velocity_y = sin(angle)*autocvar_sv_minigames_pong_ball_speed; + setthink(ball, pong_ball_think); ball.nextthink = time; ball.team = 0; ball.SendFlags |= MINIG_SF_UPDATE|PONG_SF_BALLTEAM; } // Think equivalent of pong_ball_throw, used to delay throws -void pong_ball_throwthink() +void pong_ball_throwthink(entity this) { pong_ball_throw(self); } @@ -50,10 +64,11 @@ void pong_ball_reset(entity ball) { ball.velocity = '0 0 0'; ball.origin = '0.5 0.5 0'; - ball.SendFlags |= MINIG_SF_UPDATE; - ball.think = SUB_NullThink; + setthink(ball, SUB_NullThink); ball.team = 0; - ball.SendFlags |= PONG_SF_BALLTEAM; + ball.SendFlags |= MINIG_SF_UPDATE|PONG_SF_BALLTEAM; + setthink(ball, pong_ball_throwthink); + ball.nextthink = time + autocvar_sv_minigames_pong_ball_wait; } // Add the score to the given team in the minigame @@ -61,24 +76,55 @@ void pong_add_score(entity minigame, int team_thrower, int team_receiver, int de { if ( !minigame ) return; - + if ( team_thrower == 0 ) team_thrower = team_receiver; - + if ( team_thrower == team_receiver ) delta *= -1; - + entity paddle_thrower = minigame.pong_paddles[team_thrower-1]; - if ( paddle_thrower.realowner ) + if ( paddle_thrower.realowner.minigame_players ) { paddle_thrower.realowner.minigame_players.pong_score += delta; paddle_thrower.realowner.minigame_players.SendFlags |= PONG_SF_PLAYERSCORE; } } -bool pong_paddlemiss(float ball_coord, float pad_coord, float pad_len) +// get point in the box nearest to the given one (2D) +vector box_nearest(vector box_min, vector box_max, vector p) +{ + return eX * ( p_x > box_max_x ? box_max_x : ( p_x < box_min_x ? box_min_x : p_x ) ) + + eY * ( p_y > box_max_y ? box_max_y : ( p_y < box_min_y ? box_min_y : p_y ) ); +} + +void pong_paddle_bounce(entity ball, int pteam) +{ + switch(pteam) + { + case 1: ball.velocity_x = -fabs(ball.velocity_x); break; + case 2: ball.velocity_x = fabs(ball.velocity_x); break; + case 3: ball.velocity_y = fabs(ball.velocity_y); break; + case 4: ball.velocity_y = -fabs(ball.velocity_y); break; + } + + float angle = atan2(ball.velocity_y, ball.velocity_x); + angle += ( random() - 0.5 ) * 2 * M_PI/6; + float speed = vlen(ball.velocity); + + ball.velocity_y = speed * sin(angle); + ball.velocity_x = speed * cos(angle); +} + +// checks if the ball hit the paddle for the given team +bool pong_paddle_hit(entity ball, int pteam) { - return ball_coord < pad_coord - pad_len/2 || ball_coord > pad_coord + pad_len/2; + entity paddle = ball.owner.pong_paddles[pteam-1]; + if (!paddle) + return false; + vector near_point = box_nearest(paddle.mins+paddle.origin, + paddle.maxs+paddle.origin, ball.origin); + return vdist(near_point - ball.origin, <=, ball.pong_length); } // Checks for a goal, when that happes adds scores and resets the ball @@ -87,94 +133,169 @@ bool pong_goal(entity ball, int pteam) entity paddle = ball.owner.pong_paddles[pteam-1]; if (!paddle) return false; - - if ( (pteam > 2 && pong_paddlemiss(ball.origin_x,paddle.origin_x,paddle.pong_length)) || - pong_paddlemiss(ball.origin_y,paddle.origin_y,paddle.pong_length) ) + + if ( !pong_paddle_hit(ball, pteam) ) { pong_add_score(ball.owner ,ball.team, pteam, 1); pong_ball_reset(ball); - ball.think = pong_ball_throwthink; - ball.nextthink = time + autocvar_sv_minigames_pong_ballwait; return true; } - else - { - ball.team = pteam; - ball.SendFlags |= PONG_SF_BALLTEAM; - } - + return false; } // Moves the ball around -void pong_ball_think() +void pong_ball_think(entity this) { float think_speed = autocvar_sys_ticrate; - self.nextthink = time + think_speed; - - self.origin_x += self.velocity_x * think_speed; - self.origin_y += self.velocity_y * think_speed; - - // TODO consider the ball's radius (and add cvar for that) - if ( self.origin_y <= 0 ) + this.nextthink = time + think_speed; + + this.origin_x += this.velocity_x * think_speed; + this.origin_y += this.velocity_y * think_speed; + this.SendFlags |= MINIG_SF_UPDATE; + + int i; + for ( i = 1; i <= PONG_MAX_PLAYERS; i++ ) + if ( pong_paddle_hit(this, i) ) + { + pong_paddle_bounce(this,i); + this.team = i; + this.SendFlags |= PONG_SF_BALLTEAM; + return; + } + + if ( this.origin_y <= this.pong_length ) { - if ( !pong_goal(self,3) ) + if ( !pong_goal(this,3) ) { - self.origin_y = 0; - self.velocity_y *= -1; + this.origin_y = this.pong_length; + this.velocity_y *= -1; } } - else if ( self.origin_y >= 1 ) + else if ( this.origin_y >= 1-this.pong_length ) { - if ( !pong_goal(self,4) ) + if ( !pong_goal(this,4) ) { - self.origin_y = 1; - self.velocity_y *= -1; + this.origin_y = 1-this.pong_length; + this.velocity_y *= -1; } } - - if ( self.origin_x <= 0 ) + + if ( this.origin_x <= this.pong_length ) { - if ( !pong_goal(self,2) ) + if ( !pong_goal(this,2) ) { - self.origin_x = 0; - self.velocity_x *= -1; + this.origin_x = this.pong_length; + this.velocity_x *= -1; } } - else if ( self.origin_x >= 1 ) + else if ( this.origin_x >= 1-this.pong_length ) { - if ( !pong_goal(self,1) ) + if ( !pong_goal(this,1) ) { - self.origin_x = 1; - self.velocity_x *= -1; + this.origin_x = 1-this.pong_length; + this.velocity_x *= -1; } } - - self.SendFlags |= MINIG_SF_UPDATE; + } -// Moves the paddle -void pong_paddle_think() +// AI action +void pong_ai_think(entity this) { - float think_speed = autocvar_sys_ticrate; - self.nextthink = time + think_speed; - - if ( self.realowner.movement.x > 0 && self.origin_y > self.pong_length/2 ) + float think_speed = autocvar_sv_minigames_pong_ai_thinkspeed; + this.nextthink = time + think_speed; + + float distance; + float next_distance; + float min_distance = 1; + entity ball = world; + entity mayball = world; + while ( ( mayball = findentity(mayball,owner,this.owner) ) ) + if ( mayball.classname == "pong_ball" ) + { + distance = vlen(mayball.origin-this.pong_ai_paddle.origin); + next_distance = vlen(mayball.origin+mayball.velocity-this.pong_ai_paddle.origin); + if ( distance < min_distance && ( distance < 0.5 || next_distance < distance ) ) + { + min_distance = distance; + ball = mayball; + } + } + + float target = 0.5; + float my_pos; + + + if ( this.team <= 2 ) { - self.origin_y -= autocvar_sv_minigames_pong_paddlespeed * think_speed; - if ( self.origin_y < 0 ) - self.origin_y = 0; - self.SendFlags |= MINIG_SF_UPDATE; + if ( ball ) + target = ball.origin_y + ball.velocity_y*think_speed; + my_pos = this.pong_ai_paddle.origin_y; } - else if ( self.realowner.movement.x < 0 && self.origin_y < 1-self.pong_length/2 ) + else + { + if ( ball ) + target = ball.origin_x + ball.velocity_x*think_speed; + my_pos = this.pong_ai_paddle.origin_x; + } + + distance = this.pong_length/2 * autocvar_sv_minigames_pong_ai_tolerance + + autocvar_sv_minigames_pong_paddle_speed * think_speed; + + if (target < my_pos - distance) + this.pong_keys = PONG_KEY_DECREASE; + else if (target > my_pos + distance) + this.pong_keys = PONG_KEY_INCREASE; + else + this.pong_keys = 0; +} + +entity pong_ai_spawn(entity paddle) +{ + entity ai = msle_spawn(paddle.owner,"pong_ai"); + ai.minigame_players = ai; + ai.team = paddle.team; + setthink(ai, pong_ai_think); + ai.nextthink = time; + ai.pong_ai_paddle = paddle; + + paddle.realowner = ai; + + return ai; +} + +// Moves the paddle +void pong_paddle_think(entity this) +{ + float think_speed = autocvar_sys_ticrate; + this.nextthink = time + think_speed; + + if ( this.realowner.minigame_players.pong_keys == PONG_KEY_INCREASE || + this.realowner.minigame_players.pong_keys == PONG_KEY_DECREASE ) { - self.origin_y += autocvar_sv_minigames_pong_paddlespeed * think_speed; - if ( self.origin_y > 1 ) - self.origin_y = 1; - self.SendFlags |= MINIG_SF_UPDATE; + float movement = autocvar_sv_minigames_pong_paddle_speed * think_speed; + float halflen = this.pong_length/2; + + if ( this.realowner.minigame_players.pong_keys == PONG_KEY_DECREASE ) + movement *= -1; + + if ( this.team > 2 ) + this.origin_x = bound(halflen, this.origin_x+movement, 1-halflen); + else + this.origin_y = bound(halflen, this.origin_y+movement, 1-halflen); + + this.SendFlags |= MINIG_SF_UPDATE; } } +vector pong_team_to_box_halfsize(int nteam, float length, float width) +{ + if ( nteam > 2 ) + return eY*width/2 + eX*length/2; + return eX*width/2 + eY*length/2; +} + vector pong_team_to_paddlepos(int nteam) { switch(nteam) @@ -187,6 +308,30 @@ vector pong_team_to_paddlepos(int nteam) } } +// Spawns a pong paddle +// if real_player is world, the paddle is controlled by AI +entity pong_paddle_spawn(entity minigame, int pl_team, entity real_player) +{ + entity paddle = msle_spawn(minigame,"pong_paddle"); + paddle.pong_length = autocvar_sv_minigames_pong_paddle_size; + paddle.origin = pong_team_to_paddlepos(pl_team); + setthink(paddle, pong_paddle_think); + paddle.nextthink = time; + paddle.team = pl_team; + paddle.mins = pong_team_to_box_halfsize(pl_team,-paddle.pong_length,-1/16); + paddle.maxs = pong_team_to_box_halfsize(pl_team,paddle.pong_length,1/16); + + if ( real_player == world ) + pong_ai_spawn(paddle); + else + paddle.realowner = real_player; + + minigame.pong_paddles[pl_team-1] = paddle; + + return paddle; + +} + // required function, handle server side events int pong_server_event(entity minigame, string event, ...) { @@ -197,44 +342,47 @@ int pong_server_event(entity minigame, string event, ...) minigame.minigame_flags |= PONG_STATUS_WAIT; return true; } - case "end": - // nothing to do - return false; case "join": { - int pl_num = minigame_count_players(minigame); - // Don't allow joining a match that is already running if ( minigame.minigame_flags & PONG_STATUS_PLAY ) return false; - // Don't allow any more players - if(pl_num >= PONG_MAX_PLAYERS) - return false; - - int pl_team = 1; - // Get the right team - if(minigame.minigame_players) - pl_team = minigame_next_team(minigame.minigame_players.team, PONG_MAX_PLAYERS); - - entity player = ...(0,entity); - entity paddle = msle_spawn(minigame,"pong_paddle");// Note puddle isn't a typo - paddle.pong_length = autocvar_sv_minigames_pong_paddlesize; - paddle.origin = pong_team_to_paddlepos(pl_team); - paddle.think = pong_paddle_think; - paddle.nextthink = time; - paddle.team = pl_team; - paddle.realowner = player; - minigame.pong_paddles[pl_team-1] = paddle; - - // Team 1 by default - return pl_team; + int i; + for ( i = 0; i < PONG_MAX_PLAYERS; i++ ) + { + if ( minigame.pong_paddles[i] == world ) + { + pong_paddle_spawn(minigame,i+1,player); + return i+1; + } + } + + return false; } case "part": - // TODO remove paddle or switch to AI + { + entity player = ...(0,entity); + entity paddle; + entity ai; + int i; + for ( i = 0; i < PONG_MAX_PLAYERS; i++ ) + { + paddle = minigame.pong_paddles[i]; + if ( paddle != world && paddle.realowner == player ) + { + ai = pong_ai_spawn(paddle); + ai.pong_score = player.minigame_players.pong_score; + break; + } + + } return false; + } case "cmd": + { + entity player = ...(0,entity); switch(argv(0)) { case "throw": @@ -243,16 +391,70 @@ int pong_server_event(entity minigame, string event, ...) minigame.minigame_flags = PONG_STATUS_PLAY | (minigame.minigame_flags & ~PONG_STATUS_WAIT); minigame.SendFlags |= MINIG_SF_UPDATE; - - entity ball = msle_spawn(minigame,"pong_ball"); - pong_ball_reset(ball); - pong_ball_throw(ball); + + int i; + entity ball; + for ( i = 0; i < autocvar_sv_minigames_pong_ball_number; i++ ) + { + ball = msle_spawn(minigame,"pong_ball"); + ball.pong_length = autocvar_sv_minigames_pong_ball_radius; + pong_ball_reset(ball); + } } return true; - + case "+movei": + player.pong_keys |= PONG_KEY_INCREASE; + return true; + case "+moved": + player.pong_keys |= PONG_KEY_DECREASE; + return true; + case "-movei": + player.pong_keys &= ~PONG_KEY_INCREASE; + return true; + case "-moved": + player.pong_keys &= ~PONG_KEY_DECREASE; + return true; + case "pong_aimore": + { + int i; + if ( minigame.minigame_flags & PONG_STATUS_WAIT ) + for ( i = 0; i < PONG_MAX_PLAYERS; i++ ) + { + if ( minigame.pong_paddles[i] == world ) + { + pong_paddle_spawn(minigame,i+1,world); + return true; + } + } + sprint(player.minigame_players,"Cannot spawn AI\n"); + return true; + } + case "pong_ailess": + { + if ( minigame.minigame_flags & PONG_STATUS_WAIT ) + { + entity paddle; + int i; + for ( i = PONG_MAX_PLAYERS-1; i >= 0; i-- ) + { + paddle = minigame.pong_paddles[i]; + if ( paddle != world && + paddle.realowner.classname == "pong_ai" ) + { + minigame.pong_paddles[i] = world; + remove(paddle.realowner); + remove(paddle); + return true; + } + } + } + sprint(player.minigame_players,"Cannot remove AI\n"); + return true; + } + } - // nothing to do return false; + } case "network_send": { entity sent = ...(0,entity); @@ -270,7 +472,7 @@ int pong_server_event(entity minigame, string event, ...) #elif defined(CSQC) -#include "waypointsprites.qh" // drawrotpic +void drawrotpic(vector org, float rot, string pic, vector sz, vector hotspot, vector rgb, float a, float f); float pong_team_to_angle(int nteam) { @@ -301,41 +503,42 @@ void pong_hud_board(vector pos, vector mySize) { minigame_hud_fitsqare(pos, mySize); minigame_hud_simpleboard(pos,mySize,minigame_texture("pong/board")); - + entity e; vector obj_pos; - vector ball_size = minigame_hud_denormalize_size('1 1 0' / 16,pos,mySize); - vector paddle_size; + vector obj_size; FOREACH_MINIGAME_ENTITY(e) { if ( e.classname == "pong_ball" ) { + // Note: 4*radius = 2*diameter because the image is large enough to fit the glow around the ball + obj_size = minigame_hud_denormalize_size('4 4 0'*e.pong_length,pos,mySize); obj_pos = minigame_hud_denormalize(e.origin,pos,mySize); + minigame_drawpic_centered( obj_pos, minigame_texture("pong/ball"), - ball_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL ); - - minigame_drawpic_centered( obj_pos, minigame_texture("pong/ball"), - ball_size, pong_team_to_color(e.team), + obj_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL ); + + minigame_drawpic_centered( obj_pos, minigame_texture("pong/ball-glow"), + obj_size, pong_team_to_color(e.team), panel_fg_alpha, DRAWFLAG_ADDITIVE ); } else if ( e.classname == "pong_paddle" ) { obj_pos = minigame_hud_denormalize(e.origin,pos,mySize); - paddle_size = minigame_hud_denormalize_size(eX / 16 + eY*e.pong_length,pos,mySize); - - drawrotpic(obj_pos, pong_team_to_angle(e.team), minigame_texture("pong/paddle-glow"), - paddle_size, paddle_size/2, pong_team_to_color(e.team), + obj_size = minigame_hud_denormalize_size(eX / 16 + eY*e.pong_length,pos,mySize); + + drawrotpic(obj_pos, pong_team_to_angle(e.team), minigame_texture("pong/paddle-glow"), + obj_size, obj_size/2, pong_team_to_color(e.team), panel_fg_alpha, DRAWFLAG_ADDITIVE ); - - drawrotpic(obj_pos, pong_team_to_angle(e.team), minigame_texture("pong/paddle"), - paddle_size, paddle_size/2, '1 1 1', + + drawrotpic(obj_pos, pong_team_to_angle(e.team), minigame_texture("pong/paddle"), + obj_size, obj_size/2, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL ); - + } } } - // Required function, draw the game status panel void pong_hud_status(vector pos, vector mySize) { @@ -343,36 +546,34 @@ void pong_hud_status(vector pos, vector mySize) vector ts; ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message, hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5); - + ts_y += hud_fontsize_y; pos_y += ts_y; mySize_y -= ts_y; - + vector player_fontsize = hud_fontsize * 1.75; ts_y = ( mySize_y - PONG_MAX_PLAYERS*player_fontsize_y ) / PONG_MAX_PLAYERS; ts_x = mySize_x; vector mypos; - vector tile_size = '48 48 0'; entity e; FOREACH_MINIGAME_ENTITY(e) { - if ( e.classname == "minigame_player" ) + if ( e.classname == "minigame_player" || e.classname == "pong_ai" ) { - // TODO show the team color mypos = pos; mypos_y += (e.team-1) * (player_fontsize_y + ts_y); - - drawfill(mypos, eX*mySize_x+eY*ts_y, pong_team_to_color(e.team), - 0.25, DRAWFLAG_ADDITIVE); - + + drawfill(mypos, ts, pong_team_to_color(e.team), 0.25, DRAWFLAG_ADDITIVE); + minigame_drawcolorcodedstring_trunc(mySize_x,mypos, - (e.minigame_playerslot ? GetPlayerName(e.minigame_playerslot-1) : _("AI")), + (e.minigame_playerslot ? entcs_GetName(e.minigame_playerslot-1) : _("AI")), player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL); - - mypos_y += player_fontsize_y; - - drawstring(mypos,ftos(e.pong_score),tile_size, + + drawstring(mypos+eY*player_fontsize_y,ftos(e.pong_score),'48 48 0', '0.7 0.84 1', panel_fg_alpha, DRAWFLAG_NORMAL); + + if ( e == minigame_self ) + drawborderlines(1, mypos, ts, pong_team_to_color(e.team), 1, DRAWFLAG_NORMAL); } } } @@ -382,7 +583,7 @@ string pong_message(int mgflags) { string rmessage = ""; if (mgflags & PONG_STATUS_WAIT) - rmessage = _("Press \"Throw Ball\" to start the match with the current players"); + rmessage = _("Press ^1Start Match^7 to start the match with the current players"); return rmessage; } @@ -398,9 +599,32 @@ int pong_client_event(entity minigame, string event, ...) { case K_UPARROW: case K_KP_UPARROW: + case K_LEFTARROW: + case K_KP_LEFTARROW: + minigame_cmd("+moved"); + return true; + case K_DOWNARROW: + case K_KP_DOWNARROW: + case K_RIGHTARROW: + case K_KP_RIGHTARROW: + minigame_cmd("+movei"); + return true; + } + return false; + case "key_released": + switch ( ...(0,int) ) + { + case K_UPARROW: + case K_KP_UPARROW: + case K_LEFTARROW: + case K_KP_LEFTARROW: + minigame_cmd("-moved"); return true; case K_DOWNARROW: case K_KP_DOWNARROW: + case K_RIGHTARROW: + case K_KP_RIGHTARROW: + minigame_cmd("-movei"); return true; } return false; @@ -423,7 +647,9 @@ int pong_client_event(entity minigame, string event, ...) } case "menu_show": { - HUD_MinigameMenu_CustomEntry(...(0,entity),_("Throw Ball"),"pong_throw"); + HUD_MinigameMenu_CustomEntry(...(0,entity),_("Start Match"),"pong_throw"); + HUD_MinigameMenu_CustomEntry(...(0,entity),_("Add AI player"),"pong_aimore"); + HUD_MinigameMenu_CustomEntry(...(0,entity),_("Remove AI player"),"pong_ailess"); return false; } case "menu_click": @@ -433,10 +659,14 @@ int pong_client_event(entity minigame, string event, ...) { minigame_cmd("throw"); } + else if ( cmd == "pong_aimore" || cmd == "pong_ailess" ) + { + minigame_cmd(cmd); + } return false; } } return false; } -#endif \ No newline at end of file +#endif