qcsrc/common/minigames/minigame/ps.qc

   1 REGISTER_MINIGAME(ps, "Peg Solitaire");
   2
   3 const float PS_TURN_MOVE  = 0x0100; // player has to click on a piece on the board
   4 const float PS_TURN_WIN   = 0x0200; // player has won
   5 const float PS_TURN_DRAW  = 0x0400; // player can make no more moves
   6 const float PS_TURN_TYPE  = 0x0f00; // turn type mask
   7
   8 const int PS_LET_CNT = 7;
   9 const int PS_NUM_CNT = 7;
  10
  11 const int PS_TILE_SIZE = 8;
  12
  13 // find same game piece given its tile name
  14 entity ps_find_piece(entity minig, string tile)
  15 {
  16         entity e = NULL;
  17         while ( ( e = findentity(e,owner,minig) ) )
  18                 if ( e.classname == "minigame_board_piece" && e.netname == tile )
  19                         return e;
  20         return NULL;
  21 }
  22
  23 bool ps_draw(entity minigame)
  24 {
  25         int valid = 0;
  26         entity e = NULL;
  27         while( ( e = findentity(e,owner,minigame) ) )
  28                 if( e.classname == "minigame_board_piece" )
  29                 {
  30                         ++valid;
  31                 }
  32
  33         return ((valid > 0) ? true : false);
  34 }
  35
  36 bool ps_tile_blacklisted(string tile)
  37 {
  38         int number = minigame_tile_number(tile);
  39         int letter = minigame_tile_letter(tile);
  40         if(letter < 2)
  41                 if(number < 2)
  42                         return true;
  43                 else if(number > PS_NUM_CNT - 3)
  44                         return true;
  45         if(letter > PS_LET_CNT - 3)
  46                 if(number < 2)
  47                         return true;
  48                 else if(number > PS_NUM_CNT - 3)
  49                         return true;
  50
  51         return false;
  52 }
  53
  54 // check if the tile name is valid (5x5 grid)
  55 bool ps_valid_tile(string tile)
  56 {
  57         if ( !tile )
  58                 return false;
  59         if(ps_tile_blacklisted(tile))
  60                 return false;
  61         float number = minigame_tile_number(tile);
  62         float letter = minigame_tile_letter(tile);
  63         return 0 <= number && number < PS_NUM_CNT && 0 <= letter && letter < PS_LET_CNT;
  64 }
  65
  66 // Checks if the given piece completes a row
  67 bool ps_winning_piece(entity minigame)
  68 {
  69         //int number = minigame_tile_number(piece.netname);
  70         //int letter = minigame_tile_letter(piece.netname);
  71
  72         entity e = NULL;
  73         while ( ( e = findentity(e,owner,minigame) ) )
  74                 if ( e.classname == "minigame_board_piece" )
  75                 {
  76                         int number = minigame_tile_number(e.netname);
  77                         int letter = minigame_tile_letter(e.netname);
  78                         string try = minigame_tile_buildname(letter - 1, number);
  79                         if(ps_find_piece(minigame,try))
  80                         {
  81                                 try = minigame_tile_buildname(letter - 2, number);
  82                                 if(ps_valid_tile(try) && !ps_find_piece(minigame,try))
  83                                         return false; // a move is valid, abort!
  84                         }
  85                         try = minigame_tile_buildname(letter + 1, number);
  86                         if(ps_find_piece(minigame,try))
  87                         {
  88                                 try = minigame_tile_buildname(letter + 2, number);
  89                                 if(ps_valid_tile(try) && !ps_find_piece(minigame,try))
  90                                         return false; // a move is valid, abort!
  91                         }
  92                         try = minigame_tile_buildname(letter, number - 1);
  93                         if(ps_find_piece(minigame,try))
  94                         {
  95                                 try = minigame_tile_buildname(letter, number - 2);
  96                                 if(ps_valid_tile(try) && !ps_find_piece(minigame,try))
  97                                         return false; // a move is valid, abort!
  98                         }
  99                         try = minigame_tile_buildname(letter, number + 1);
 100                         if(ps_find_piece(minigame,try))
 101                         {
 102                                 try = minigame_tile_buildname(letter, number + 2);
 103                                 if(ps_valid_tile(try) && !ps_find_piece(minigame,try))
 104                                         return false; // a move is valid, abort!
 105                         }
 106                 }
 107
 108         return true;
 109 }
 110
 111 void ps_setup_pieces(entity minigame)
 112 {
 113         int i, t;
 114         for(i = 0; i < PS_NUM_CNT; ++i)
 115         for(t = 0; t < PS_LET_CNT; ++t)
 116         {
 117                 string try = minigame_tile_buildname(i,t);
 118                 if(!ps_valid_tile(try))
 119                         continue;
 120                 if(i == floor(PS_NUM_CNT * 0.5) && t == floor(PS_LET_CNT * 0.5))
 121                         continue; // middle piece is empty
 122                 entity piece = msle_spawn(minigame,"minigame_board_piece");
 123                 piece.team = 1; // init default team?
 124                 piece.netname = strzone(minigame_tile_buildname(t,i));
 125                 minigame_server_sendflags(piece,MINIG_SF_ALL);
 126         }
 127
 128         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 129 }
 130
 131 bool ps_move_piece(entity minigame, entity piece, string pos, int leti, int numb)
 132 {
 133         if(!piece)
 134                 return false;
 135         if(ps_find_piece(minigame, pos))
 136                 return false;
 137         entity middle = ps_find_piece(minigame, minigame_tile_buildname(leti,numb));
 138         if(!middle)
 139                 return false;
 140
 141         if(middle.netname) { strunzone(middle.netname); }
 142         delete(middle);
 143
 144         if(piece.netname) { strunzone(piece.netname); }
 145         piece.netname = strzone(pos);
 146
 147         minigame_server_sendflags(piece,MINIG_SF_ALL);
 148
 149         return true;
 150 }
 151
 152 // make a move
 153 void ps_move(entity minigame, entity player, string thepiece, string pos )
 154 {
 155         if ( minigame.minigame_flags & PS_TURN_MOVE )
 156         if ( pos )
 157         {
 158                 if ( ps_valid_tile(pos) )
 159                 if ( !ps_find_piece(minigame, pos) && ps_find_piece(minigame, thepiece) )
 160                 {
 161                         entity piece = ps_find_piece(minigame, thepiece);
 162                         int number = minigame_tile_number(thepiece);
 163                         int letter = minigame_tile_letter(thepiece);
 164                         bool done = false;
 165                         string try;
 166
 167                         try = minigame_tile_buildname(letter-1,number);
 168                         if(ps_find_piece(minigame,try))
 169                         {
 170                                 try = minigame_tile_buildname(letter-2,number);
 171                                 if(ps_valid_tile(try) && try == pos)
 172                                         done = ps_move_piece(minigame, piece, pos, letter - 1, number);
 173                         }
 174                         try = minigame_tile_buildname(letter+1,number);
 175                         if(!done && ps_find_piece(minigame,try))
 176                         {
 177                                 try = minigame_tile_buildname(letter+2,number);
 178                                 if(ps_valid_tile(try) && try == pos)
 179                                         done = ps_move_piece(minigame, piece, pos, letter + 1, number);
 180                         }
 181                         try = minigame_tile_buildname(letter,number-1);
 182                         if(!done && ps_find_piece(minigame,try))
 183                         {
 184                                 try = minigame_tile_buildname(letter,number-2);
 185                                 if(ps_valid_tile(try) && try == pos)
 186                                         done = ps_move_piece(minigame, piece, pos, letter, number - 1);
 187                         }
 188                         try = minigame_tile_buildname(letter,number+1);
 189                         if(!done && ps_find_piece(minigame,try))
 190                         {
 191                                 try = minigame_tile_buildname(letter,number+2);
 192                                 if(ps_valid_tile(try) && try == pos)
 193                                         done = ps_move_piece(minigame, piece, pos, letter, number + 1);
 194                         }
 195
 196                         if(!done)
 197                                 return; // didn't make a move
 198
 199                         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 200
 201                         if ( ps_winning_piece(minigame) )
 202                         {
 203                                 if(ps_draw(minigame))
 204                                         minigame.minigame_flags = PS_TURN_DRAW;
 205                                 else
 206                                         minigame.minigame_flags = PS_TURN_WIN;
 207                         }
 208                         else
 209                                 minigame.minigame_flags = PS_TURN_MOVE;
 210                 }
 211         }
 212 }
 213
 214 #ifdef SVQC
 215
 216
 217 // required function, handle server side events
 218 int ps_server_event(entity minigame, string event, ...)
 219 {
 220         switch(event)
 221         {
 222                 case "start":
 223                 {
 224                         ps_setup_pieces(minigame);
 225                         minigame.minigame_flags = PS_TURN_MOVE;
 226                         return true;
 227                 }
 228                 case "end":
 229                 {
 230                         entity e = NULL;
 231                         while( (e = findentity(e, owner, minigame)) )
 232                         if(e.classname == "minigame_board_piece")
 233                         {
 234                                 if(e.netname) { strunzone(e.netname); }
 235                                 delete(e);
 236                         }
 237                         return false;
 238                 }
 239                 case "join":
 240                 {
 241                         int pl_num = minigame_count_players(minigame);
 242
 243                         // Don't allow more than 1 player
 244                         if(pl_num >= 1) { return false; }
 245
 246                         // Team 1 by default
 247                         return 1;
 248                 }
 249                 case "cmd":
 250                 {
 251                         switch(argv(0))
 252                         {
 253                                 case "move":
 254
 255                                         ps_move(minigame, ...(0,entity), (...(1,int) == 3 ? argv(1) : string_null), (...(1,int) == 3 ? argv(2) : string_null));
 256                                         return true;
 257                         }
 258
 259                         return false;
 260                 }
 261         }
 262
 263         return false;
 264 }
 265
 266
 267 #elif defined(CSQC)
 268
 269 entity ps_curr_piece; // identifier for the currently selected piece
 270 string ps_curr_pos; // identifier of the tile under the mouse
 271 vector ps_boardpos; // HUD board position
 272 vector ps_boardsize;// HUD board size
 273
 274 // Required function, draw the game board
 275 void ps_hud_board(vector pos, vector mySize)
 276 {
 277         minigame_hud_fitsqare(pos, mySize);
 278         ps_boardpos = pos;
 279         ps_boardsize = mySize;
 280
 281         minigame_hud_simpleboard(pos,mySize,minigame_texture("ps/board"));
 282
 283         vector tile_size = minigame_hud_denormalize_size('1 1 0' / PS_TILE_SIZE,pos,mySize);
 284         vector tile_pos;
 285
 286         bool valid = ps_valid_tile(ps_curr_pos);
 287         bool highlight = false;
 288         if(valid)
 289         {
 290                 string try;
 291                 int number = minigame_tile_number(ps_curr_pos);
 292                 int letter = minigame_tile_letter(ps_curr_pos);
 293                 try = minigame_tile_buildname(letter-1,number);
 294                 if(ps_find_piece(active_minigame,try))
 295                 {
 296                         try = minigame_tile_buildname(letter-2,number);
 297                         if(ps_valid_tile(try) && !ps_find_piece(active_minigame,try))
 298                                 highlight = true;
 299                 }
 300                 try = minigame_tile_buildname(letter+1,number);
 301                 if(ps_find_piece(active_minigame,try))
 302                 {
 303                         try = minigame_tile_buildname(letter+2,number);
 304                         if(ps_valid_tile(try) && !ps_find_piece(active_minigame,try))
 305                                 highlight = true;
 306                 }
 307                 try = minigame_tile_buildname(letter,number-1);
 308                 if(ps_find_piece(active_minigame,try))
 309                 {
 310                         try = minigame_tile_buildname(letter,number-2);
 311                         if(ps_valid_tile(try) && !ps_find_piece(active_minigame,try))
 312                                 highlight = true;
 313                 }
 314                 try = minigame_tile_buildname(letter,number+1);
 315                 if(ps_find_piece(active_minigame,try))
 316                 {
 317                         try = minigame_tile_buildname(letter,number+2);
 318                         if(ps_valid_tile(try) && !ps_find_piece(active_minigame,try))
 319                                 highlight = true;
 320                 }
 321         }
 322         bool draw_pos = false;
 323         if(ps_curr_piece && valid && !ps_find_piece(active_minigame, ps_curr_pos))
 324         {
 325                 string try; // sigh
 326                 int numb = minigame_tile_number(ps_curr_piece.netname);
 327                 int leti = minigame_tile_letter(ps_curr_piece.netname);
 328
 329                 try = minigame_tile_buildname(leti-1,numb);
 330                 if(ps_find_piece(active_minigame,try))
 331                 {
 332                         try = minigame_tile_buildname(leti-2,numb);
 333                         if(try == ps_curr_pos)
 334                                 draw_pos = true;
 335                 }
 336                 try = minigame_tile_buildname(leti+1,numb);
 337                 if(ps_find_piece(active_minigame,try))
 338                 {
 339                         try = minigame_tile_buildname(leti+2,numb);
 340                         if(try == ps_curr_pos)
 341                                 draw_pos = true;
 342                 }
 343                 try = minigame_tile_buildname(leti,numb-1);
 344                 if(ps_find_piece(active_minigame,try))
 345                 {
 346                         try = minigame_tile_buildname(leti,numb-2);
 347                         if(try == ps_curr_pos)
 348                                 draw_pos = true;
 349                 }
 350                 try = minigame_tile_buildname(leti,numb+1);
 351                 if(ps_find_piece(active_minigame,try))
 352                 {
 353                         try = minigame_tile_buildname(leti,numb+2);
 354                         if(try == ps_curr_pos)
 355                                 draw_pos = true;
 356                 }
 357         }
 358
 359         entity e;
 360         FOREACH_MINIGAME_ENTITY(e)
 361         {
 362                 if ( e.classname == "minigame_board_piece" )
 363                 {
 364                         tile_pos = minigame_tile_pos(e.netname,PS_NUM_CNT,PS_LET_CNT);
 365                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 366
 367                         vector tile_color = '1 1 1';
 368
 369                         if(highlight)
 370                         if(e.netname == ps_curr_pos)
 371                         if(ps_curr_piece.netname != ps_curr_pos)
 372                         {
 373                                 minigame_drawpic_centered( tile_pos,
 374                                                 minigame_texture("ps/tile_available"),
 375                                                 tile_size, tile_color, panel_fg_alpha, DRAWFLAG_NORMAL );
 376                         }
 377                         if(e == ps_curr_piece)
 378                         {
 379                                 minigame_drawpic_centered( tile_pos,
 380                                                 minigame_texture("ps/tile_selected"),
 381                                                 tile_size, tile_color, panel_fg_alpha, DRAWFLAG_ADDITIVE );
 382                         }
 383
 384                         minigame_drawpic_centered( tile_pos,
 385                                         minigame_texture("ps/piece"),
 386                                         tile_size * 0.8, tile_color, panel_fg_alpha, DRAWFLAG_NORMAL );
 387                 }
 388         }
 389
 390         if(draw_pos)
 391         {
 392                 tile_pos = minigame_tile_pos(ps_curr_pos,PS_NUM_CNT,PS_LET_CNT);
 393                 tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 394
 395                 minigame_drawpic_centered(tile_pos,
 396                                 minigame_texture("ps/piece"),
 397                                 tile_size * 0.8, '0.5 0.5 0.5', panel_fg_alpha, DRAWFLAG_NORMAL);
 398         }
 399
 400         if ( ( active_minigame.minigame_flags & PS_TURN_WIN ) || ( active_minigame.minigame_flags & PS_TURN_DRAW ) )
 401         {
 402                 int remaining = 0;
 403                 FOREACH_MINIGAME_ENTITY(e)
 404                         if(e.classname == "minigame_board_piece")
 405                                 ++remaining;
 406
 407                 vector winfs = hud_fontsize*2;
 408                 string remaining_text;
 409                 if(active_minigame.minigame_flags & PS_TURN_WIN)
 410                         remaining_text = "All pieces cleared!";
 411                 else
 412                         remaining_text = strcat("Remaining pieces: ", ftos(remaining));
 413
 414                 vector win_pos = pos+eY*(mySize_y-winfs_y)/2;
 415                 vector win_sz;
 416                 win_sz = minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
 417                         sprintf("Game over! %s", remaining_text),
 418                         winfs, 0, DRAWFLAG_NORMAL, 0.5);
 419
 420                 drawfill(win_pos-eY*hud_fontsize_y,win_sz+2*eY*hud_fontsize_y,'1 1 1',0.5,DRAWFLAG_ADDITIVE);
 421
 422                 minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
 423                         sprintf("Game over! %s", remaining_text),
 424                         winfs, panel_fg_alpha, DRAWFLAG_NORMAL, 0.5);
 425         }
 426 }
 427
 428
 429 // Required function, draw the game status panel
 430 void ps_hud_status(vector pos, vector mySize)
 431 {
 432         HUD_Panel_DrawBg(1);
 433         vector ts;
 434         ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
 435                 hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
 436
 437         pos_y += ts_y;
 438         mySize_y -= ts_y;
 439
 440         vector player_fontsize = hud_fontsize * 1.75;
 441         ts_y = ( mySize_y - 2*player_fontsize_y ) / 2;
 442         ts_x = mySize_x;
 443         vector mypos;
 444         vector tile_size = '48 48 0';
 445
 446         mypos = pos;
 447         drawfill(mypos,eX*mySize_x+eY*player_fontsize_y,'1 1 1',0.5,DRAWFLAG_ADDITIVE);
 448         mypos_y += player_fontsize_y;
 449         drawfill(mypos,eX*mySize_x+eY*tile_size_y,'1 1 1',0.25,DRAWFLAG_ADDITIVE);
 450
 451         int remaining = 0;
 452         entity e;
 453         FOREACH_MINIGAME_ENTITY(e)
 454         {
 455                 if(e.classname == "minigame_board_piece")
 456                 {
 457                         ++remaining;
 458                 }
 459         }
 460
 461         FOREACH_MINIGAME_ENTITY(e)
 462         {
 463                 if ( e.classname == "minigame_player" )
 464                 {
 465                         mypos = pos;
 466                         minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
 467                                 entcs_GetName(e.minigame_playerslot-1),
 468                                 player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
 469
 470                         mypos_y += player_fontsize_y;
 471                         //drawpic( mypos,
 472                         //              minigame_texture("ps/piece"),
 473                         //              tile_size, '1 0 0', panel_fg_alpha, DRAWFLAG_NORMAL );
 474
 475                         //mypos_x += tile_size_x;
 476
 477                         drawstring(mypos,sprintf(_("Pieces left: %s"), ftos(remaining)),'28 28 0',
 478                                            '0.7 0.84 1', panel_fg_alpha, DRAWFLAG_NORMAL);
 479                 }
 480         }
 481 }
 482
 483 // Turn a set of flags into a help message
 484 string ps_turn_to_string(int turnflags)
 485 {
 486         if (turnflags & PS_TURN_DRAW )
 487                 return _("No more valid moves");
 488
 489         if ( turnflags & PS_TURN_WIN )
 490                 return _("Well done, you win!");
 491
 492         if ( turnflags & PS_TURN_MOVE )
 493                 return _("Jump a piece over another to capture it");
 494
 495         return "";
 496 }
 497
 498 // Make the correct move
 499 void ps_make_move(entity minigame)
 500 {
 501         if ( minigame.minigame_flags == PS_TURN_MOVE )
 502         {
 503                 entity piece = ps_find_piece(minigame,ps_curr_pos);
 504                 if(!ps_curr_piece || piece)
 505                         ps_curr_piece = ps_find_piece(minigame,ps_curr_pos);
 506                 else
 507                 {
 508                         minigame_cmd("move ", ps_curr_piece.netname, " ", ps_curr_pos);
 509                         ps_curr_piece = NULL;
 510                 }
 511         }
 512 }
 513
 514 void ps_set_curr_pos(string s)
 515 {
 516         if ( ps_curr_pos )
 517                 strunzone(ps_curr_pos);
 518         if ( s )
 519                 s = strzone(s);
 520         ps_curr_pos = s;
 521 }
 522
 523 // Required function, handle client events
 524 int ps_client_event(entity minigame, string event, ...)
 525 {
 526         switch(event)
 527         {
 528                 case "activate":
 529                 {
 530                         ps_set_curr_pos("");
 531                         ps_curr_piece = NULL;
 532                         minigame.message = ps_turn_to_string(minigame.minigame_flags);
 533                         return false;
 534                 }
 535                 case "key_pressed":
 536                 {
 537                         //if((minigame.minigame_flags & PS_TURN_TEAM) == minigame_self.team)
 538                         {
 539                                 switch ( ...(0,int) )
 540                                 {
 541                                         case K_RIGHTARROW:
 542                                         case K_KP_RIGHTARROW:
 543                                                 if ( ! ps_curr_pos )
 544                                                         ps_set_curr_pos("a3");
 545                                                 else
 546                                                         ps_set_curr_pos( minigame_relative_tile(ps_curr_pos,1,0,PS_NUM_CNT,PS_LET_CNT));
 547                                                 return true;
 548                                         case K_LEFTARROW:
 549                                         case K_KP_LEFTARROW:
 550                                                 if ( ! ps_curr_pos )
 551                                                         ps_set_curr_pos("c3");
 552                                                 else
 553                                                         ps_set_curr_pos(minigame_relative_tile(ps_curr_pos,-1,0,PS_NUM_CNT,PS_LET_CNT));
 554                                                 return true;
 555                                         case K_UPARROW:
 556                                         case K_KP_UPARROW:
 557                                                 if ( ! ps_curr_pos )
 558                                                         ps_set_curr_pos("a1");
 559                                                 else
 560                                                         ps_set_curr_pos(minigame_relative_tile(ps_curr_pos,0,1,PS_NUM_CNT,PS_LET_CNT));
 561                                                 return true;
 562                                         case K_DOWNARROW:
 563                                         case K_KP_DOWNARROW:
 564                                                 if ( ! ps_curr_pos )
 565                                                         ps_set_curr_pos("a3");
 566                                                 else
 567                                                         ps_set_curr_pos(minigame_relative_tile(ps_curr_pos,0,-1,PS_NUM_CNT,PS_LET_CNT));
 568                                                 return true;
 569                                         case K_ENTER:
 570                                         case K_KP_ENTER:
 571                                         case K_SPACE:
 572                                                 ps_make_move(minigame);
 573                                                 return true;
 574                                 }
 575                         }
 576
 577                         return false;
 578                 }
 579                 case "mouse_pressed":
 580                 {
 581                         if(...(0,int) == K_MOUSE1)
 582                         {
 583                                 ps_make_move(minigame);
 584                                 return true;
 585                         }
 586
 587                         return false;
 588                 }
 589                 case "mouse_moved":
 590                 {
 591                         vector mouse_pos = minigame_hud_normalize(mousepos,ps_boardpos,ps_boardsize);
 592                         if ( minigame.minigame_flags == PS_TURN_MOVE )
 593                         {
 594                                 ps_set_curr_pos(minigame_tile_name(mouse_pos,PS_NUM_CNT,PS_LET_CNT));
 595                         }
 596                         if ( ! ps_valid_tile(ps_curr_pos) )
 597                                 ps_set_curr_pos("");
 598
 599                         return true;
 600                 }
 601                 case "network_receive":
 602                 {
 603                         entity sent = ...(0,entity);
 604                         int sf = ...(1,int);
 605                         if ( sent.classname == "minigame" )
 606                         {
 607                                 if ( sf & MINIG_SF_UPDATE )
 608                                 {
 609                                         sent.message = ps_turn_to_string(sent.minigame_flags);
 610                                         if ( sent.minigame_flags & minigame_self.team )
 611                                                 minigame_prompt();
 612                                 }
 613                         }
 614
 615                         return false;
 616                 }
 617         }
 618
 619         return false;
 620 }
 621
 622 #endif