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) && !bd_find_piece(minigame, pos, true))
  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 dir )
 169 {
 170         if ( minigame.minigame_flags & BD_TURN_MOVE )
 171         if ( dir )
 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 dxs = 0, dys = 0;
 181                         string thedir = strtolower(dir);
 182                         if(thedir == "up" || thedir == "u") { dxs = 0; dys = 1; }
 183                         if(thedir == "down" || thedir == "dn" || thedir == "d") { dxs = 0; dys = -1; }
 184                         if(thedir == "left" || thedir == "lt" || thedir == "l") { dxs = -1; dys = 0; }
 185                         if(thedir == "right" || thedir == "rt" || thedir == "r") { dxs = 1; dys = 0; }
 186
 187                         int dx = bound(-1, dxs, 1);
 188                         int dy = bound(-1, dys, 1);
 189
 190                         dozer.bd_dir_x = dx;
 191                         dozer.bd_dir_y = dy;
 192                         dozer.bd_dir_z = 0;
 193
 194                         if(bd_move_dozer(minigame, dozer))
 195                                 player.bd_moves++;
 196
 197                         bd_check_winner(minigame);
 198
 199                         minigame_server_sendflags(dozer,MINIG_SF_UPDATE); // update anyway
 200                         minigame_server_sendflags(player, BD_SF_PLAYERMOVES);
 201                         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 202                 }
 203         }
 204 }
 205
 206 void bd_reset_moves(entity minigame)
 207 {
 208         entity e;
 209 #ifdef SVQC
 210         for(e = minigame.minigame_players; e; e = e.list_next)
 211 #elif defined(CSQC)
 212         e = world;
 213         while( (e = findentity(e,owner,minigame)) )
 214                 if ( e.classname == "minigame_player" )
 215 #endif
 216                 {
 217                         e.bd_moves = 0;
 218                         minigame_server_sendflags(e,BD_SF_PLAYERMOVES);
 219                 }
 220 }
 221
 222 // request a new match
 223 void bd_restart_match(entity minigame, entity player)
 224 {
 225         minigame.minigame_flags = BD_TURN_MOVE;
 226         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 227         entity e = world;
 228         while ( ( e = findentity(e,owner,minigame) ) )
 229                 if ( e.classname == "minigame_board_piece" )
 230                         remove(e);
 231
 232         bd_setup_pieces(minigame);
 233
 234         bd_reset_moves(minigame);
 235 }
 236
 237 #ifdef SVQC
 238
 239 // required function, handle server side events
 240 int bd_server_event(entity minigame, string event, ...)
 241 {
 242         switch(event)
 243         {
 244                 case "start":
 245                 {
 246                         bd_setup_pieces(minigame);
 247                         minigame.minigame_flags = BD_TURN_MOVE;
 248
 249                         return true;
 250                 }
 251                 case "end":
 252                 {
 253                         entity e = world;
 254                         while( (e = findentity(e, owner, minigame)) )
 255                         if(e.classname == "minigame_board_piece")
 256                         {
 257                                 if(e.netname) { strunzone(e.netname); }
 258                                 remove(e);
 259                         }
 260                         return false;
 261                 }
 262                 case "join":
 263                 {
 264                         int pl_num = minigame_count_players(minigame);
 265
 266                         if(pl_num >= BD_TEAMS) { return false; }
 267
 268                         return 1;
 269                 }
 270                 case "cmd":
 271                 {
 272                         switch(argv(0))
 273                         {
 274                                 case "move":
 275                                         bd_move(minigame, ...(0,entity), ((...(1,int)) >= 2 ? argv(1) : string_null));
 276                                         return true;
 277                                 case "next":
 278                                         bd_restart_match(minigame,...(0,entity));
 279                                         return true;
 280                                 case "restart":
 281                                         bd_restart_match(minigame,...(0,entity));
 282                                         return true;
 283                         }
 284
 285                         return false;
 286                 }
 287                 case "network_send":
 288                 {
 289                         entity sent = ...(0,entity);
 290                         int sf = ...(1,int);
 291                         if ( sent.classname == "minigame_board_piece" && (sf & MINIG_SF_UPDATE) )
 292                         {
 293                                 int letter = minigame_tile_letter(sent.netname);
 294                                 int number = minigame_tile_number(sent.netname);
 295
 296                                 WriteByte(MSG_ENTITY,letter);
 297                                 WriteByte(MSG_ENTITY,number);
 298
 299                                 WriteByte(MSG_ENTITY,sent.bd_tiletype);
 300
 301                                 int dx = sent.bd_dir_x;
 302                                 int dy = sent.bd_dir_y;
 303                                 if(dx == -1) dx = 2;
 304                                 if(dy == -1) dy = 2;
 305                                 WriteByte(MSG_ENTITY,dx);
 306                                 WriteByte(MSG_ENTITY,dy);
 307                         }
 308                         else if(sent.classname == "minigame_player" && (sf & BD_SF_PLAYERMOVES))
 309                                 WriteShort(MSG_ENTITY,sent.bd_moves);
 310                         return false;
 311                 }
 312         }
 313
 314         return false;
 315 }
 316
 317
 318 #elif defined(CSQC)
 319
 320 vector bd_boardpos; // HUD board position
 321 vector bd_boardsize;// HUD board size
 322
 323 // Required function, draw the game board
 324 void bd_hud_board(vector pos, vector mySize)
 325 {
 326         minigame_hud_fitsqare(pos, mySize);
 327         bd_boardpos = pos;
 328         bd_boardsize = mySize;
 329
 330         minigame_hud_simpleboard(pos,mySize,minigame_texture("bd/board"));
 331
 332         vector tile_size = minigame_hud_denormalize_size('1 1 0' / BD_TILE_SIZE,pos,mySize);
 333         vector tile_pos;
 334
 335         entity e;
 336         FOREACH_MINIGAME_ENTITY(e)
 337         {
 338                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype != BD_TILE_TARGET && e.bd_tiletype != BD_TILE_DOZER )
 339                 {
 340                         tile_pos = minigame_tile_pos(e.netname,BD_NUM_CNT,BD_LET_CNT);
 341                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 342
 343                         string thepiece = "bd/brick1";
 344                         switch(e.bd_tiletype)
 345                         {
 346                                 case BD_TILE_BOULDER: thepiece = "bd/boulder"; break;
 347                                 case BD_TILE_BRICK2: thepiece = "bd/brick2"; break;
 348                                 case BD_TILE_BRICK3: thepiece = "bd/brick3"; break;
 349                         }
 350
 351                         minigame_drawpic_centered( tile_pos,
 352                                         minigame_texture(thepiece),
 353                                         tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
 354                 }
 355
 356                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype == BD_TILE_TARGET && e.bd_tiletype != BD_TILE_DOZER )
 357                 {
 358                         tile_pos = minigame_tile_pos(e.netname,BD_NUM_CNT,BD_LET_CNT);
 359                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 360
 361                         minigame_drawpic_centered( tile_pos,
 362                                         minigame_texture("bd/target"),
 363                                         tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
 364                 }
 365
 366                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype != BD_TILE_TARGET && e.bd_tiletype == BD_TILE_DOZER )
 367                 {
 368                         tile_pos = minigame_tile_pos(e.netname,BD_NUM_CNT,BD_LET_CNT);
 369                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 370
 371                         vector thedir = e.bd_dir;
 372                         float theang = 0;
 373
 374                         if(thedir_y == -1) { theang = M_PI; }
 375                         if(thedir_x == 1) { theang = M_PI/2; }
 376                         if(thedir_x == -1) { theang = M_PI*3/2; }
 377
 378                         drawrotpic(tile_pos, theang, minigame_texture("bd/dozer"),
 379                                                 tile_size, tile_size/2, '1 1 1',
 380                                                 panel_fg_alpha, DRAWFLAG_NORMAL );
 381                 }
 382         }
 383
 384         FOREACH_MINIGAME_ENTITY(e)
 385         {
 386                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype == BD_TILE_TARGET )
 387                 {
 388                         tile_pos = minigame_tile_pos(e.netname,BD_NUM_CNT,BD_LET_CNT);
 389                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 390
 391                         minigame_drawpic_centered( tile_pos,
 392                                         minigame_texture("bd/target"),
 393                                         tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
 394                 }
 395         }
 396
 397         FOREACH_MINIGAME_ENTITY(e)
 398         {
 399                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype == BD_TILE_DOZER )
 400                 {
 401                         tile_pos = minigame_tile_pos(e.netname,BD_NUM_CNT,BD_LET_CNT);
 402                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 403
 404                         vector thedir = e.bd_dir;
 405                         float theang = 0;
 406
 407                         if(thedir_y == -1) { theang = M_PI; }
 408                         if(thedir_x == 1) { theang = M_PI/2; }
 409                         if(thedir_x == -1) { theang = M_PI*3/2; }
 410
 411                         drawrotpic(tile_pos, theang, minigame_texture("bd/dozer"),
 412                                                 tile_size, tile_size/2, '1 1 1',
 413                                                 panel_fg_alpha, DRAWFLAG_NORMAL );
 414                 }
 415         }
 416
 417         if ( (active_minigame.minigame_flags & BD_TURN_LOSS) || (active_minigame.minigame_flags & BD_TURN_WIN) )
 418         {
 419                 vector winfs = hud_fontsize*2;
 420                 string victory_text = "Game over!";
 421
 422                 if(active_minigame.minigame_flags & BD_TURN_WIN)
 423                         victory_text = "You win!";
 424
 425                 vector win_pos = pos+eY*(mySize_y-winfs_y)/2;
 426                 vector win_sz;
 427                 win_sz = minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
 428                         sprintf("%s", victory_text),
 429                         winfs, 0, DRAWFLAG_NORMAL, 0.5);
 430
 431                 drawfill(win_pos-eY*hud_fontsize_y,win_sz+2*eY*hud_fontsize_y,'0.3 0.3 1',0.8,DRAWFLAG_ADDITIVE);
 432
 433                 minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
 434                         sprintf("%s", victory_text),
 435                         winfs, panel_fg_alpha, DRAWFLAG_NORMAL, 0.5);
 436         }
 437 }
 438
 439
 440 // Required function, draw the game status panel
 441 void bd_hud_status(vector pos, vector mySize)
 442 {
 443         HUD_Panel_DrawBg(1);
 444         vector ts;
 445         ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
 446                 hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
 447
 448         pos_y += ts_y;
 449         mySize_y -= ts_y;
 450
 451         vector player_fontsize = hud_fontsize * 1.75;
 452         ts_y = ( mySize_y - 2*player_fontsize_y ) / BD_TEAMS;
 453         ts_x = mySize_x;
 454         vector mypos;
 455         vector tile_size = '48 48 0';
 456
 457         mypos = pos;
 458         drawfill(mypos,eX*mySize_x+eY*player_fontsize_y,'1 1 1',0.5,DRAWFLAG_ADDITIVE);
 459         mypos_y += player_fontsize_y;
 460         drawfill(mypos,eX*mySize_x+eY*tile_size_y,'1 1 1',0.25,DRAWFLAG_ADDITIVE);
 461
 462         entity e;
 463         FOREACH_MINIGAME_ENTITY(e)
 464         {
 465                 if ( e.classname == "minigame_player" )
 466                 {
 467                         mypos = pos;
 468                         minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
 469                                 GetPlayerName(e.minigame_playerslot-1),
 470                                 player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
 471
 472                         mypos_y += player_fontsize_y;
 473                         drawpic( mypos,
 474                                         minigame_texture("bd/dozer"),
 475                                         tile_size * 0.7, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
 476
 477                         mypos_x += tile_size_x;
 478
 479                         drawstring(mypos,ftos(e.bd_moves),tile_size,
 480                                            '0.7 0.84 1', panel_fg_alpha, DRAWFLAG_NORMAL);
 481                 }
 482         }
 483 }
 484
 485 // Turn a set of flags into a help message
 486 string bd_turn_to_string(int turnflags)
 487 {
 488         if ( turnflags & BD_TURN_LOSS )
 489                 return _("Better luck next time!");
 490
 491         if ( turnflags & BD_TURN_WIN )
 492                 if(random() > 0.5)
 493                         return _("Tubular!");
 494                 else
 495                         return _("Wicked!");
 496
 497         if ( turnflags & BD_TURN_MOVE )
 498                 return _("Push the boulders onto the targets");
 499
 500         return "";
 501 }
 502
 503 // Make the correct move
 504 void bd_make_move(entity minigame, string dir)
 505 {
 506         if ( minigame.minigame_flags == BD_TURN_MOVE )
 507         {
 508                 minigame_cmd("move ", dir);
 509         }
 510 }
 511
 512 // Required function, handle client events
 513 int bd_client_event(entity minigame, string event, ...)
 514 {
 515         switch(event)
 516         {
 517                 case "activate":
 518                 {
 519                         minigame.message = bd_turn_to_string(minigame.minigame_flags);
 520                         return false;
 521                 }
 522                 case "key_pressed":
 523                 {
 524                         if(minigame.minigame_flags & BD_TURN_MOVE)
 525                         {
 526                                 switch ( ...(0,int) )
 527                                 {
 528                                         case K_RIGHTARROW:
 529                                         case K_KP_RIGHTARROW:
 530                                                 bd_make_move(minigame, "r");
 531                                                 return true;
 532                                         case K_LEFTARROW:
 533                                         case K_KP_LEFTARROW:
 534                                                 bd_make_move(minigame, "l");
 535                                                 return true;
 536                                         case K_UPARROW:
 537                                         case K_KP_UPARROW:
 538                                                 bd_make_move(minigame, "u");
 539                                                 return true;
 540                                         case K_DOWNARROW:
 541                                         case K_KP_DOWNARROW:
 542                                                 bd_make_move(minigame, "d");
 543                                                 return true;
 544                                 }
 545                         }
 546
 547                         return false;
 548                 }
 549                 case "network_receive":
 550                 {
 551                         entity sent = ...(0,entity);
 552                         int sf = ...(1,int);
 553                         if ( sent.classname == "minigame" )
 554                         {
 555                                 if ( sf & MINIG_SF_UPDATE )
 556                                 {
 557                                         sent.message = bd_turn_to_string(sent.minigame_flags);
 558                                         //if ( sent.minigame_flags & minigame_self.team )
 559                                                 minigame_prompt();
 560                                 }
 561                         }
 562                         else if(sent.classname == "minigame_board_piece")
 563                         {
 564                                 if(sf & MINIG_SF_UPDATE)
 565                                 {
 566                                         int letter = ReadByte();
 567                                         int number = ReadByte();
 568                                         if(sent.netname) { strunzone(sent.netname); }
 569                                         sent.netname = strzone(minigame_tile_buildname(letter, number));
 570
 571                                         sent.bd_tiletype = ReadByte();
 572
 573                                         int dx = ReadByte();
 574                                         int dy = ReadByte();
 575
 576                                         if(dx == 2) dx = -1;
 577                                         if(dy == 2) dy = -1;
 578
 579                                         sent.bd_dir_x = dx;
 580                                         sent.bd_dir_y = dy;
 581                                         sent.bd_dir_z = 0;
 582                                 }
 583                         }
 584                         else if(sent.classname == "minigame_player" && (sf & BD_SF_PLAYERMOVES))
 585                                 sent.bd_moves = ReadShort(); // make this a byte when possible
 586
 587                         return false;
 588                 }
 589                 case "menu_show":
 590                 {
 591                         HUD_MinigameMenu_CustomEntry(...(0,entity),_("Next Match"),"next");
 592                         HUD_MinigameMenu_CustomEntry(...(0,entity),_("Restart"),"restart");
 593                         return false;
 594                 }
 595                 case "menu_click":
 596                 {
 597                         if(...(0,string) == "next")
 598                                 minigame_cmd("next");
 599                         if(...(0,string) == "restart")
 600                                 minigame_cmd("restart");
 601                         return false;
 602                 }
 603         }
 604
 605         return false;
 606 }
 607
 608 #endif