qcsrc/common/minigames/minigame/bd.qc

   1 REGISTER_MINIGAME(bd, "Bulldozer");
   2
   3 const int BD_TURN_MOVE  = 0x0100; // player must move the bulldozer
   4 const int BD_TURN_WIN   = 0x0200; // victory
   5 const int BD_TURN_LOSS  = 0x0400; // they did it?!
   6 const int BD_TURN_EDIT  = 0x0800; // editing mode
   7 const int BD_TURN_TYPE  = 0x0f00; // turn type mask
   8
   9 const int BD_SF_PLAYERMOVES = MINIG_SF_CUSTOM;
  10
  11 // 240 tiles...
  12 const int BD_LET_CNT = 12;
  13 const int BD_NUM_CNT = 12;
  14
  15 const int BD_TILE_SIZE = 12;
  16
  17 const int BD_TEAMS = 1;
  18
  19 .vector bd_dir;
  20
  21 .int bd_moves;
  22
  23 .int bd_tiletype;
  24 const int BD_TILE_DOZER = 1;
  25 const int BD_TILE_TARGET = 2;
  26 const int BD_TILE_BOULDER = 3;
  27 const int BD_TILE_BRICK1 = 4;
  28 const int BD_TILE_BRICK2 = 5;
  29 const int BD_TILE_BRICK3 = 6;
  30 const int BD_TILE_LAST = 6;
  31
  32 // find same game piece given its tile name
  33 entity bd_find_piece(entity minig, string tile, bool check_target)
  34 {
  35         entity e = world;
  36         while ( ( e = findentity(e,owner,minig) ) )
  37                 if ( e.classname == "minigame_board_piece" && e.netname == tile && ((check_target) ? e.bd_tiletype == BD_TILE_TARGET : e.bd_tiletype != BD_TILE_TARGET) )
  38                         return e;
  39         return world;
  40 }
  41
  42 // check if the tile name is valid (15x15 grid)
  43 bool bd_valid_tile(string tile)
  44 {
  45         if ( !tile )
  46                 return false;
  47         int number = minigame_tile_number(tile);
  48         int letter = minigame_tile_letter(tile);
  49         return 0 <= number && number < BD_NUM_CNT && 0 <= letter && letter < BD_LET_CNT;
  50 }
  51
  52 entity bd_find_dozer(entity minig)
  53 {
  54         entity e = world;
  55         while ( ( e = findentity(e,owner,minig) ) )
  56                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype == BD_TILE_DOZER )
  57                         return e;
  58         return world;
  59 }
  60
  61 void bd_check_winner(entity minig)
  62 {
  63         int total = 0, valid = 0;
  64         entity e = world;
  65         while ( ( e = findentity(e,owner,minig) ) )
  66                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype == BD_TILE_TARGET )
  67                 {
  68                         ++total;
  69                         if(bd_find_piece(minig, e.netname, false).bd_tiletype == BD_TILE_BOULDER)
  70                                 ++valid;
  71                 }
  72
  73         if(valid >= total)
  74         {
  75                 minig.minigame_flags = BD_TURN_WIN;
  76                 minigame_server_sendflags(minig,MINIG_SF_UPDATE);
  77         }
  78 }
  79
  80 void minigame_setup_randompiece(entity minigame, int ttype)
  81 {
  82         RandomSelection_Init();
  83         int i, j;
  84         for(i = 1; i < BD_LET_CNT - 1; ++i)
  85         for(j = 1; j < BD_NUM_CNT - 1; ++j)
  86         {
  87                 string pos = minigame_tile_buildname(i, j);
  88                 if(!bd_find_piece(minigame, pos, false))
  89                         RandomSelection_Add(world, 0, pos, 1, 1);
  90         }
  91
  92         entity piece = msle_spawn(minigame,"minigame_board_piece");
  93         piece.team = 1;
  94         piece.netname = strzone(RandomSelection_chosen_string);
  95         piece.bd_tiletype = ttype;
  96         minigame_server_sendflags(piece,MINIG_SF_ALL);
  97 }
  98
  99 void bd_setup_pieces(entity minigame)
 100 {
 101         // TODO!
 102         minigame_setup_randompiece(minigame, BD_TILE_DOZER);
 103         minigame_setup_randompiece(minigame, BD_TILE_TARGET);
 104         minigame_setup_randompiece(minigame, BD_TILE_BOULDER);
 105         minigame_setup_randompiece(minigame, BD_TILE_BRICK1);
 106         minigame_setup_randompiece(minigame, BD_TILE_BRICK2);
 107         minigame_setup_randompiece(minigame, BD_TILE_BRICK3);
 108         minigame_setup_randompiece(minigame, BD_TILE_BRICK1);
 109         minigame_setup_randompiece(minigame, BD_TILE_BRICK2);
 110         minigame_setup_randompiece(minigame, BD_TILE_BRICK3);
 111
 112         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 113 }
 114
 115 bool bd_move_dozer(entity minigame, entity dozer)
 116 {
 117         if(!dozer.bd_dir_x && !dozer.bd_dir_y)
 118                 return false; // nope!
 119
 120         int myx = minigame_tile_letter(dozer.netname);
 121         int myy = minigame_tile_number(dozer.netname);
 122
 123         myx += dozer.bd_dir_x;
 124         myy += dozer.bd_dir_y;
 125
 126         string newpos = minigame_tile_buildname(myx, myy);
 127         entity hit = bd_find_piece(minigame, newpos, false);
 128
 129         if(!bd_valid_tile(newpos))
 130                 return false;
 131
 132         if(hit)
 133         switch(hit.bd_tiletype)
 134         {
 135                 case BD_TILE_DOZER: // wtf, but let's do this incase
 136                 case BD_TILE_BRICK1:
 137                 case BD_TILE_BRICK2:
 138                 case BD_TILE_BRICK3: return false;
 139                 case BD_TILE_BOULDER:
 140                 {
 141                         string testpos;
 142                         int tx = minigame_tile_letter(hit.netname);
 143                         int ty = minigame_tile_number(hit.netname);
 144
 145                         tx += dozer.bd_dir_x;
 146                         ty += dozer.bd_dir_y;
 147
 148                         testpos = minigame_tile_buildname(tx, ty);
 149                         entity testhit = bd_find_piece(minigame, testpos, false);
 150
 151                         if(!bd_valid_tile(testpos) || testhit)
 152                                 return false;
 153
 154                         if(hit.netname) { strunzone(hit.netname); }
 155                         hit.netname = strzone(testpos);
 156                         minigame_server_sendflags(hit,MINIG_SF_UPDATE);
 157                         break;
 158                 }
 159         }
 160
 161         if(dozer.netname) { strunzone(dozer.netname); }
 162         dozer.netname = strzone(newpos);
 163
 164         return true;
 165 }
 166
 167 // make a move
 168 void bd_move(entity minigame, entity player, string dxs, string dys )
 169 {
 170         if ( minigame.minigame_flags & BD_TURN_MOVE )
 171         if ( dxs || dys )
 172         {
 173                 //if ( bd_valid_tile(pos) )
 174                 //if ( bd_find_piece(minigame, pos, false) )
 175                 {
 176                         entity dozer = bd_find_dozer(minigame);
 177                         if(!dozer)
 178                                 return; // should not happen... TODO: end match?
 179
 180                         int dx = ((dxs) ? bound(-1, stof(dxs), 1) : 0);
 181                         int dy = ((dys) ? bound(-1, stof(dys), 1) : 0);
 182
 183                         dozer.bd_dir_x = dx;
 184                         dozer.bd_dir_y = dy;
 185                         dozer.bd_dir_z = 0;
 186
 187                         if(bd_move_dozer(minigame, dozer))
 188                                 player.bd_moves++;
 189
 190                         bd_check_winner(minigame);
 191
 192                         minigame_server_sendflags(dozer,MINIG_SF_UPDATE); // update anyway
 193                         minigame_server_sendflags(player, BD_SF_PLAYERMOVES);
 194                         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 195                 }
 196         }
 197 }
 198
 199 void bd_reset_moves(entity minigame)
 200 {
 201         entity e;
 202 #ifdef SVQC
 203         for(e = minigame.minigame_players; e; e = e.list_next)
 204 #elif defined(CSQC)
 205         e = world;
 206         while( (e = findentity(e,owner,minigame)) )
 207                 if ( e.classname == "minigame_player" )
 208 #endif
 209                 {
 210                         e.bd_moves = 0;
 211                         minigame_server_sendflags(e,BD_SF_PLAYERMOVES);
 212                 }
 213 }
 214
 215 // request a new match
 216 void bd_restart_match(entity minigame, entity player)
 217 {
 218         minigame.minigame_flags = BD_TURN_MOVE;
 219         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 220         entity e = world;
 221         while ( ( e = findentity(e,owner,minigame) ) )
 222                 if ( e.classname == "minigame_board_piece" )
 223                         remove(e);
 224
 225         bd_setup_pieces(minigame);
 226
 227         bd_reset_moves(minigame);
 228 }
 229
 230 #ifdef SVQC
 231
 232 // required function, handle server side events
 233 int bd_server_event(entity minigame, string event, ...)
 234 {
 235         switch(event)
 236         {
 237                 case "start":
 238                 {
 239                         bd_setup_pieces(minigame);
 240                         minigame.minigame_flags = BD_TURN_MOVE;
 241
 242                         return true;
 243                 }
 244                 case "end":
 245                 {
 246                         entity e = world;
 247                         while( (e = findentity(e, owner, minigame)) )
 248                         if(e.classname == "minigame_board_piece")
 249                         {
 250                                 if(e.netname) { strunzone(e.netname); }
 251                                 remove(e);
 252                         }
 253                         return false;
 254                 }
 255                 case "join":
 256                 {
 257                         int pl_num = minigame_count_players(minigame);
 258
 259                         if(pl_num >= BD_TEAMS) { return false; }
 260
 261                         return 1;
 262                 }
 263                 case "cmd":
 264                 {
 265                         switch(argv(0))
 266                         {
 267                                 case "move":
 268                                         bd_move(minigame, ...(0,entity), ((...(1,int)) >= 2 ? argv(1) : string_null), ((...(1,int)) == 3 ? argv(2) : string_null));
 269                                         return true;
 270                                 case "next":
 271                                         bd_restart_match(minigame,...(0,entity));
 272                                         return true;
 273                                 case "restart":
 274                                         bd_restart_match(minigame,...(0,entity));
 275                                         return true;
 276                         }
 277
 278                         return false;
 279                 }
 280                 case "network_send":
 281                 {
 282                         entity sent = ...(0,entity);
 283                         int sf = ...(1,int);
 284                         if ( sent.classname == "minigame_board_piece" && (sf & MINIG_SF_UPDATE) )
 285                         {
 286                                 int letter = minigame_tile_letter(sent.netname);
 287                                 int number = minigame_tile_number(sent.netname);
 288
 289                                 WriteByte(MSG_ENTITY,letter);
 290                                 WriteByte(MSG_ENTITY,number);
 291
 292                                 WriteByte(MSG_ENTITY,sent.bd_tiletype);
 293
 294                                 int dx = sent.bd_dir_x;
 295                                 int dy = sent.bd_dir_y;
 296                                 if(dx == -1) dx = 2;
 297                                 if(dy == -1) dy = 2;
 298                                 WriteByte(MSG_ENTITY,dx);
 299                                 WriteByte(MSG_ENTITY,dy);
 300                         }
 301                         else if(sent.classname == "minigame_player" && (sf & BD_SF_PLAYERMOVES))
 302                                 WriteShort(MSG_ENTITY,sent.bd_moves);
 303                         return false;
 304                 }
 305         }
 306
 307         return false;
 308 }
 309
 310
 311 #elif defined(CSQC)
 312
 313 vector bd_boardpos; // HUD board position
 314 vector bd_boardsize;// HUD board size
 315
 316 // Required function, draw the game board
 317 void bd_hud_board(vector pos, vector mySize)
 318 {
 319         minigame_hud_fitsqare(pos, mySize);
 320         bd_boardpos = pos;
 321         bd_boardsize = mySize;
 322
 323         minigame_hud_simpleboard(pos,mySize,minigame_texture("bd/board"));
 324
 325         vector tile_size = minigame_hud_denormalize_size('1 1 0' / BD_TILE_SIZE,pos,mySize);
 326         vector tile_pos;
 327
 328         entity e;
 329         FOREACH_MINIGAME_ENTITY(e)
 330         {
 331                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype != BD_TILE_TARGET && e.bd_tiletype != BD_TILE_DOZER )
 332                 {
 333                         tile_pos = minigame_tile_pos(e.netname,BD_NUM_CNT,BD_LET_CNT);
 334                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 335
 336                         string thepiece = "bd/brick1";
 337                         switch(e.bd_tiletype)
 338                         {
 339                                 case BD_TILE_BOULDER: thepiece = "bd/boulder"; break;
 340                                 case BD_TILE_BRICK2: thepiece = "bd/brick2"; break;
 341                                 case BD_TILE_BRICK3: thepiece = "bd/brick3"; break;
 342                         }
 343
 344                         minigame_drawpic_centered( tile_pos,
 345                                         minigame_texture(thepiece),
 346                                         tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
 347                 }
 348
 349                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype == BD_TILE_TARGET && e.bd_tiletype != BD_TILE_DOZER )
 350                 {
 351                         tile_pos = minigame_tile_pos(e.netname,BD_NUM_CNT,BD_LET_CNT);
 352                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 353
 354                         minigame_drawpic_centered( tile_pos,
 355                                         minigame_texture("bd/target"),
 356                                         tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
 357                 }
 358
 359                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype != BD_TILE_TARGET && e.bd_tiletype == BD_TILE_DOZER )
 360                 {
 361                         tile_pos = minigame_tile_pos(e.netname,BD_NUM_CNT,BD_LET_CNT);
 362                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 363
 364                         vector thedir = e.bd_dir;
 365                         float theang = 0;
 366
 367                         if(thedir_y == -1) { theang = M_PI; }
 368                         if(thedir_x == 1) { theang = M_PI/2; }
 369                         if(thedir_x == -1) { theang = M_PI*3/2; }
 370
 371                         drawrotpic(tile_pos, theang, minigame_texture("bd/dozer"),
 372                                                 tile_size, tile_size/2, '1 1 1',
 373                                                 panel_fg_alpha, DRAWFLAG_NORMAL );
 374                 }
 375         }
 376
 377         FOREACH_MINIGAME_ENTITY(e)
 378         {
 379                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype == BD_TILE_TARGET )
 380                 {
 381                         tile_pos = minigame_tile_pos(e.netname,BD_NUM_CNT,BD_LET_CNT);
 382                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 383
 384                         minigame_drawpic_centered( tile_pos,
 385                                         minigame_texture("bd/target"),
 386                                         tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
 387                 }
 388         }
 389
 390         FOREACH_MINIGAME_ENTITY(e)
 391         {
 392                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype == BD_TILE_DOZER )
 393                 {
 394                         tile_pos = minigame_tile_pos(e.netname,BD_NUM_CNT,BD_LET_CNT);
 395                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 396
 397                         vector thedir = e.bd_dir;
 398                         float theang = 0;
 399
 400                         if(thedir_y == -1) { theang = M_PI; }
 401                         if(thedir_x == 1) { theang = M_PI/2; }
 402                         if(thedir_x == -1) { theang = M_PI*3/2; }
 403
 404                         drawrotpic(tile_pos, theang, minigame_texture("bd/dozer"),
 405                                                 tile_size, tile_size/2, '1 1 1',
 406                                                 panel_fg_alpha, DRAWFLAG_NORMAL );
 407                 }
 408         }
 409
 410         if ( (active_minigame.minigame_flags & BD_TURN_LOSS) || (active_minigame.minigame_flags & BD_TURN_WIN) )
 411         {
 412                 vector winfs = hud_fontsize*2;
 413                 string victory_text = "Game over!";
 414
 415                 if(active_minigame.minigame_flags & BD_TURN_WIN)
 416                         victory_text = "You win!";
 417
 418                 vector win_pos = pos+eY*(mySize_y-winfs_y)/2;
 419                 vector win_sz;
 420                 win_sz = minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
 421                         sprintf("%s", victory_text),
 422                         winfs, 0, DRAWFLAG_NORMAL, 0.5);
 423
 424                 drawfill(win_pos-eY*hud_fontsize_y,win_sz+2*eY*hud_fontsize_y,'0.3 0.3 1',0.8,DRAWFLAG_ADDITIVE);
 425
 426                 minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
 427                         sprintf("%s", victory_text),
 428                         winfs, panel_fg_alpha, DRAWFLAG_NORMAL, 0.5);
 429         }
 430 }
 431
 432
 433 // Required function, draw the game status panel
 434 void bd_hud_status(vector pos, vector mySize)
 435 {
 436         HUD_Panel_DrawBg(1);
 437         vector ts;
 438         ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
 439                 hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
 440
 441         pos_y += ts_y;
 442         mySize_y -= ts_y;
 443
 444         vector player_fontsize = hud_fontsize * 1.75;
 445         ts_y = ( mySize_y - 2*player_fontsize_y ) / BD_TEAMS;
 446         ts_x = mySize_x;
 447         vector mypos;
 448         vector tile_size = '48 48 0';
 449
 450         mypos = pos;
 451         drawfill(mypos,eX*mySize_x+eY*player_fontsize_y,'1 1 1',0.5,DRAWFLAG_ADDITIVE);
 452         mypos_y += player_fontsize_y;
 453         drawfill(mypos,eX*mySize_x+eY*tile_size_y,'1 1 1',0.25,DRAWFLAG_ADDITIVE);
 454
 455         entity e;
 456         FOREACH_MINIGAME_ENTITY(e)
 457         {
 458                 if ( e.classname == "minigame_player" )
 459                 {
 460                         mypos = pos;
 461                         minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
 462                                 GetPlayerName(e.minigame_playerslot-1),
 463                                 player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
 464
 465                         mypos_y += player_fontsize_y;
 466                         drawpic( mypos,
 467                                         minigame_texture("bd/dozer"),
 468                                         tile_size * 0.7, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
 469
 470                         mypos_x += tile_size_x;
 471
 472                         drawstring(mypos,ftos(e.bd_moves),tile_size,
 473                                            '0.7 0.84 1', panel_fg_alpha, DRAWFLAG_NORMAL);
 474                 }
 475         }
 476 }
 477
 478 // Turn a set of flags into a help message
 479 string bd_turn_to_string(int turnflags)
 480 {
 481         if ( turnflags & BD_TURN_LOSS )
 482                 return _("Better luck next time!");
 483
 484         if ( turnflags & BD_TURN_WIN )
 485                 if(random() > 0.5)
 486                         return _("Tubular!");
 487                 else
 488                         return _("Wicked!");
 489
 490         if ( turnflags & BD_TURN_MOVE )
 491                 return _("Push the boulders onto the targets");
 492
 493         return "";
 494 }
 495
 496 // Make the correct move
 497 void bd_make_move(entity minigame, int dx, int dy)
 498 {
 499         if ( minigame.minigame_flags == BD_TURN_MOVE )
 500         {
 501                 minigame_cmd("move ",ftos(dx), " ", ftos(dy));
 502         }
 503 }
 504
 505 // Required function, handle client events
 506 int bd_client_event(entity minigame, string event, ...)
 507 {
 508         switch(event)
 509         {
 510                 case "activate":
 511                 {
 512                         minigame.message = bd_turn_to_string(minigame.minigame_flags);
 513                         return false;
 514                 }
 515                 case "key_pressed":
 516                 {
 517                         if(minigame.minigame_flags & BD_TURN_MOVE)
 518                         {
 519                                 switch ( ...(0,int) )
 520                                 {
 521                                         case K_RIGHTARROW:
 522                                         case K_KP_RIGHTARROW:
 523                                                 bd_make_move(minigame, 1, 0);
 524                                                 return true;
 525                                         case K_LEFTARROW:
 526                                         case K_KP_LEFTARROW:
 527                                                 bd_make_move(minigame, -1, 0);
 528                                                 return true;
 529                                         case K_UPARROW:
 530                                         case K_KP_UPARROW:
 531                                                 bd_make_move(minigame, 0, 1);
 532                                                 return true;
 533                                         case K_DOWNARROW:
 534                                         case K_KP_DOWNARROW:
 535                                                 bd_make_move(minigame, 0, -1);
 536                                                 return true;
 537                                 }
 538                         }
 539
 540                         return false;
 541                 }
 542                 case "network_receive":
 543                 {
 544                         entity sent = ...(0,entity);
 545                         int sf = ...(1,int);
 546                         if ( sent.classname == "minigame" )
 547                         {
 548                                 if ( sf & MINIG_SF_UPDATE )
 549                                 {
 550                                         sent.message = bd_turn_to_string(sent.minigame_flags);
 551                                         //if ( sent.minigame_flags & minigame_self.team )
 552                                                 minigame_prompt();
 553                                 }
 554                         }
 555                         else if(sent.classname == "minigame_board_piece")
 556                         {
 557                                 if(sf & MINIG_SF_UPDATE)
 558                                 {
 559                                         int letter = ReadByte();
 560                                         int number = ReadByte();
 561                                         if(sent.netname) { strunzone(sent.netname); }
 562                                         sent.netname = strzone(minigame_tile_buildname(letter, number));
 563
 564                                         sent.bd_tiletype = ReadByte();
 565
 566                                         int dx = ReadByte();
 567                                         int dy = ReadByte();
 568
 569                                         if(dx == 2) dx = -1;
 570                                         if(dy == 2) dy = -1;
 571
 572                                         sent.bd_dir_x = dx;
 573                                         sent.bd_dir_y = dy;
 574                                         sent.bd_dir_z = 0;
 575                                 }
 576                         }
 577                         else if(sent.classname == "minigame_player" && (sf & BD_SF_PLAYERMOVES))
 578                                 sent.bd_moves = ReadShort(); // make this a byte when possible
 579
 580                         return false;
 581                 }
 582                 case "menu_show":
 583                 {
 584                         HUD_MinigameMenu_CustomEntry(...(0,entity),_("Next Match"),"next");
 585                         HUD_MinigameMenu_CustomEntry(...(0,entity),_("Restart"),"restart");
 586                         return false;
 587                 }
 588                 case "menu_click":
 589                 {
 590                         if(...(0,string) == "next")
 591                                 minigame_cmd("next");
 592                         if(...(0,string) == "restart")
 593                                 minigame_cmd("restart");
 594                         return false;
 595                 }
 596         }
 597
 598         return false;
 599 }
 600
 601 #endif