qcsrc/common/minigames/minigame/bd.qc

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