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