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                         {
 732                                 if(piece.bd_tiletype == BD_TILE_BOULDER)
 733                                         ++boulder_count;
 734                                 else if(piece.bd_tiletype == BD_TILE_TARGET)
 735                                         ++target_count;
 736                         }
 737
 738                 if(boulder_count != target_count)
 739                 {
 740                         LOG_INFO("Not enough targets or boulders, fix your level!");
 741                         return false;
 742                 }
 743
 744                 // saves all objects to the database file
 745                 string file_name;
 746                 float file_get;
 747
 748                 file_name = strcat("minigames/bulldozer/storage_", minigame.bd_levelname, ".txt");
 749                 file_get = fopen(file_name, FILE_WRITE);
 750                 fputs(file_get, strcat("// bulldozer storage \"", minigame.bd_levelname, "\" last updated ", strftime(true, "%d-%m-%Y %H:%M:%S"), "\n"));
 751
 752                 if(minigame.bd_nextlevel && minigame.bd_nextlevel != "" && fexists(strcat("minigames/bulldozer/storage_", minigame.bd_nextlevel, ".txt")))
 753                         fputs(file_get, strcat("nextlevel = \"", minigame.bd_nextlevel, "\"\n"));
 754
 755                 entity e = NULL;
 756                 while ( ( e = findentity(e,owner,minigame) ) )
 757                 if ( e.classname == "bd_controller" )
 758                 {
 759                         for(int j = 0; j < BD_NUM_CNT; ++j)
 760                         {
 761                                 // use a line of text for each object, listing all properties
 762                                 fputs(file_get, strcat(bd_save_controller_piece(minigame, e, j), "\n"));
 763                         }
 764                 }
 765                 e = NULL;
 766
 767                 while ( ( e = findentity(e,owner,minigame) ) )
 768                 if ( e.classname == "minigame_board_piece" )
 769                 {
 770                         // use a line of text for each object, listing all properties
 771                         fputs(file_get, strcat(bd_save_piece(minigame, e), "\n"));
 772                 }
 773                 fclose(file_get);
 774
 775                 return true;
 776         }
 777
 778         return false;
 779 }
 780
 781 void bd_load_level(entity minigame)
 782 {
 783         // loads all items from the database file
 784         string file_read, file_name;
 785         float file_get;
 786
 787         file_name = strcat("minigames/bulldozer/storage_", minigame.bd_levelname, ".txt");
 788         file_get = fopen(file_name, FILE_READ);
 789         if(file_get < 0)
 790         {
 791                 LOG_INFO("^3BULLDOZER: ^7could not find storage file ^3", file_name, "^7, no items were loaded");
 792         }
 793         else
 794         {
 795                 for(;;)
 796                 {
 797                         file_read = fgets(file_get);
 798                         if(file_read == "")
 799                                 break;
 800                         if(substring(file_read, 0, 2) == "//")
 801                                 continue;
 802                         if(substring(file_read, 0, 1) == "#")
 803                                 continue;
 804                         if(substring(file_read, 0, 9) == "nextlevel")
 805                         {
 806                                 bd_set_nextlevel(minigame, file_read);
 807                                 continue;
 808                         }
 809
 810                         bd_load_piece(minigame, file_read);
 811                 }
 812         }
 813         fclose(file_get);
 814 }
 815
 816 void bd_close_editor(entity minigame, entity player)
 817 {
 818 #ifdef SVQC
 819         if(!player.minigame_players.bd_canedit)
 820         {
 821                 sprint(player.minigame_players, "You're not allowed to edit levels, sorry!\n");
 822                 return;
 823         }
 824 #endif
 825
 826         entity dozer = bd_find_dozer(minigame);
 827         if(!dozer)
 828         {
 829                 LOG_INFO("You need to place a bulldozer on the level to save it!");
 830                 return;
 831         }
 832
 833         if(bd_save_level(minigame))
 834         {
 835                 minigame.minigame_flags = BD_TURN_MOVE;
 836                 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 837         }
 838         else
 839         {
 840                 LOG_INFO("You need to set the level name!");
 841                 return;
 842         }
 843 }
 844
 845 #ifdef SVQC
 846
 847 // required function, handle server side events
 848 int bd_server_event(entity minigame, string event, ...)
 849 {
 850         switch(event)
 851         {
 852                 case "start":
 853                 {
 854                         strcpy(minigame.bd_levelname, autocvar_sv_minigames_bulldozer_startlevel);
 855                         bd_setup_pieces(minigame);
 856                         minigame.minigame_flags = BD_TURN_MOVE;
 857
 858                         return true;
 859                 }
 860                 case "end":
 861                 {
 862                         entity e = NULL;
 863                         while( (e = findentity(e, owner, minigame)) )
 864                         if(e.classname == "minigame_board_piece")
 865                         {
 866                                 strfree(e.netname);
 867                                 delete(e);
 868                         }
 869                         e = NULL;
 870                         while( (e = findentity(e, owner, minigame)) )
 871                         if(e.classname == "bd_controller")
 872                         {
 873                                 delete(e);
 874                         }
 875
 876                         strfree(minigame.bd_nextlevel);
 877                         strfree(minigame.bd_levelname);
 878                         return false;
 879                 }
 880                 case "join":
 881                 {
 882                         int pl_num = minigame_count_players(minigame);
 883
 884                         if(pl_num >= BD_TEAMS) { return false; }
 885
 886                         return 1;
 887                 }
 888                 case "cmd":
 889                 {
 890                         switch(argv(0))
 891                         {
 892                                 case "move":
 893                                         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));
 894                                         return true;
 895                                 case "next":
 896                                         bd_next_match(minigame,...(0,entity), ((...(1,int) >= 2 ? argv(1) : string_null)));
 897                                         return true;
 898                                 case "restart":
 899                                         bd_restart_match(minigame,...(0,entity));
 900                                         return true;
 901                                 case "edit":
 902                                         bd_activate_editor(minigame,...(0,entity));
 903                                         return true;
 904                                 case "save":
 905                                         bd_close_editor(minigame,...(0,entity));
 906                                         return true;
 907                                 case "fill":
 908                                         bd_do_fill(minigame, ...(0,entity), ((...(1,int)) >= 2 ? argv(1) : string_null), ((...(1,int)) >= 3 ? argv(2) : string_null));
 909                                         return true;
 910                         }
 911
 912                         return false;
 913                 }
 914                 case "network_send":
 915                 {
 916                         entity sent = ...(0,entity);
 917                         int sf = ...(1,int);
 918                         if ( sent.classname == "minigame_board_piece" && (sf & MINIG_SF_UPDATE) )
 919                         {
 920                                 int letter = minigame_tile_letter(sent.netname);
 921                                 int number = minigame_tile_number(sent.netname);
 922
 923                                 WriteByte(MSG_ENTITY,letter);
 924                                 WriteByte(MSG_ENTITY,number);
 925
 926                                 WriteByte(MSG_ENTITY,sent.bd_tiletype);
 927
 928                                 WriteByte(MSG_ENTITY,sent.bd_dir);
 929                         }
 930                         else if(sent.classname == "minigame_player" && (sf & BD_SF_PLAYERMOVES))
 931                                 WriteShort(MSG_ENTITY,sent.bd_moves);
 932                         return false;
 933                 }
 934         }
 935
 936         return false;
 937 }
 938
 939
 940 #elif defined(CSQC)
 941
 942 int bd_curr_tile;
 943 string bd_curr_pos;
 944
 945 .entity bd_enemy;
 946 .bool bd_hide;
 947
 948 vector bd_boardpos; // HUD board position
 949 vector bd_boardsize;// HUD board size
 950
 951 string bd_get_tile_pic(int tileid)
 952 {
 953         switch(tileid)
 954         {
 955                 case BD_TILE_BOULDER: return "bd/boulder";
 956                 case BD_TILE_BRICK1: return "bd/brick1";
 957                 case BD_TILE_BRICK2: return "bd/brick2";
 958                 case BD_TILE_BRICK3: return "bd/brick3";
 959                 case BD_TILE_BRICK4: return "bd/brick4";
 960                 case BD_TILE_BRICK5: return "bd/brick5";
 961                 case BD_TILE_BRICK6: return "bd/brick6";
 962                 case BD_TILE_BRICK7: return "bd/brick7";
 963                 case BD_TILE_BRICK8: return "bd/brick8";
 964                 case BD_TILE_TARGET: return "bd/target";
 965                 case BD_TILE_DOZER: return "bd/dozer";
 966         }
 967
 968         return string_null;
 969 }
 970
 971 // Required function, draw the game board
 972 void bd_hud_board(vector pos, vector mySize)
 973 {
 974         minigame_hud_fitsqare(pos, mySize);
 975         bd_boardpos = pos;
 976         bd_boardsize = mySize;
 977
 978         minigame_hud_simpleboard(pos,mySize,minigame_texture("bd/board"));
 979
 980         vector tile_size = minigame_hud_denormalize_size('1 1 0' / BD_TILE_SIZE,pos,mySize);
 981         vector tile_pos;
 982
 983         entity e;
 984         FOREACH_MINIGAME_ENTITY(e)
 985         {
 986                 if(e.classname == "minigame_board_piece")
 987                 {
 988                         if(e.bd_tiletype == BD_TILE_TARGET)
 989                         {
 990                                 e.bd_enemy = NULL;
 991                                 e.bd_enemy = bd_find_piece(active_minigame, e.netname, false);
 992                         }
 993                         else if(e.bd_tiletype == BD_TILE_BOULDER)
 994                         {
 995                                 e.bd_hide = false; // reset either way
 996                                 e.bd_hide = ((bd_find_piece(active_minigame, e.netname, true)) != NULL);
 997                         }
 998                 }
 999         }
1000         FOREACH_MINIGAME_ENTITY(e)
1001         {
1002                 if ( e.classname == "bd_controller" )
1003                 {
1004                         for(int j = 0; j < BD_NUM_CNT; ++j)
1005                         {
1006                                 if(!e.bd_tiletypes[j]) continue;
1007
1008                                 int letter = e.bd_tilelet;
1009                                 string mypos = minigame_tile_buildname(letter, j);
1010
1011                                 tile_pos = minigame_tile_pos(mypos,BD_NUM_CNT,BD_LET_CNT);
1012                                 tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
1013
1014                                 string thepiece = bd_get_tile_pic(e.bd_tiletypes[j]);
1015
1016                                 minigame_drawpic_centered( tile_pos,
1017                                                 minigame_texture(thepiece),
1018                                                 tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
1019                         }
1020                 }
1021                 else if ( e.classname == "minigame_board_piece" )
1022                 {
1023                         if(e.bd_tiletype != BD_TILE_DOZER && !e.bd_hide) // hide boulders
1024                         {
1025                                 tile_pos = minigame_tile_pos(e.netname,BD_NUM_CNT,BD_LET_CNT);
1026                                 tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
1027
1028                                 string thepiece = bd_get_tile_pic(e.bd_tiletype);
1029
1030                                 if(e.bd_enemy)
1031                                         thepiece = "bd/boulder_target";
1032
1033                                 minigame_drawpic_centered( tile_pos,
1034                                                 minigame_texture(thepiece),
1035                                                 tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
1036                         }
1037                 }
1038         }
1039
1040         // draw dozers on top, always
1041         FOREACH_MINIGAME_ENTITY(e)
1042         {
1043                 if ( e.classname == "minigame_board_piece" && e.bd_tiletype == BD_TILE_DOZER )
1044                 {
1045                         tile_pos = minigame_tile_pos(e.netname,BD_NUM_CNT,BD_LET_CNT);
1046                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
1047
1048                         int bdir = e.bd_dir;
1049                         float theang = 0;
1050
1051                         switch(bdir)
1052                         {
1053                                 case BD_DIR_UP: theang = 0; break;
1054                                 default:
1055                                 case BD_DIR_DN: theang = M_PI; break;
1056                                 case BD_DIR_LF: theang = M_PI * 3 / 2; break;
1057                                 case BD_DIR_RT: theang = M_PI / 2; break;
1058                         }
1059
1060                         drawrotpic(tile_pos, theang, minigame_texture("bd/dozer"),
1061                                                 tile_size, tile_size/2, '1 1 1',
1062                                                 panel_fg_alpha, DRAWFLAG_NORMAL );
1063                 }
1064         }
1065
1066         if(active_minigame.minigame_flags & BD_TURN_EDIT)
1067         if(bd_valid_tile(bd_curr_pos))
1068         {
1069                 entity piece = bd_find_piece(active_minigame, bd_curr_pos, false);
1070                 entity targ = bd_find_piece(active_minigame, bd_curr_pos, true);
1071                 string thepiece = ((piece || (targ && bd_curr_tile != BD_TILE_BOULDER)) ? "bd/delete" : bd_get_tile_pic(bd_curr_tile));
1072
1073                 tile_pos = minigame_tile_pos(bd_curr_pos,BD_LET_CNT,BD_NUM_CNT);
1074                 tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
1075                 if(bd_curr_tile == BD_TILE_DOZER)
1076                 {
1077                         drawrotpic(tile_pos, M_PI, minigame_texture("bd/dozer"),
1078                                                 tile_size, tile_size/2, '1 1 1',
1079                                                 panel_fg_alpha/2, DRAWFLAG_NORMAL );
1080                 }
1081                 else
1082                 {
1083                         minigame_drawpic_centered( tile_pos,
1084                                         minigame_texture(thepiece),
1085                                         tile_size, '1 1 1', panel_fg_alpha/2, DRAWFLAG_NORMAL );
1086                 }
1087         }
1088
1089         if ( (active_minigame.minigame_flags & BD_TURN_LOSS) || (active_minigame.minigame_flags & BD_TURN_WIN) )
1090         {
1091                 vector winfs = hud_fontsize*2;
1092                 string victory_text = _("Game over!");
1093
1094                 if(active_minigame.minigame_flags & BD_TURN_WIN)
1095                         victory_text = _("Well done! Click 'Next Level' to continue");
1096
1097                 vector win_pos = pos+eY*(mySize_y-winfs_y)/2;
1098                 vector win_sz;
1099                 win_sz = minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
1100                         victory_text, winfs, 0, DRAWFLAG_NORMAL, 0.5);
1101
1102                 drawfill(win_pos-eY*hud_fontsize_y,win_sz+2*eY*hud_fontsize_y,'0.3 0.3 1',0.8,DRAWFLAG_ADDITIVE);
1103
1104                 minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
1105                         victory_text, 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         {
1166                 if(random() > 0.5)
1167                         return _("Tubular! Press \"Next Level\" to continue!");
1168                 else
1169                         return _("Wicked! Press \"Next Level\" to continue!");
1170         }
1171
1172         if( turnflags & BD_TURN_EDIT )
1173                 return _("Press the space bar to change your currently selected tile");
1174
1175         if ( turnflags & BD_TURN_MOVE )
1176                 return _("Push the boulders onto the targets");
1177
1178         return "";
1179 }
1180
1181 // Make the correct move
1182 void bd_make_move(entity minigame, string dir)
1183 {
1184         if ( minigame.minigame_flags == BD_TURN_MOVE )
1185         {
1186                 minigame_cmd("move ", dir);
1187         }
1188 }
1189
1190 void bd_editor_make_move(entity minigame, string dir)
1191 {
1192         if ( minigame.minigame_flags == BD_TURN_EDIT )
1193         {
1194                 minigame_cmd("move ", bd_curr_pos, " ", ftos(bd_curr_tile), " ", dir);
1195         }
1196 }
1197
1198 void bd_editor_fill(entity minigame)
1199 {
1200         if ( minigame.minigame_flags == BD_TURN_EDIT )
1201         {
1202                 minigame_cmd("fill ", bd_curr_pos, " ", ftos(bd_curr_tile));
1203         }
1204 }
1205
1206 void bd_set_curr_pos(string s)
1207 {
1208         strfree(bd_curr_pos);
1209         if ( s )
1210                 s = strzone(s);
1211         bd_curr_pos = s;
1212 }
1213
1214 bool bd_normal_move(entity minigame, int themove)
1215 {
1216         switch ( themove )
1217         {
1218                 case K_RIGHTARROW:
1219                 case K_KP_RIGHTARROW:
1220                         bd_make_move(minigame, "r");
1221                         return true;
1222                 case K_LEFTARROW:
1223                 case K_KP_LEFTARROW:
1224                         bd_make_move(minigame, "l");
1225                         return true;
1226                 case K_UPARROW:
1227                 case K_KP_UPARROW:
1228                         bd_make_move(minigame, "u");
1229                         return true;
1230                 case K_DOWNARROW:
1231                 case K_KP_DOWNARROW:
1232                         bd_make_move(minigame, "d");
1233                         return true;
1234         }
1235
1236         return false;
1237 }
1238
1239 bool bd_change_dozer_angle(entity minigame)
1240 {
1241         entity dozer = bd_find_piece(minigame, bd_curr_pos, false);
1242         if(!dozer || dozer.bd_tiletype != BD_TILE_DOZER)
1243                 return false;
1244
1245         switch(dozer.bd_dir)
1246         {
1247                 case BD_DIR_UP: dozer.bd_dir = BD_DIR_LF; break; // up -> left
1248                 default:
1249                 case BD_DIR_DN: dozer.bd_dir = BD_DIR_RT; break; // down -> right
1250                 case BD_DIR_LF: dozer.bd_dir = BD_DIR_DN; break; // left -> down
1251                 case BD_DIR_RT: dozer.bd_dir = BD_DIR_UP; break; // right -> up
1252         }
1253         string thedir = bd_get_dir_name(dozer.bd_dir);
1254
1255         bd_editor_make_move(minigame, thedir);
1256         return true;
1257 }
1258
1259 bool bd_editor_move(entity minigame, int themove)
1260 {
1261         switch ( themove )
1262         {
1263                 case K_RIGHTARROW:
1264                 case K_KP_RIGHTARROW:
1265                         if ( ! bd_curr_pos )
1266                                 bd_set_curr_pos("a3");
1267                         else
1268                                 bd_set_curr_pos(minigame_relative_tile(bd_curr_pos,1,0,BD_NUM_CNT,BD_LET_CNT));
1269                         return true;
1270                 case K_LEFTARROW:
1271                 case K_KP_LEFTARROW:
1272                         if ( ! bd_curr_pos )
1273                                 bd_set_curr_pos("c3");
1274                         else
1275                                 bd_set_curr_pos(minigame_relative_tile(bd_curr_pos,-1,0,BD_NUM_CNT,BD_LET_CNT));
1276                         return true;
1277                 case K_UPARROW:
1278                 case K_KP_UPARROW:
1279                         if ( ! bd_curr_pos )
1280                                 bd_set_curr_pos("a1");
1281                         else
1282                                 bd_set_curr_pos(minigame_relative_tile(bd_curr_pos,0,1,BD_NUM_CNT,BD_LET_CNT));
1283                         return true;
1284                 case K_DOWNARROW:
1285                 case K_KP_DOWNARROW:
1286                         if ( ! bd_curr_pos )
1287                                 bd_set_curr_pos("a3");
1288                         else
1289                                 bd_set_curr_pos(minigame_relative_tile(bd_curr_pos,0,-1,BD_NUM_CNT,BD_LET_CNT));
1290                         return true;
1291                 case K_ENTER:
1292                 case K_KP_ENTER:
1293                         bd_editor_make_move(minigame, "");
1294                         return true;
1295                 case K_SPACE:
1296                         if(bd_change_dozer_angle(minigame))
1297                                 return true;
1298                         bd_curr_tile += 1;
1299                         if(bd_curr_tile > BD_TILE_LAST)
1300                                 bd_curr_tile = 1;
1301                         return true;
1302         }
1303
1304         return false;
1305 }
1306
1307 // Required function, handle client events
1308 int bd_client_event(entity minigame, string event, ...)
1309 {
1310         switch(event)
1311         {
1312                 case "activate":
1313                 {
1314                         strcpy(minigame.message, bd_turn_to_string(minigame.minigame_flags));
1315                         bd_set_curr_pos("");
1316                         bd_curr_tile = BD_TILE_BRICK1;
1317                         return false;
1318                 }
1319                 case "deactivate":
1320                 {
1321                         strfree(minigame.message);
1322                         return false;
1323                 }
1324                 case "key_pressed":
1325                 {
1326                         if(minigame.minigame_flags & BD_TURN_MOVE)
1327                         {
1328                                 if(bd_normal_move(minigame, ...(0,int)))
1329                                         return true;
1330                         }
1331
1332                         if(minigame.minigame_flags & BD_TURN_EDIT)
1333                         {
1334                                 if(bd_editor_move(minigame, ...(0,int)))
1335                                         return true;
1336                         }
1337
1338                         return false;
1339                 }
1340                 case "mouse_pressed":
1341                 {
1342                         if(minigame.minigame_flags & BD_TURN_EDIT)
1343                         {
1344                                 if(...(0,int) == K_MOUSE1)
1345                                 {
1346                                         bd_editor_make_move(minigame, "");
1347                                         return true;
1348                                 }
1349
1350                                 if(...(0,int) == K_MOUSE2)
1351                                 {
1352                                         bd_editor_fill(minigame);
1353                                         return true;
1354                                 }
1355                         }
1356
1357                         return false;
1358                 }
1359                 case "mouse_moved":
1360                 {
1361                         if(minigame.minigame_flags & BD_TURN_EDIT)
1362                         {
1363                                 vector mouse_pos = minigame_hud_normalize(mousepos,bd_boardpos,bd_boardsize);
1364                                 bd_set_curr_pos(minigame_tile_name(mouse_pos,BD_LET_CNT,BD_NUM_CNT));
1365                                 if ( ! bd_valid_tile(bd_curr_pos) )
1366                                         bd_set_curr_pos("");
1367                         }
1368                         return true;
1369                 }
1370                 case "network_receive":
1371                 {
1372                         entity sent = ...(0,entity);
1373                         int sf = ...(1,int);
1374                         if ( sent.classname == "minigame" )
1375                         {
1376                                 if ( sf & MINIG_SF_UPDATE )
1377                                 {
1378                                         strcpy(sent.message, bd_turn_to_string(sent.minigame_flags));
1379                                         //if ( sent.minigame_flags & minigame_self.team )
1380                                                 //minigame_prompt();
1381                                 }
1382                         }
1383                         else if(sent.classname == "minigame_board_piece")
1384                         {
1385                                 if(sf & MINIG_SF_UPDATE)
1386                                 {
1387                                         int letter = ReadByte();
1388                                         int number = ReadByte();
1389                                         strcpy(sent.netname, minigame_tile_buildname(letter, number));
1390
1391                                         sent.bd_tiletype = ReadByte();
1392
1393                                         sent.bd_dir = ReadByte();
1394                                 }
1395                         }
1396                         else if(sent.classname == "minigame_player" && (sf & BD_SF_PLAYERMOVES))
1397                                 sent.bd_moves = ReadShort(); // make this a byte when possible
1398
1399                         return false;
1400                 }
1401                 case "menu_show":
1402                 {
1403                         HUD_MinigameMenu_CustomEntry(...(0,entity),_("Next Level"),"next");
1404                         HUD_MinigameMenu_CustomEntry(...(0,entity),_("Restart"),"restart");
1405                         HUD_MinigameMenu_CustomEntry(...(0,entity),_("Editor"),"edit");
1406                         HUD_MinigameMenu_CustomEntry(...(0,entity),_("Save"),"save");
1407                         return false;
1408                 }
1409                 case "menu_click":
1410                 {
1411                         if(...(0,string) == "next")
1412                                 minigame_cmd("next");
1413                         if(...(0,string) == "restart")
1414                                 minigame_cmd("restart");
1415                         if(...(0,string) == "edit")
1416                                 minigame_cmd("edit");
1417                         if(...(0,string) == "save")
1418                                 minigame_cmd("save");
1419                         return false;
1420                 }
1421         }
1422
1423         return false;
1424 }
1425
1426 #endif