qcsrc/common/minigames/minigame/bd.qc

   1 #include "bd.qh"
   2 REGISTER_MINIGAME(bd, "Bulldozer");
   3
   4 const int BD_TURN_MOVE  = 0x0100; // player must move the bulldozer
   5 const int BD_TURN_WIN   = 0x0200; // victory
   6 const int BD_TURN_LOSS  = 0x0400; // they did it?!
   7 const int BD_TURN_EDIT  = 0x0800; // editing mode
   8 const int BD_TURN_TYPE  = 0x0f00; // turn type mask
   9
  10 const int BD_SF_PLAYERMOVES = MINIG_SF_CUSTOM;
  11
  12 // 240 tiles...
  13 const int BD_LET_CNT = 20;
  14 const int BD_NUM_CNT = 20;
  15
  16 const int BD_TILE_SIZE = 20;
  17
  18 const int BD_TEAMS = 1;
  19
  20 .int bd_dir;
  21
  22 .int bd_moves;
  23
  24 .string bd_levelname;
  25 .string bd_nextlevel;
  26
  27 #ifdef SVQC
  28 .bool bd_canedit;
  29 #endif
  30
  31 .int bd_tiletype;
  32 const int BD_TILE_DOZER = 1;
  33 const int BD_TILE_TARGET = 2;
  34 const int BD_TILE_BOULDER = 3;
  35 const int BD_TILE_BRICK1 = 4;
  36 const int BD_TILE_BRICK2 = 5;
  37 const int BD_TILE_BRICK3 = 6;
  38 const int BD_TILE_BRICK4 = 7;
  39 const int BD_TILE_BRICK5 = 8;
  40 const int BD_TILE_BRICK6 = 9;
  41 const int BD_TILE_BRICK7 = 10;
  42 const int BD_TILE_BRICK8 = 11;
  43 const int BD_TILE_LAST = 11;
  44
  45 const int BD_DIR_UP = 0;
  46 const int BD_DIR_DN = 1;
  47 const int BD_DIR_LF = 2;
  48 const int BD_DIR_RT = 3;
  49
  50 #ifdef SVQC
  51 string autocvar_sv_minigames_bulldozer_startlevel = "level1";
  52 #endif
  53
  54 // find same game piece given its tile name
  55 entity bd_find_piece(entity minig, string tile, bool check_target)
  56 {
  57         entity e = NULL;
  58         while ( ( e = findentity(e,owner,minig) ) )
  59                 if ( e.classname == "minigame_board_piece" && e.netname == tile && ((check_target) ? e.bd_tiletype == BD_TILE_TARGET : e.bd_tiletype != BD_TILE_TARGET) )
  60                         return e;
  61         return NULL;
  62 }
  63
  64 // check if the tile name is valid (15x15 grid)
  65 bool bd_valid_tile(string tile)
  66 {
  67         if ( !tile )
  68                 return false;
  69         int number = minigame_tile_number(tile);
  70         int letter = minigame_tile_letter(tile);
  71         return 0 <= number && number < BD_NUM_CNT && 0 <= letter && letter < BD_LET_CNT;
  72 }
  73
  74 entity bd_find_dozer(entity minig)
  75 {
  76         entity e = NULL;
  77         while ( ( e = findentity(e,owner,minig) ) )
  78                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype == BD_TILE_DOZER )
  79                         return e;
  80         return NULL;
  81 }
  82
  83 void bd_check_winner(entity minig)
  84 {
  85         int total = 0, valid = 0;
  86         entity e = NULL;
  87         while ( ( e = findentity(e,owner,minig) ) )
  88                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype == BD_TILE_TARGET )
  89                 {
  90                         ++total;
  91                         if(bd_find_piece(minig, e.netname, false).bd_tiletype == BD_TILE_BOULDER)
  92                                 ++valid;
  93                 }
  94
  95         if(valid >= total)
  96         {
  97                 minig.minigame_flags = BD_TURN_WIN;
  98                 minigame_server_sendflags(minig,MINIG_SF_UPDATE);
  99         }
 100 }
 101
 102 vector bd_get_dir(int bdir)
 103 {
 104         switch(bdir)
 105         {
 106                 case BD_DIR_UP: return '0 1 0'; // up
 107                 default:
 108                 case BD_DIR_DN: return '0 -1 0'; // down
 109                 case BD_DIR_LF: return '-1 0 0'; // left
 110                 case BD_DIR_RT: return '1 0 0'; // right
 111         }
 112 }
 113
 114 string bd_get_dir_name(int bdir)
 115 {
 116         switch(bdir)
 117         {
 118                 case BD_DIR_UP: return "u"; // up
 119                 default:
 120                 case BD_DIR_DN: return "d"; // down
 121                 case BD_DIR_LF: return "l"; // left
 122                 case BD_DIR_RT: return "r"; // right
 123         }
 124 }
 125
 126 int bd_dir_fromname(string bdir)
 127 {
 128         if(bdir == "up" || bdir == "u")
 129                 return BD_DIR_UP; // up
 130         if(bdir == "down" || bdir == "dn" || bdir == "d")
 131                 return BD_DIR_DN; /// down
 132         if(bdir == "left" || bdir == "lt" || bdir == "l")
 133                 return BD_DIR_LF; // left
 134         if(bdir == "right" || bdir == "rt" || bdir == "r")
 135                 return BD_DIR_RT; // right
 136
 137         return BD_DIR_DN; // down
 138 }
 139
 140 bool bd_canfill(int ttype)
 141 {
 142         switch(ttype)
 143         {
 144                 case BD_TILE_BRICK8:
 145                 case BD_TILE_BRICK7:
 146                 case BD_TILE_BRICK6:
 147                 case BD_TILE_BRICK5:
 148                 case BD_TILE_BRICK4:
 149                 case BD_TILE_BRICK3:
 150                 case BD_TILE_BRICK2:
 151                 case BD_TILE_BRICK1: return true;
 152         }
 153
 154         return false;
 155 }
 156
 157 bool bd_move_dozer(entity minigame, entity dozer)
 158 {
 159         //if(!dozer.bd_dir)
 160                 //return false; // nope!
 161
 162         int myx = minigame_tile_letter(dozer.netname);
 163         int myy = minigame_tile_number(dozer.netname);
 164
 165         vector dir = bd_get_dir(dozer.bd_dir);
 166
 167         myx += dir.x;
 168         myy += dir.y;
 169
 170         string newpos = minigame_tile_buildname(myx, myy);
 171         entity hit = bd_find_piece(minigame, newpos, false);
 172
 173         if(!bd_valid_tile(newpos))
 174                 return false;
 175
 176         if(hit)
 177         switch(hit.bd_tiletype)
 178         {
 179                 case BD_TILE_DOZER: // wtf, but let's do this incase
 180                 case BD_TILE_BRICK8:
 181                 case BD_TILE_BRICK7:
 182                 case BD_TILE_BRICK6:
 183                 case BD_TILE_BRICK5:
 184                 case BD_TILE_BRICK4:
 185                 case BD_TILE_BRICK3:
 186                 case BD_TILE_BRICK2:
 187                 case BD_TILE_BRICK1: return false;
 188                 case BD_TILE_BOULDER:
 189                 {
 190                         string testpos;
 191                         int tx = minigame_tile_letter(hit.netname);
 192                         int ty = minigame_tile_number(hit.netname);
 193
 194                         tx += dir.x;
 195                         ty += dir.y;
 196
 197                         testpos = minigame_tile_buildname(tx, ty);
 198                         entity testhit = bd_find_piece(minigame, testpos, false);
 199
 200                         if(!bd_valid_tile(testpos) || testhit)
 201                                 return false;
 202
 203                         if(hit.netname) { strunzone(hit.netname); }
 204                         hit.netname = strzone(testpos);
 205                         minigame_server_sendflags(hit,MINIG_SF_UPDATE);
 206                         break;
 207                 }
 208         }
 209
 210         if(dozer.netname) { strunzone(dozer.netname); }
 211         dozer.netname = strzone(newpos);
 212
 213         return true;
 214 }
 215
 216 // make a move
 217 void bd_move(entity minigame, entity player, string dir)
 218 {
 219         if ( minigame.minigame_flags & BD_TURN_MOVE )
 220         if ( dir )
 221         {
 222                 //if ( bd_valid_tile(pos) )
 223                 //if ( bd_find_piece(minigame, pos, false) )
 224                 {
 225                         entity dozer = bd_find_dozer(minigame);
 226                         if(!dozer)
 227                         {
 228                                 LOG_INFO("Dozer wasn't found!\n");
 229                                 return; // should not happen... TODO: end match?
 230                         }
 231
 232                         string thedir = strtolower(dir);
 233                         int bdir = bd_dir_fromname(thedir);
 234
 235                         int moved = 0;
 236                         entity e = NULL;
 237                         while ( ( e = findentity(e,owner,minigame) ) )
 238                                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype == BD_TILE_DOZER )
 239                                 {
 240                                         e.bd_dir = bdir;
 241
 242                                         if(bd_move_dozer(minigame, e))
 243                                                 ++moved;
 244
 245                                         minigame_server_sendflags(e,MINIG_SF_UPDATE); // update anyway
 246                                 }
 247
 248                         if(moved)
 249                                 player.bd_moves++;
 250
 251                         bd_check_winner(minigame);
 252
 253                         minigame_server_sendflags(player,BD_SF_PLAYERMOVES);
 254                         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 255                 }
 256         }
 257 }
 258
 259 // editor
 260 void bd_editor_place(entity minigame, entity player, string pos, int thetile, string thedir)
 261 {
 262         if ( minigame.minigame_flags & BD_TURN_EDIT )
 263         if ( pos && thetile )
 264         {
 265                 if ( bd_valid_tile(pos) )
 266                 {
 267                         entity found_piece = bd_find_piece(minigame, pos, false);
 268                         entity targ = bd_find_piece(minigame, pos, true);
 269
 270                         if(found_piece.bd_tiletype == BD_TILE_DOZER && thedir != "")
 271                         {
 272                                 string newdir = strtolower(thedir);
 273                                 int bdir = bd_dir_fromname(newdir);
 274
 275                                 found_piece.bd_dir = bdir;
 276                                 minigame_server_sendflags(found_piece,MINIG_SF_UPDATE); // update anyway
 277                                 return;
 278                         }
 279
 280                         //entity dozer = bd_find_dozer(minigame);
 281                         //if(dozer && thetile == BD_TILE_DOZER && pos != dozer.netname)
 282                                 //return; // nice try
 283
 284                         if(found_piece || (targ && thetile != BD_TILE_BOULDER))
 285                         {
 286                                 entity piece = bd_find_piece(minigame, pos, false);
 287                                 if(!piece) piece = bd_find_piece(minigame, pos, true);
 288                                 if(!piece)
 289                                         return; // how?!
 290
 291                                 if(piece.netname) { strunzone(piece.netname); }
 292                                 delete(piece);
 293                                 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 294                                 return;
 295                         }
 296
 297                         entity piece = msle_spawn(minigame,"minigame_board_piece");
 298                         piece.team = 1;
 299                         piece.netname = strzone(pos);
 300                         piece.bd_tiletype = thetile;
 301                         piece.bd_dir = 0;
 302                         minigame_server_sendflags(piece,MINIG_SF_UPDATE);
 303
 304                         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 305                 }
 306         }
 307 }
 308
 309 void bd_do_move(entity minigame, entity player, string dir, string thetile, string thedir)
 310 {
 311         if(minigame.minigame_flags & BD_TURN_MOVE)
 312                 bd_move(minigame, player, dir);
 313
 314         if(minigame.minigame_flags & BD_TURN_EDIT)
 315                 bd_editor_place(minigame, player, dir, stof(thetile), thedir);
 316 }
 317
 318 void bd_fill_recurse(entity minigame, entity player, int thetype, int letter, int number)
 319 {
 320         string pos = minigame_tile_buildname(letter,number);
 321         if(!bd_valid_tile(pos))
 322                 return;
 323         if(bd_find_piece(minigame, pos, false) || bd_find_piece(minigame, pos, true))
 324                 return;
 325
 326         bd_editor_place(minigame, player, pos, thetype, "");
 327
 328         bd_fill_recurse(minigame, player, thetype, letter - 1, number);
 329         bd_fill_recurse(minigame, player, thetype, letter + 1, number);
 330         bd_fill_recurse(minigame, player, thetype, letter, number - 1);
 331         bd_fill_recurse(minigame, player, thetype, letter, number + 1);
 332 }
 333
 334 void bd_unfill_recurse(entity minigame, entity player, int thetype, int letter, int number)
 335 {
 336         string pos = minigame_tile_buildname(letter,number);
 337         if(!bd_valid_tile(pos))
 338                 return;
 339
 340         entity targ = bd_find_piece(minigame, pos, true);
 341         entity piece = bd_find_piece(minigame, pos, false);
 342
 343         if(targ && thetype == targ.bd_tiletype)
 344         {
 345                 if(targ.netname) { strunzone(targ.netname); }
 346                 delete(targ);
 347         }
 348         else if(piece && thetype == piece.bd_tiletype)
 349         {
 350                 if(piece.netname) { strunzone(piece.netname); }
 351                 delete(piece);
 352         }
 353         else return;
 354
 355         bd_unfill_recurse(minigame, player, thetype, letter - 1, number);
 356         bd_unfill_recurse(minigame, player, thetype, letter + 1, number);
 357         bd_unfill_recurse(minigame, player, thetype, letter, number - 1);
 358         bd_unfill_recurse(minigame, player, thetype, letter, number + 1);
 359 }
 360
 361 void bd_do_fill(entity minigame, entity player, string dir, string thetile)
 362 {
 363 #ifdef SVQC
 364         if(!player.minigame_players.bd_canedit)
 365         {
 366                 sprint(player.minigame_players, "You're not allowed to edit levels, sorry!\n");
 367                 return;
 368         }
 369 #endif
 370
 371         if(minigame.minigame_flags & BD_TURN_EDIT)
 372         {
 373                 int thetype = stof(thetile);
 374
 375                 entity targ = bd_find_piece(minigame, dir, true);
 376                 entity piece = bd_find_piece(minigame, dir, false);
 377
 378                 if(!bd_canfill(thetype) || (piece || targ))
 379                 {
 380                         int killtype = 0;
 381
 382                         if(targ) { killtype = targ.bd_tiletype; }
 383                         if(piece) { killtype = piece.bd_tiletype; }
 384
 385                         if(killtype)
 386                         {
 387                                 int letter = minigame_tile_letter(dir);
 388                                 int number = minigame_tile_number(dir);
 389                                 bd_unfill_recurse(minigame, player, killtype, letter, number);
 390                         }
 391
 392                         return;
 393                 }
 394
 395                 int letter = minigame_tile_letter(dir);
 396                 int number = minigame_tile_number(dir);
 397
 398                 bd_fill_recurse(minigame, player, thetype, letter, number);
 399         }
 400 }
 401
 402 void bd_reset_moves(entity minigame)
 403 {
 404         entity e;
 405 #ifdef SVQC
 406         for(e = minigame.minigame_players; e; e = e.list_next)
 407 #elif defined(CSQC)
 408         e = NULL;
 409         while( (e = findentity(e,owner,minigame)) )
 410                 if ( e.classname == "minigame_player" )
 411 #endif
 412                 {
 413                         e.bd_moves = 0;
 414                         minigame_server_sendflags(e,BD_SF_PLAYERMOVES);
 415                 }
 416 }
 417
 418 void bd_load_level(entity minigame);
 419 void bd_setup_pieces(entity minigame)
 420 {
 421         entity e = NULL;
 422         while( (e = findentity(e, owner, minigame)) )
 423                 if(e.classname == "minigame_board_piece")
 424                 {
 425                         if(e.netname) { strunzone(e.netname); }
 426                         delete(e);
 427                 }
 428
 429         bd_load_level(minigame);
 430 }
 431
 432 void bd_do_next_match(entity minigame, entity player)
 433 {
 434         minigame.minigame_flags = BD_TURN_MOVE;
 435         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 436
 437         if(minigame.bd_nextlevel && minigame.bd_nextlevel != "")
 438         {
 439                 if(minigame.bd_levelname) { strunzone(minigame.bd_levelname); }
 440                 minigame.bd_levelname = strzone(minigame.bd_nextlevel);
 441         }
 442
 443         bd_setup_pieces(minigame);
 444
 445         bd_reset_moves(minigame);
 446 }
 447
 448 void bd_set_next_match(entity minigame, string next)
 449 {
 450         if(minigame.bd_nextlevel) { strunzone(minigame.bd_nextlevel); }
 451         minigame.bd_nextlevel = strzone(next);
 452 }
 453
 454 void bd_next_match(entity minigame, entity player, string next)
 455 {
 456         if(minigame.minigame_flags & BD_TURN_WIN)
 457                 bd_do_next_match(minigame, player);
 458         if(minigame.minigame_flags & BD_TURN_EDIT)
 459                 bd_set_next_match(minigame, next);
 460 }
 461
 462 // request a new match
 463 void bd_restart_match(entity minigame, entity player)
 464 {
 465         minigame.minigame_flags = BD_TURN_MOVE;
 466         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 467
 468         bd_setup_pieces(minigame);
 469
 470         bd_reset_moves(minigame);
 471 }
 472
 473 void bd_activate_editor(entity minigame, entity player)
 474 {
 475 #ifdef SVQC
 476         if(!player.minigame_players.bd_canedit)
 477         {
 478                 sprint(player.minigame_players, "You're not allowed to edit levels, sorry!\n");
 479                 return;
 480         }
 481 #endif
 482
 483         minigame.minigame_flags = BD_TURN_EDIT;
 484         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 485
 486         bd_reset_moves(minigame);
 487
 488         bd_setup_pieces(minigame);
 489 }
 490
 491 string bd_save_piece(entity minigame, entity e)
 492 {
 493         string bd_string = "";
 494
 495         bd_string = strcat(bd_string, "\"", e.netname, "\" ");
 496         bd_string = strcat(bd_string, ftos(e.bd_tiletype), " ");
 497         bd_string = strcat(bd_string, ftos(e.bd_dir));
 498
 499         return bd_string;
 500 }
 501
 502 void bd_set_nextlevel(entity minigame, string s)
 503 {
 504         tokenize_console(s);
 505
 506         if(minigame.bd_nextlevel) { strunzone(minigame.bd_nextlevel); }
 507         minigame.bd_nextlevel = strzone(argv(2));
 508 }
 509
 510 int bd_fix_dir(vector dir)
 511 {
 512         if(dir.x == 0 && dir.y == 1) { return BD_DIR_UP; } // up
 513         if(dir.x == 0 && dir.y == -1) { return BD_DIR_DN; } // down
 514         if(dir.x == -1 && dir.y == 0) { return BD_DIR_LF; } // left
 515         if(dir.x == 1 && dir.y == 0) { return BD_DIR_RT; } // right
 516
 517         return BD_DIR_DN; // down if all else fails
 518 }
 519
 520 entity bd_load_piece(entity minigame, string s)
 521 {
 522         // separate pieces between the ; symbols
 523         string bd_string = s;
 524
 525         tokenize_console(bd_string);
 526
 527         entity e = msle_spawn(minigame,"minigame_board_piece");
 528         e.team = 1;
 529         e.bd_dir = 0;
 530
 531         int argv_num = 0;
 532         e.netname = strzone(argv(argv_num)); ++argv_num;
 533         e.bd_tiletype = stof(argv(argv_num)); ++argv_num;
 534         e.bd_dir = stoi(argv(argv_num)); ++argv_num;
 535
 536         minigame_server_sendflags(e,MINIG_SF_ALL);
 537
 538         return e;
 539 }
 540
 541 bool bd_save_level(entity minigame)
 542 {
 543         if(minigame.bd_levelname && minigame.bd_levelname != "")
 544         {
 545                 int target_count = 0, boulder_count = 0;
 546                 entity piece = NULL;
 547                 while((piece = findentity(piece,owner,minigame)))
 548                 if(piece.classname == "minigame_board_piece")
 549                         if(piece.bd_tiletype == BD_TILE_BOULDER)
 550                                 ++boulder_count;
 551                         else if(piece.bd_tiletype == BD_TILE_TARGET)
 552                                 ++target_count;
 553
 554                 if(boulder_count != target_count)
 555                 {
 556                         LOG_INFO("Not enough targets or boulders, fix your level!\n");
 557                         return false;
 558                 }
 559
 560                 // saves all objects to the database file
 561                 string file_name;
 562                 float file_get;
 563
 564                 file_name = strcat("minigames/bulldozer/storage_", minigame.bd_levelname, ".txt");
 565                 file_get = fopen(file_name, FILE_WRITE);
 566                 fputs(file_get, strcat("// bulldozer storage \"", minigame.bd_levelname, "\" last updated ", strftime(true, "%d-%m-%Y %H:%M:%S"), "\n"));
 567
 568                 if(minigame.bd_nextlevel && minigame.bd_nextlevel != "" && fexists(strcat("minigames/bulldozer/storage_", minigame.bd_nextlevel, ".txt")))
 569                         fputs(file_get, strcat("nextlevel = \"", minigame.bd_nextlevel, "\"\n"));
 570
 571                 entity e = NULL;
 572                 while ( ( e = findentity(e,owner,minigame) ) )
 573                 if ( e.classname == "minigame_board_piece" )
 574                 {
 575                         // use a line of text for each object, listing all properties
 576                         fputs(file_get, strcat(bd_save_piece(minigame, e), "\n"));
 577                 }
 578                 fclose(file_get);
 579
 580                 return true;
 581         }
 582
 583         return false;
 584 }
 585
 586 void bd_load_level(entity minigame)
 587 {
 588         // loads all items from the database file
 589         string file_read, file_name;
 590         float file_get;
 591
 592         file_name = strcat("minigames/bulldozer/storage_", minigame.bd_levelname, ".txt");
 593         file_get = fopen(file_name, FILE_READ);
 594         if(file_get < 0)
 595         {
 596                 LOG_INFO("^3BULLDOZER: ^7could not find storage file ^3", file_name, "^7, no items were loaded\n");
 597         }
 598         else
 599         {
 600                 for(;;)
 601                 {
 602                         file_read = fgets(file_get);
 603                         if(file_read == "")
 604                                 break;
 605                         if(substring(file_read, 0, 2) == "//")
 606                                 continue;
 607                         if(substring(file_read, 0, 1) == "#")
 608                                 continue;
 609                         if(substring(file_read, 0, 9) == "nextlevel")
 610                         {
 611                                 bd_set_nextlevel(minigame, file_read);
 612                                 continue;
 613                         }
 614
 615                         entity e;
 616                         e = bd_load_piece(minigame, file_read);
 617                 }
 618         }
 619         fclose(file_get);
 620 }
 621
 622 void bd_close_editor(entity minigame, entity player)
 623 {
 624 #ifdef SVQC
 625         if(!player.minigame_players.bd_canedit)
 626         {
 627                 sprint(player.minigame_players, "You're not allowed to edit levels, sorry!\n");
 628                 return;
 629         }
 630 #endif
 631
 632         entity dozer = bd_find_dozer(minigame);
 633         if(!dozer)
 634         {
 635                 LOG_INFO("You need to place a bulldozer on the level to save it!\n");
 636                 return;
 637         }
 638
 639         if(bd_save_level(minigame))
 640         {
 641                 minigame.minigame_flags = BD_TURN_MOVE;
 642                 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 643         }
 644         else
 645         {
 646                 LOG_INFO("You need to set the level name!\n");
 647                 return;
 648         }
 649 }
 650
 651 #ifdef SVQC
 652
 653 // required function, handle server side events
 654 int bd_server_event(entity minigame, string event, ...)
 655 {
 656         switch(event)
 657         {
 658                 case "start":
 659                 {
 660                         if(minigame.bd_levelname) { strunzone(minigame.bd_levelname); }
 661                         minigame.bd_levelname = strzone(autocvar_sv_minigames_bulldozer_startlevel);
 662                         bd_setup_pieces(minigame);
 663                         minigame.minigame_flags = BD_TURN_MOVE;
 664
 665                         return true;
 666                 }
 667                 case "end":
 668                 {
 669                         entity e = NULL;
 670                         while( (e = findentity(e, owner, minigame)) )
 671                         if(e.classname == "minigame_board_piece")
 672                         {
 673                                 if(e.netname) { strunzone(e.netname); }
 674                                 delete(e);
 675                         }
 676
 677                         if(minigame.bd_nextlevel) { strunzone(minigame.bd_nextlevel); }
 678                         if(minigame.bd_levelname) { strunzone(minigame.bd_levelname); }
 679                         return false;
 680                 }
 681                 case "join":
 682                 {
 683                         int pl_num = minigame_count_players(minigame);
 684
 685                         if(pl_num >= BD_TEAMS) { return false; }
 686
 687                         return 1;
 688                 }
 689                 case "cmd":
 690                 {
 691                         switch(argv(0))
 692                         {
 693                                 case "move":
 694                                         bd_do_move(minigame, ...(0,entity), ((...(1,int)) >= 2 ? argv(1) : string_null), ((...(1,int)) >= 3 ? argv(2) : string_null), ((...(1,int)) >= 4 ? argv(3) : string_null));
 695                                         return true;
 696                                 case "next":
 697                                         bd_next_match(minigame,...(0,entity), ((...(1,int) >= 2 ? argv(1) : string_null)));
 698                                         return true;
 699                                 case "restart":
 700                                         bd_restart_match(minigame,...(0,entity));
 701                                         return true;
 702                                 case "edit":
 703                                         bd_activate_editor(minigame,...(0,entity));
 704                                         return true;
 705                                 case "save":
 706                                         bd_close_editor(minigame,...(0,entity));
 707                                         return true;
 708                                 case "fill":
 709                                         bd_do_fill(minigame, ...(0,entity), ((...(1,int)) >= 2 ? argv(1) : string_null), ((...(1,int)) >= 3 ? argv(2) : string_null));
 710                                         return true;
 711                         }
 712
 713                         return false;
 714                 }
 715                 case "network_send":
 716                 {
 717                         entity sent = ...(0,entity);
 718                         int sf = ...(1,int);
 719                         if ( sent.classname == "minigame_board_piece" && (sf & MINIG_SF_UPDATE) )
 720                         {
 721                                 int letter = minigame_tile_letter(sent.netname);
 722                                 int number = minigame_tile_number(sent.netname);
 723
 724                                 WriteByte(MSG_ENTITY,letter);
 725                                 WriteByte(MSG_ENTITY,number);
 726
 727                                 WriteByte(MSG_ENTITY,sent.bd_tiletype);
 728
 729                                 WriteByte(MSG_ENTITY,sent.bd_dir);
 730                         }
 731                         else if(sent.classname == "minigame_player" && (sf & BD_SF_PLAYERMOVES))
 732                                 WriteShort(MSG_ENTITY,sent.bd_moves);
 733                         return false;
 734                 }
 735         }
 736
 737         return false;
 738 }
 739
 740
 741 #elif defined(CSQC)
 742
 743 int bd_curr_tile;
 744 string bd_curr_pos;
 745
 746 .entity bd_enemy;
 747 .bool bd_hide;
 748
 749 vector bd_boardpos; // HUD board position
 750 vector bd_boardsize;// HUD board size
 751
 752 string bd_get_tile_pic(int tileid)
 753 {
 754         switch(tileid)
 755         {
 756                 case BD_TILE_BOULDER: return "bd/boulder";
 757                 case BD_TILE_BRICK1: return "bd/brick1";
 758                 case BD_TILE_BRICK2: return "bd/brick2";
 759                 case BD_TILE_BRICK3: return "bd/brick3";
 760                 case BD_TILE_BRICK4: return "bd/brick4";
 761                 case BD_TILE_BRICK5: return "bd/brick5";
 762                 case BD_TILE_BRICK6: return "bd/brick6";
 763                 case BD_TILE_BRICK7: return "bd/brick7";
 764                 case BD_TILE_BRICK8: return "bd/brick8";
 765                 case BD_TILE_TARGET: return "bd/target";
 766                 case BD_TILE_DOZER: return "bd/dozer";
 767         }
 768
 769         return string_null;
 770 }
 771
 772 // Required function, draw the game board
 773 void bd_hud_board(vector pos, vector mySize)
 774 {
 775         minigame_hud_fitsqare(pos, mySize);
 776         bd_boardpos = pos;
 777         bd_boardsize = mySize;
 778
 779         minigame_hud_simpleboard(pos,mySize,minigame_texture("bd/board"));
 780
 781         vector tile_size = minigame_hud_denormalize_size('1 1 0' / BD_TILE_SIZE,pos,mySize);
 782         vector tile_pos;
 783
 784         entity e;
 785         FOREACH_MINIGAME_ENTITY(e)
 786         {
 787                 if(e.classname == "minigame_board_piece")
 788                 {
 789                         if(e.bd_tiletype == BD_TILE_TARGET)
 790                         {
 791                                 e.bd_enemy = NULL;
 792                                 e.bd_enemy = bd_find_piece(active_minigame, e.netname, false);
 793                         }
 794                         else if(e.bd_tiletype == BD_TILE_BOULDER)
 795                         {
 796                                 e.bd_hide = false; // reset either way
 797                                 e.bd_hide = ((bd_find_piece(active_minigame, e.netname, true)) != NULL);
 798                         }
 799                 }
 800         }
 801         FOREACH_MINIGAME_ENTITY(e)
 802         {
 803                 if ( e.classname == "minigame_board_piece" )
 804                 {
 805                         if(e.bd_tiletype != BD_TILE_DOZER && !e.bd_hide) // hide boulders
 806                         {
 807                                 tile_pos = minigame_tile_pos(e.netname,BD_NUM_CNT,BD_LET_CNT);
 808                                 tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 809
 810                                 string thepiece = bd_get_tile_pic(e.bd_tiletype);
 811
 812                                 if(e.bd_enemy)
 813                                         thepiece = "bd/boulder_target";
 814
 815                                 minigame_drawpic_centered( tile_pos,
 816                                                 minigame_texture(thepiece),
 817                                                 tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
 818                         }
 819                 }
 820         }
 821
 822         // draw dozers on top, always
 823         FOREACH_MINIGAME_ENTITY(e)
 824         {
 825                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype == BD_TILE_DOZER )
 826                 {
 827                         tile_pos = minigame_tile_pos(e.netname,BD_NUM_CNT,BD_LET_CNT);
 828                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 829
 830                         int bdir = e.bd_dir;
 831                         float theang = 0;
 832
 833                         switch(bdir)
 834                         {
 835                                 case BD_DIR_UP: theang = 0; break;
 836                                 default:
 837                                 case BD_DIR_DN: theang = M_PI; break;
 838                                 case BD_DIR_LF: theang = M_PI * 3 / 2; break;
 839                                 case BD_DIR_RT: theang = M_PI / 2; break;
 840                         }
 841
 842                         drawrotpic(tile_pos, theang, minigame_texture("bd/dozer"),
 843                                                 tile_size, tile_size/2, '1 1 1',
 844                                                 panel_fg_alpha, DRAWFLAG_NORMAL );
 845                 }
 846         }
 847
 848         if(active_minigame.minigame_flags & BD_TURN_EDIT)
 849         if(bd_valid_tile(bd_curr_pos))
 850         {
 851                 entity piece = bd_find_piece(active_minigame, bd_curr_pos, false);
 852                 entity targ = bd_find_piece(active_minigame, bd_curr_pos, true);
 853                 string thepiece = ((piece || (targ && bd_curr_tile != BD_TILE_BOULDER)) ? "bd/delete" : bd_get_tile_pic(bd_curr_tile));
 854
 855                 tile_pos = minigame_tile_pos(bd_curr_pos,BD_LET_CNT,BD_NUM_CNT);
 856                 tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 857                 if(bd_curr_tile == BD_TILE_DOZER)
 858                 {
 859                         drawrotpic(tile_pos, M_PI, minigame_texture("bd/dozer"),
 860                                                 tile_size, tile_size/2, '1 1 1',
 861                                                 panel_fg_alpha/2, DRAWFLAG_NORMAL );
 862                 }
 863                 else
 864                 {
 865                         minigame_drawpic_centered( tile_pos,
 866                                         minigame_texture(thepiece),
 867                                         tile_size, '1 1 1', panel_fg_alpha/2, DRAWFLAG_NORMAL );
 868                 }
 869         }
 870
 871         if ( (active_minigame.minigame_flags & BD_TURN_LOSS) || (active_minigame.minigame_flags & BD_TURN_WIN) )
 872         {
 873                 vector winfs = hud_fontsize*2;
 874                 string victory_text = "Game over!";
 875
 876                 if(active_minigame.minigame_flags & BD_TURN_WIN)
 877                         victory_text = "Well done! Click 'Next Level' to continue";
 878
 879                 vector win_pos = pos+eY*(mySize_y-winfs_y)/2;
 880                 vector win_sz;
 881                 win_sz = minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
 882                         sprintf("%s", victory_text),
 883                         winfs, 0, DRAWFLAG_NORMAL, 0.5);
 884
 885                 drawfill(win_pos-eY*hud_fontsize_y,win_sz+2*eY*hud_fontsize_y,'0.3 0.3 1',0.8,DRAWFLAG_ADDITIVE);
 886
 887                 minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
 888                         sprintf("%s", victory_text),
 889                         winfs, panel_fg_alpha, DRAWFLAG_NORMAL, 0.5);
 890         }
 891 }
 892
 893
 894 // Required function, draw the game status panel
 895 void bd_hud_status(vector pos, vector mySize)
 896 {
 897         HUD_Panel_DrawBg();
 898         vector ts;
 899         ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
 900                 hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
 901
 902         pos_y += ts_y;
 903         mySize_y -= ts_y;
 904
 905         vector player_fontsize = hud_fontsize * 1.75;
 906         ts_y = ( mySize_y - 2*player_fontsize_y ) / BD_TEAMS;
 907         ts_x = mySize_x;
 908         vector mypos;
 909         vector tile_size = '48 48 0';
 910
 911         mypos = pos;
 912         drawfill(mypos,eX*mySize_x+eY*player_fontsize_y,'1 1 1',0.5,DRAWFLAG_ADDITIVE);
 913         mypos_y += player_fontsize_y;
 914         drawfill(mypos,eX*mySize_x+eY*tile_size_y,'1 1 1',0.25,DRAWFLAG_ADDITIVE);
 915
 916         entity e;
 917         FOREACH_MINIGAME_ENTITY(e)
 918         {
 919                 if ( e.classname == "minigame_player" )
 920                 {
 921                         mypos = pos;
 922                         minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
 923                                 entcs_GetName(e.minigame_playerslot-1),
 924                                 player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
 925
 926                         mypos_y += player_fontsize_y;
 927                         string thepiece = "bd/dozer";
 928                         if(active_minigame.minigame_flags & BD_TURN_EDIT)
 929                                 thepiece = bd_get_tile_pic(bd_curr_tile);
 930                         drawpic( mypos,
 931                                         minigame_texture(thepiece),
 932                                         tile_size * 0.7, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
 933
 934                         mypos_x += tile_size_x;
 935
 936                         drawstring(mypos,ftos(e.bd_moves),tile_size,
 937                                            '0.7 0.84 1', panel_fg_alpha, DRAWFLAG_NORMAL);
 938                 }
 939         }
 940 }
 941
 942 // Turn a set of flags into a help message
 943 string bd_turn_to_string(int turnflags)
 944 {
 945         if ( turnflags & BD_TURN_LOSS )
 946                 return _("Better luck next time!");
 947
 948         if ( turnflags & BD_TURN_WIN )
 949                 if(random() > 0.5)
 950                         return _("Tubular! Press \"Next Level\" to continue!");
 951                 else
 952                         return _("Wicked! Press \"Next Level\" to continue!");
 953
 954         if( turnflags & BD_TURN_EDIT )
 955                 return _("Press the space bar to change your currently selected tile");
 956
 957         if ( turnflags & BD_TURN_MOVE )
 958                 return _("Push the boulders onto the targets");
 959
 960         return "";
 961 }
 962
 963 // Make the correct move
 964 void bd_make_move(entity minigame, string dir)
 965 {
 966         if ( minigame.minigame_flags == BD_TURN_MOVE )
 967         {
 968                 minigame_cmd("move ", dir);
 969         }
 970 }
 971
 972 void bd_editor_make_move(entity minigame, string dir)
 973 {
 974         if ( minigame.minigame_flags == BD_TURN_EDIT )
 975         {
 976                 minigame_cmd("move ", bd_curr_pos, " ", ftos(bd_curr_tile), " ", dir);
 977         }
 978 }
 979
 980 void bd_editor_fill(entity minigame)
 981 {
 982         if ( minigame.minigame_flags == BD_TURN_EDIT )
 983         {
 984                 minigame_cmd("fill ", bd_curr_pos, " ", ftos(bd_curr_tile));
 985         }
 986 }
 987
 988 void bd_set_curr_pos(string s)
 989 {
 990         if ( bd_curr_pos )
 991                 strunzone(bd_curr_pos);
 992         if ( s )
 993                 s = strzone(s);
 994         bd_curr_pos = s;
 995 }
 996
 997 bool bd_normal_move(entity minigame, int themove)
 998 {
 999         switch ( themove )
1000         {
1001                 case K_RIGHTARROW:
1002                 case K_KP_RIGHTARROW:
1003                         bd_make_move(minigame, "r");
1004                         return true;
1005                 case K_LEFTARROW:
1006                 case K_KP_LEFTARROW:
1007                         bd_make_move(minigame, "l");
1008                         return true;
1009                 case K_UPARROW:
1010                 case K_KP_UPARROW:
1011                         bd_make_move(minigame, "u");
1012                         return true;
1013                 case K_DOWNARROW:
1014                 case K_KP_DOWNARROW:
1015                         bd_make_move(minigame, "d");
1016                         return true;
1017         }
1018
1019         return false;
1020 }
1021
1022 bool bd_change_dozer_angle(entity minigame)
1023 {
1024         entity dozer = bd_find_piece(minigame, bd_curr_pos, false);
1025         if(!dozer || dozer.bd_tiletype != BD_TILE_DOZER)
1026                 return false;
1027
1028         switch(dozer.bd_dir)
1029         {
1030                 case BD_DIR_UP: dozer.bd_dir = BD_DIR_LF; break; // up -> left
1031                 default:
1032                 case BD_DIR_DN: dozer.bd_dir = BD_DIR_RT; break; // down -> right
1033                 case BD_DIR_LF: dozer.bd_dir = BD_DIR_DN; break; // left -> down
1034                 case BD_DIR_RT: dozer.bd_dir = BD_DIR_UP; break; // right -> up
1035         }
1036         string thedir = bd_get_dir_name(dozer.bd_dir);
1037
1038         bd_editor_make_move(minigame, thedir);
1039         return true;
1040 }
1041
1042 bool bd_editor_move(entity minigame, int themove)
1043 {
1044         switch ( themove )
1045         {
1046                 case K_RIGHTARROW:
1047                 case K_KP_RIGHTARROW:
1048                         if ( ! bd_curr_pos )
1049                                 bd_set_curr_pos("a3");
1050                         else
1051                                 bd_set_curr_pos(minigame_relative_tile(bd_curr_pos,1,0,BD_NUM_CNT,BD_LET_CNT));
1052                         return true;
1053                 case K_LEFTARROW:
1054                 case K_KP_LEFTARROW:
1055                         if ( ! bd_curr_pos )
1056                                 bd_set_curr_pos("c3");
1057                         else
1058                                 bd_set_curr_pos(minigame_relative_tile(bd_curr_pos,-1,0,BD_NUM_CNT,BD_LET_CNT));
1059                         return true;
1060                 case K_UPARROW:
1061                 case K_KP_UPARROW:
1062                         if ( ! bd_curr_pos )
1063                                 bd_set_curr_pos("a1");
1064                         else
1065                                 bd_set_curr_pos(minigame_relative_tile(bd_curr_pos,0,1,BD_NUM_CNT,BD_LET_CNT));
1066                         return true;
1067                 case K_DOWNARROW:
1068                 case K_KP_DOWNARROW:
1069                         if ( ! bd_curr_pos )
1070                                 bd_set_curr_pos("a3");
1071                         else
1072                                 bd_set_curr_pos(minigame_relative_tile(bd_curr_pos,0,-1,BD_NUM_CNT,BD_LET_CNT));
1073                         return true;
1074                 case K_ENTER:
1075                 case K_KP_ENTER:
1076                         bd_editor_make_move(minigame, "");
1077                         return true;
1078                 case K_SPACE:
1079                         if(bd_change_dozer_angle(minigame))
1080                                 return true;
1081                         bd_curr_tile += 1;
1082                         if(bd_curr_tile > BD_TILE_LAST)
1083                                 bd_curr_tile = 1;
1084                         return true;
1085         }
1086
1087         return false;
1088 }
1089
1090 // Required function, handle client events
1091 int bd_client_event(entity minigame, string event, ...)
1092 {
1093         switch(event)
1094         {
1095                 case "activate":
1096                 {
1097                         minigame.message = bd_turn_to_string(minigame.minigame_flags);
1098                         bd_set_curr_pos("");
1099                         bd_curr_tile = BD_TILE_BRICK1;
1100                         return false;
1101                 }
1102                 case "key_pressed":
1103                 {
1104                         if(minigame.minigame_flags & BD_TURN_MOVE)
1105                         {
1106                                 if(bd_normal_move(minigame, ...(0,int)))
1107                                         return true;
1108                         }
1109
1110                         if(minigame.minigame_flags & BD_TURN_EDIT)
1111                         {
1112                                 if(bd_editor_move(minigame, ...(0,int)))
1113                                         return true;
1114                         }
1115
1116                         return false;
1117                 }
1118                 case "mouse_pressed":
1119                 {
1120                         if(minigame.minigame_flags & BD_TURN_EDIT)
1121                         {
1122                                 if(...(0,int) == K_MOUSE1)
1123                                 {
1124                                         bd_editor_make_move(minigame, "");
1125                                         return true;
1126                                 }
1127
1128                                 if(...(0,int) == K_MOUSE2)
1129                                 {
1130                                         bd_editor_fill(minigame);
1131                                         return true;
1132                                 }
1133                         }
1134
1135                         return false;
1136                 }
1137                 case "mouse_moved":
1138                 {
1139                         if(minigame.minigame_flags & BD_TURN_EDIT)
1140                         {
1141                                 vector mouse_pos = minigame_hud_normalize(mousepos,bd_boardpos,bd_boardsize);
1142                                 bd_set_curr_pos(minigame_tile_name(mouse_pos,BD_LET_CNT,BD_NUM_CNT));
1143                                 if ( ! bd_valid_tile(bd_curr_pos) )
1144                                         bd_set_curr_pos("");
1145                         }
1146                         return true;
1147                 }
1148                 case "network_receive":
1149                 {
1150                         entity sent = ...(0,entity);
1151                         int sf = ...(1,int);
1152                         if ( sent.classname == "minigame" )
1153                         {
1154                                 if ( sf & MINIG_SF_UPDATE )
1155                                 {
1156                                         sent.message = bd_turn_to_string(sent.minigame_flags);
1157                                         //if ( sent.minigame_flags & minigame_self.team )
1158                                                 minigame_prompt();
1159                                 }
1160                         }
1161                         else if(sent.classname == "minigame_board_piece")
1162                         {
1163                                 if(sf & MINIG_SF_UPDATE)
1164                                 {
1165                                         int letter = ReadByte();
1166                                         int number = ReadByte();
1167                                         if(sent.netname) { strunzone(sent.netname); }
1168                                         sent.netname = strzone(minigame_tile_buildname(letter, number));
1169
1170                                         sent.bd_tiletype = ReadByte();
1171
1172                                         sent.bd_dir = ReadByte();
1173                                 }
1174                         }
1175                         else if(sent.classname == "minigame_player" && (sf & BD_SF_PLAYERMOVES))
1176                                 sent.bd_moves = ReadShort(); // make this a byte when possible
1177
1178                         return false;
1179                 }
1180                 case "menu_show":
1181                 {
1182                         HUD_MinigameMenu_CustomEntry(...(0,entity),_("Next Level"),"next");
1183                         HUD_MinigameMenu_CustomEntry(...(0,entity),_("Restart"),"restart");
1184                         HUD_MinigameMenu_CustomEntry(...(0,entity),_("Editor"),"edit");
1185                         HUD_MinigameMenu_CustomEntry(...(0,entity),_("Save"),"save");
1186                         return false;
1187                 }
1188                 case "menu_click":
1189                 {
1190                         if(...(0,string) == "next")
1191                                 minigame_cmd("next");
1192                         if(...(0,string) == "restart")
1193                                 minigame_cmd("restart");
1194                         if(...(0,string) == "edit")
1195                                 minigame_cmd("edit");
1196                         if(...(0,string) == "save")
1197                                 minigame_cmd("save");
1198                         return false;
1199                 }
1200         }
1201
1202         return false;
1203 }
1204
1205 #endif