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