qcsrc/common/minigames/minigame/c4.qc

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