qcsrc/common/minigames/minigame/c4.qc

   1 REGISTER_MINIGAME(c4, "Connect Four");
   2
   3 const float C4_TURN_PLACE = 0x0100; // player has to place a piece on the board
   4 const float C4_TURN_WIN   = 0x0200; // player has won
   5 const float C4_TURN_DRAW  = 0x0400; // no moves are possible
   6
   7 const float C4_TURN_TEAM1 = 0x0001;
   8 const float C4_TURN_TEAM2 = 0x0002;
   9 const float C4_TURN_TEAM  = 0x000f; // turn team mask
  10
  11 const int C4_LET_CNT = 7;
  12 const int C4_NUM_CNT = 6;
  13 const int C4_WIN_CNT = 4;
  14
  15 const int C4_MAX_TILES = 42;
  16
  17 const int C4_TILE_SIZE = 8;
  18
  19 const int C4_TEAMS = 2;
  20
  21 .int c4_npieces; // (minigame) number of pieces on the board (simplifies checking a draw)
  22 .int c4_nexteam; // (minigame) next team (used to change the starting team on following matches)
  23
  24 // find connect 4 piece given its tile name
  25 entity c4_find_piece(entity minig, string tile)
  26 {
  27         entity e = world;
  28         while ( ( e = findentity(e,owner,minig) ) )
  29                 if ( e.classname == "minigame_board_piece" && e.netname == tile )
  30                         return e;
  31         return world;
  32 }
  33
  34 // Checks if the given piece completes a row
  35 bool c4_winning_piece(entity piece)
  36 {
  37         int number = minigame_tile_number(piece.netname);
  38         int letter = minigame_tile_letter(piece.netname);
  39
  40         int i;
  41         entity top = piece;
  42         entity left = piece;
  43         entity topleft = piece;
  44         entity botleft = piece;
  45         for(i = number; i < C4_NUM_CNT; ++i)
  46         {
  47                 entity p = c4_find_piece(piece.owner,minigame_tile_buildname(letter, i));
  48                 if(p.team == piece.team)
  49                         top = p;
  50                 else break;
  51         }
  52
  53         for(i = letter; i >= 0; --i)
  54         {
  55                 entity p = c4_find_piece(piece.owner,minigame_tile_buildname(i, number));
  56                 if(p.team == piece.team)
  57                         left = p;
  58                 else break;
  59         }
  60
  61         int j;
  62         for(i = letter, j = number; i >= 0, j >= 0; --i, --j)
  63         {
  64                 entity p = c4_find_piece(piece.owner,minigame_tile_buildname(i, j));
  65                 if(p.team == piece.team)
  66                         botleft = p;
  67                 else break;
  68         }
  69         for(i = letter, j = number; i >= 0, j < C4_NUM_CNT; --i, ++j)
  70         {
  71                 entity p = c4_find_piece(piece.owner,minigame_tile_buildname(i, j));
  72                 if(p.team == piece.team)
  73                         topleft = p;
  74                 else break;
  75         }
  76
  77         // down
  78         int found = 0;
  79         for(i = minigame_tile_number(top.netname); i >= 0; --i)
  80         {
  81                 if(c4_find_piece(piece.owner,minigame_tile_buildname(letter, i)).team == piece.team)
  82                         ++found;
  83                 else break;
  84         }
  85
  86         if(found >= C4_WIN_CNT)
  87                 return true;
  88
  89         // right
  90         found = 0;
  91         for(i = minigame_tile_letter(left.netname); i < C4_LET_CNT; ++i)
  92         {
  93                 if(c4_find_piece(piece.owner,minigame_tile_buildname(i, number)).team == piece.team)
  94                         ++found;
  95                 else break;
  96         }
  97
  98         if(found >= C4_WIN_CNT)
  99                 return true;
 100
 101         // diagright down
 102         found = 0;
 103         for(i = minigame_tile_letter(topleft.netname), j = minigame_tile_number(topleft.netname); i < C4_LET_CNT, j >= 0; ++i, --j)
 104         {
 105                 if(c4_find_piece(piece.owner,minigame_tile_buildname(i, j)).team == piece.team)
 106                         ++found;
 107                 else break;
 108         }
 109
 110         if(found >= C4_WIN_CNT)
 111                 return true;
 112
 113         // diagright up
 114         found = 0;
 115         for(i = minigame_tile_letter(botleft.netname), j = minigame_tile_number(botleft.netname); i < C4_LET_CNT, j < C4_NUM_CNT; ++i, ++j)
 116         {
 117                 if(c4_find_piece(piece.owner,minigame_tile_buildname(i, j)).team == piece.team)
 118                         ++found;
 119                 else break;
 120         }
 121
 122         if(found >= C4_WIN_CNT)
 123                 return true;
 124
 125         return false;
 126 }
 127
 128 // check if the tile name is valid (6x7 grid)
 129 bool c4_valid_tile(string tile)
 130 {
 131         if ( !tile )
 132                 return false;
 133         float number = minigame_tile_number(tile);
 134         float letter = minigame_tile_letter(tile);
 135         return 0 <= number && number < C4_NUM_CNT && 0 <= letter && letter < C4_LET_CNT;
 136 }
 137
 138 string c4_get_lowest_tile(entity minigame, string s)
 139 {
 140         int i;
 141         int end = 0;
 142         for(i = C4_NUM_CNT; i >= 0; --i)
 143         {
 144                 if(!c4_find_piece(minigame,minigame_tile_buildname(minigame_tile_letter(s), i)))
 145                 if(c4_find_piece(minigame,minigame_tile_buildname(minigame_tile_letter(s), i - 1)))
 146                 {
 147                         end = i;
 148                         break;
 149                 }
 150         }
 151         return minigame_tile_buildname(minigame_tile_letter(s), end);
 152 }
 153
 154 // make a move
 155 void c4_move(entity minigame, entity player, string pos )
 156 {
 157         pos = c4_get_lowest_tile(minigame, pos);
 158
 159         if ( minigame.minigame_flags & C4_TURN_PLACE )
 160         if ( pos && player.team == (minigame.minigame_flags & C4_TURN_TEAM) )
 161         {
 162                 if ( c4_valid_tile(pos) )
 163                 if ( !c4_find_piece(minigame,pos) )
 164                 {
 165                         entity piece = msle_spawn(minigame,"minigame_board_piece");
 166                         piece.team = player.team;
 167                         piece.netname = strzone(pos);
 168                         minigame_server_sendflags(piece,MINIG_SF_ALL);
 169                         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 170                         minigame.c4_npieces++;
 171                         minigame.c4_nexteam = minigame_next_team(player.team,C4_TEAMS);
 172                         if ( c4_winning_piece(piece) )
 173                         {
 174                                 minigame.minigame_flags = C4_TURN_WIN | player.team;
 175                         }
 176                         else if ( minigame.c4_npieces >= C4_MAX_TILES )
 177                                 minigame.minigame_flags = C4_TURN_DRAW;
 178                         else
 179                                 minigame.minigame_flags = C4_TURN_PLACE | minigame.c4_nexteam;
 180                 }
 181         }
 182 }
 183
 184 #ifdef SVQC
 185
 186
 187 // required function, handle server side events
 188 int c4_server_event(entity minigame, string event, ...)
 189 {
 190         switch(event)
 191         {
 192                 case "start":
 193                 {
 194                         minigame.minigame_flags = (C4_TURN_PLACE | C4_TURN_TEAM1);
 195                         return true;
 196                 }
 197                 case "end":
 198                 {
 199                         entity e = world;
 200                         while( (e = findentity(e, owner, minigame)) )
 201                         if(e.classname == "minigame_board_piece")
 202                         {
 203                                 if(e.netname) { strunzone(e.netname); }
 204                                 remove(e);
 205                         }
 206                         return false;
 207                 }
 208                 case "join":
 209                 {
 210                         int pl_num = minigame_count_players(minigame);
 211
 212                         // Don't allow more than 2 players
 213                         if(pl_num >= C4_TEAMS) { return false; }
 214
 215                         // Get the right team
 216                         if(minigame.minigame_players)
 217                                 return minigame_next_team(minigame.minigame_players.team, C4_TEAMS);
 218
 219                         // Team 1 by default
 220                         return 1;
 221                 }
 222                 case "cmd":
 223                 {
 224                         switch(argv(0))
 225                         {
 226                                 case "move":
 227                                         c4_move(minigame, ...(0,entity), ...(1,int) == 2 ? argv(1) : string_null );
 228                                         return true;
 229                         }
 230
 231                         return false;
 232                 }
 233         }
 234
 235         return false;
 236 }
 237
 238
 239 #elif defined(CSQC)
 240
 241 string c4_curr_pos; // identifier of the tile under the mouse
 242 vector c4_boardpos; // HUD board position
 243 vector c4_boardsize;// HUD board size
 244 .int c4_checkwin; // Used to optimize checks to display a win
 245
 246 // Required function, draw the game board
 247 void c4_hud_board(vector pos, vector mySize)
 248 {
 249         minigame_hud_fitsqare(pos, mySize);
 250         c4_boardpos = pos;
 251         c4_boardsize = mySize;
 252
 253         minigame_hud_simpleboard(pos,mySize,minigame_texture("c4/board_under"));
 254
 255         drawpic(pos, minigame_texture("c4/board_over"), mySize, '1 1 1', 1, 0);
 256
 257         vector tile_size = minigame_hud_denormalize_size('1 1 0' / C4_TILE_SIZE,pos,mySize);
 258         vector tile_pos;
 259
 260         if ( (active_minigame.minigame_flags & C4_TURN_TEAM) == minigame_self.team )
 261         if ( c4_valid_tile(c4_curr_pos) )
 262         {
 263                 tile_pos = minigame_tile_pos(c4_curr_pos,C4_NUM_CNT,C4_LET_CNT);
 264                 tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 265                 minigame_drawpic_centered( tile_pos,
 266                                 minigame_texture(strcat("c4/piece",ftos(minigame_self.team))),
 267                                 tile_size, '1 1 1', panel_fg_alpha/2, DRAWFLAG_NORMAL );
 268         }
 269
 270         entity e;
 271         FOREACH_MINIGAME_ENTITY(e)
 272         {
 273                 if ( e.classname == "minigame_board_piece" )
 274                 {
 275                         tile_pos = minigame_tile_pos(e.netname,C4_NUM_CNT,C4_LET_CNT);
 276                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 277
 278                         if ( active_minigame.minigame_flags & C4_TURN_WIN )
 279                         if ( !e.c4_checkwin )
 280                                 e.c4_checkwin = c4_winning_piece(e) ? 1 : -1;
 281
 282                         float icon_color = 1;
 283                         if ( e.c4_checkwin == -1 )
 284                                 icon_color = 0.4;
 285                         else if ( e.c4_checkwin == 1 )
 286                         {
 287                                 icon_color = 2;
 288                                 minigame_drawpic_centered( tile_pos, minigame_texture("c4/winglow"),
 289                                                 tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_ADDITIVE );
 290                         }
 291
 292                         minigame_drawpic_centered( tile_pos,
 293                                         minigame_texture(strcat("c4/piece",ftos(e.team))),
 294                                         tile_size, '1 1 1'*icon_color, panel_fg_alpha, DRAWFLAG_NORMAL );
 295                 }
 296         }
 297
 298         if ( active_minigame.minigame_flags & C4_TURN_WIN )
 299         {
 300                 vector winfs = hud_fontsize*2;
 301                 string playername = "";
 302                 FOREACH_MINIGAME_ENTITY(e)
 303                         if ( e.classname == "minigame_player" &&
 304                                         e.team == (active_minigame.minigame_flags & C4_TURN_TEAM) )
 305                                 playername = entcs_GetName(e.minigame_playerslot-1);
 306
 307                 vector win_pos = pos+eY*(mySize_y-winfs_y)/2;
 308                 vector win_sz;
 309                 win_sz = minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
 310                         sprintf("%s^7 won the game!",playername),
 311                         winfs, 0, DRAWFLAG_NORMAL, 0.5);
 312
 313                 drawfill(win_pos-eY*hud_fontsize_y,win_sz+2*eY*hud_fontsize_y,'1 1 1',0.5,DRAWFLAG_ADDITIVE);
 314
 315                 minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
 316                         sprintf("%s^7 won the game!",playername),
 317                         winfs, panel_fg_alpha, DRAWFLAG_NORMAL, 0.5);
 318         }
 319 }
 320
 321
 322 // Required function, draw the game status panel
 323 void c4_hud_status(vector pos, vector mySize)
 324 {
 325         HUD_Panel_DrawBg(1);
 326         vector ts;
 327         ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
 328                 hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
 329
 330         pos_y += ts_y;
 331         mySize_y -= ts_y;
 332
 333         vector player_fontsize = hud_fontsize * 1.75;
 334         ts_y = ( mySize_y - 2*player_fontsize_y ) / 2;
 335         ts_x = mySize_x;
 336         vector mypos;
 337         vector tile_size = '48 48 0';
 338
 339         mypos = pos;
 340         if ( (active_minigame.minigame_flags&C4_TURN_TEAM) == 2 )
 341                 mypos_y  += player_fontsize_y + ts_y;
 342         drawfill(mypos,eX*mySize_x+eY*player_fontsize_y,'1 1 1',0.5,DRAWFLAG_ADDITIVE);
 343         mypos_y += player_fontsize_y;
 344         drawfill(mypos,eX*mySize_x+eY*tile_size_y,'1 1 1',0.25,DRAWFLAG_ADDITIVE);
 345
 346         entity e;
 347         FOREACH_MINIGAME_ENTITY(e)
 348         {
 349                 if ( e.classname == "minigame_player" )
 350                 {
 351                         mypos = pos;
 352                         if ( e.team == 2 )
 353                                 mypos_y  += player_fontsize_y + ts_y;
 354                         minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
 355                                 entcs_GetName(e.minigame_playerslot-1),
 356                                 player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
 357
 358                         mypos_y += player_fontsize_y;
 359                         drawpic( mypos,
 360                                         minigame_texture(strcat("c4/piece",ftos(e.team))),
 361                                         tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
 362
 363                         mypos_x += tile_size_x;
 364                 }
 365         }
 366 }
 367
 368 // Turn a set of flags into a help message
 369 string c4_turn_to_string(int turnflags)
 370 {
 371         if ( turnflags & C4_TURN_DRAW )
 372                 return _("Draw");
 373
 374         if ( turnflags & C4_TURN_WIN )
 375         {
 376                 if ( (turnflags&C4_TURN_TEAM) != minigame_self.team )
 377                         return _("You lost the game!");
 378                 return _("You win!");
 379         }
 380
 381         if ( (turnflags & C4_TURN_TEAM) != minigame_self.team )
 382                 return _("Wait for your opponent to make their move");
 383
 384         if ( turnflags & C4_TURN_PLACE )
 385                 return _("Click on the game board to place your piece");
 386
 387         return "";
 388 }
 389
 390 // Make the correct move
 391 void c4_make_move(entity minigame)
 392 {
 393         if ( minigame.minigame_flags == (C4_TURN_PLACE|minigame_self.team) )
 394         {
 395                 minigame_cmd("move ",c4_curr_pos);
 396         }
 397 }
 398
 399 void c4_set_curr_pos(string s)
 400 {
 401         if ( c4_curr_pos )
 402                 strunzone(c4_curr_pos);
 403         if ( s )
 404                 s = strzone(s);
 405         c4_curr_pos = s;
 406 }
 407
 408 // Required function, handle client events
 409 int c4_client_event(entity minigame, string event, ...)
 410 {
 411         switch(event)
 412         {
 413                 case "activate":
 414                 {
 415                         c4_set_curr_pos("");
 416                         minigame.message = c4_turn_to_string(minigame.minigame_flags);
 417                         return false;
 418                 }
 419                 case "key_pressed":
 420                 {
 421                         if((minigame.minigame_flags & C4_TURN_TEAM) == minigame_self.team)
 422                         {
 423                                 switch ( ...(0,int) )
 424                                 {
 425                                         case K_RIGHTARROW:
 426                                         case K_KP_RIGHTARROW:
 427                                                 if ( ! c4_curr_pos )
 428                                                         c4_set_curr_pos(c4_get_lowest_tile(minigame, "a3"));
 429                                                 else
 430                                                         c4_set_curr_pos(c4_get_lowest_tile(minigame, minigame_relative_tile(c4_curr_pos,1,0,C4_NUM_CNT,C4_LET_CNT)));
 431                                                 return true;
 432                                         case K_LEFTARROW:
 433                                         case K_KP_LEFTARROW:
 434                                                 if ( ! c4_curr_pos )
 435                                                         c4_set_curr_pos(c4_get_lowest_tile(minigame, "c3"));
 436                                                 else
 437                                                         c4_set_curr_pos(c4_get_lowest_tile(minigame, minigame_relative_tile(c4_curr_pos,-1,0,C4_NUM_CNT,C4_LET_CNT)));
 438                                                 return true;
 439                                         /*case K_UPARROW:
 440                                         case K_KP_UPARROW:
 441                                                 if ( ! c4_curr_pos )
 442                                                         c4_set_curr_pos("a1");
 443                                                 else
 444                                                         c4_set_curr_pos(minigame_relative_tile(c4_curr_pos,0,1,6,7));
 445                                                 return true;
 446                                         case K_DOWNARROW:
 447                                         case K_KP_DOWNARROW:
 448                                                 if ( ! c4_curr_pos )
 449                                                         c4_set_curr_pos("a3");
 450                                                 else
 451                                                         c4_set_curr_pos(minigame_relative_tile(c4_curr_pos,0,-1,6,7));
 452                                                 return true;*/
 453                                         case K_ENTER:
 454                                         case K_KP_ENTER:
 455                                         case K_SPACE:
 456                                                 c4_make_move(minigame);
 457                                                 return true;
 458                                 }
 459                         }
 460
 461                         return false;
 462                 }
 463                 case "mouse_pressed":
 464                 {
 465                         if(...(0,int) == K_MOUSE1)
 466                         {
 467                                 c4_make_move(minigame);
 468                                 return true;
 469                         }
 470
 471                         return false;
 472                 }
 473                 case "mouse_moved":
 474                 {
 475                         vector mouse_pos = minigame_hud_normalize(mousepos,c4_boardpos,c4_boardsize);
 476                         if ( minigame.minigame_flags == (C4_TURN_PLACE|minigame_self.team) )
 477                         {
 478                                 c4_set_curr_pos(c4_get_lowest_tile(minigame, minigame_tile_name(mouse_pos,C4_NUM_CNT,C4_LET_CNT)));
 479                         }
 480                         if ( ! c4_valid_tile(c4_curr_pos) )
 481                                 c4_set_curr_pos("");
 482
 483                         return true;
 484                 }
 485                 case "network_receive":
 486                 {
 487                         entity sent = ...(0,entity);
 488                         int sf = ...(1,int);
 489                         if ( sent.classname == "minigame" )
 490                         {
 491                                 if ( sf & MINIG_SF_UPDATE )
 492                                 {
 493                                         sent.message = c4_turn_to_string(sent.minigame_flags);
 494                                         if ( sent.minigame_flags & minigame_self.team )
 495                                                 minigame_prompt();
 496                                 }
 497                         }
 498
 499                         return false;
 500                 }
 501         }
 502
 503         return false;
 504 }
 505
 506 #endif