src/GarbageGenerator.cxx

   1 /*
   2  * GarbageGenerator.cxx
   3  * Daniel Nelson - 8/25/0
   4  *
   5  * Copyright (C) 2000  Daniel Nelson
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20  *
  21  * Daniel Nelson - aluminumangel.org
  22  * 174 W. 18th Ave.
  23  * Columbus, OH  43210
  24  *
  25  * Displays and sends garbage to the opponent.
  26  */
  27
  28 #include <iostream>
  29
  30 using namespace std;
  31
  32 #include "Game.h"
  33 #include "GarbageGenerator.h"
  34 #include "Block.h"
  35 #include "BlockManager.h"
  36 #include "Garbage.h"
  37 #include "GarbageManager.h"
  38 #include "ComboTabulator.h"
  39 #include "Communicator.h"
  40 #include "SparkleManager.h"
  41 #include "SignManager.h"
  42 #include "ComputerPlayer.h"
  43
  44 GarbageQueueElement GarbageGenerator::garbage_queue[GC_GARBAGE_QUEUE_SIZE];
  45 int GarbageGenerator::waiting_count;
  46
  47 void GarbageGenerator::gameStart (   )
  48 {
  49   waiting_count = 0;
  50   for (int n = GC_GARBAGE_QUEUE_SIZE; n--; )
  51     garbage_queue[n].active = false;
  52 }
  53
  54 void GarbageGenerator::comboElimination ( ComboTabulator &combo )
  55 {
  56   int sibling = (combo.multiplier > 1 ? 1 : 0);
  57
  58   // used by blocks to determine death spark number
  59   combo.latest_magnitude = combo.special_magnitude + combo.magnitude
  60    + combo.multiplier - 1;
  61
  62   // send the special garbage
  63
  64   bool special_sign = true;
  65   for (int n = BF_NUMBER_SPECIAL; n--; ) {
  66     if (combo.special[n]) {
  67       special_sign = false;
  68       SignManager::createSign(combo.x, combo.y, ST_SPECIAL, n + 1);
  69
  70       if (BlockManager::isColorlessCode(n))
  71         combo.special_magnitude -= combo.special[n];
  72
  73       while (combo.special[n]--) {
  74         sendSpecialGarbage(GarbageManager::mapBlockCodeToGarbageFlavor(n));
  75         SparkleManager::createRewardMote(combo.x, combo.y, n + 4, sibling++);
  76       }
  77       combo.special[n] = 0;
  78     }
  79   }
  80
  81   // send the gray garbage
  82
  83   if (combo.special_magnitude >= GC_MIN_PATTERN_LENGTH) {
  84     if (special_sign)
  85       SignManager::createSign(combo.x, combo.y, ST_SPECIAL, 0);
  86
  87     combo.special_magnitude -= GC_MIN_PATTERN_LENGTH - 2;
  88     while (--combo.special_magnitude) {
  89
  90       sendSpecialGarbage(GF_GRAY);
  91       SparkleManager::createRewardMote(combo.x, combo.y, 3, sibling++);
  92     }
  93
  94   } else
  95     combo.special_magnitude = 0;
  96
  97   // send the normal garbage
  98
  99   if (combo.magnitude > GC_MIN_PATTERN_LENGTH) {
 100     SignManager::createSign(combo.x, combo.y, ST_MAGNITUDE,
 101      combo.magnitude - 4);
 102
 103     if (combo.magnitude <= GC_PLAY_WIDTH) {
 104
 105       sendGarbage(1, combo.magnitude - 1, GF_NORMAL);
 106       SparkleManager::createRewardMote(combo.x, combo.y,
 107        combo.magnitude - 4, sibling++);
 108
 109     } else if (combo.magnitude < 2 * GC_PLAY_WIDTH - 1) {
 110
 111       sendGarbage(1, combo.magnitude - (combo.magnitude >> 1),
 112        GF_NORMAL);
 113       SparkleManager::createRewardMote(combo.x, combo.y,
 114        combo.magnitude - (combo.magnitude >> 1) - 3, sibling++);
 115
 116       sendGarbage(1, combo.magnitude >> 1, GF_NORMAL);
 117       SparkleManager::createRewardMote(combo.x, combo.y,
 118        (combo.magnitude >> 1) - 3, sibling++);
 119
 120     } else {
 121       combo.magnitude += GC_MIN_PATTERN_LENGTH;
 122       while (combo.magnitude > GC_PLAY_WIDTH - 1) {
 123
 124         sendGarbage(1, GC_PLAY_WIDTH - 1, GF_NORMAL);
 125         SparkleManager::createRewardMote(combo.x, combo.y,
 126          GC_PLAY_WIDTH - 4, sibling++);
 127
 128         combo.magnitude -= GC_PLAY_WIDTH - 1;
 129       }
 130
 131       if (combo.magnitude >= GC_MIN_PATTERN_LENGTH) {
 132
 133         sendGarbage(1, combo.magnitude, GF_NORMAL);
 134         SparkleManager::createRewardMote(combo.x, combo.y,
 135          combo.magnitude - 3, sibling);
 136       }
 137     }
 138   }
 139
 140   combo.magnitude = 0;
 141 }
 142
 143 void GarbageGenerator::comboComplete ( ComboTabulator &combo )
 144 {
 145   // send the multiplier garbage
 146   if (combo.multiplier > 1)
 147     sendGarbage(combo.multiplier - 1, GC_PLAY_WIDTH, GF_NORMAL);
 148 }
 149
 150 void GarbageGenerator::addToQueue ( CommunicationBuffer &buffer )
 151 {
 152         addToQueue(buffer.garbage, buffer.count);
 153 }
 154
 155 void GarbageGenerator::addToQueue (uint32 height, uint32 width, uint32 flavor, uint32 stamp)
 156 {
 157   assert(height <= GC_PLAY_HEIGHT);
 158   assert(width  <= GC_PLAY_WIDTH);
 159   if (!GarbageManager::isSpecialFlavor(flavor))
 160     dealLocalGarbage(height, width, flavor, stamp);
 161   else
 162     dealSpecialLocalGarbage(flavor, stamp);
 163 }
 164
 165 void GarbageGenerator::addToQueue ( GarbageQueueElement &element )
 166 {
 167   int stamp = Game::time_step;
 168   GarbageQueueElement e = element;
 169   addToQueue(e.height, e.width, e.flavor, stamp);
 170 }
 171
 172 void GarbageGenerator::addToQueue ( BufferElement *garbage, size_t size ) {
 173         for (size_t n = 0; n < size; n++) {
 174     BufferElement e = garbage[n];
 175     addToQueue(e.height, e.width, e.flavor, e.time_stamp);
 176   }
 177 }
 178
 179 void GarbageGenerator::dealLocalGarbage ( int height, int width, int flavor,
 180  int time_stamp )
 181 /*
 182  * Used for solo games.
 183  */
 184 {
 185   if (waiting_count == GC_GARBAGE_QUEUE_SIZE) return;
 186
 187   int i = 0;
 188   while (garbage_queue[i].active) i++;
 189
 190   garbage_queue[i].active = true;
 191   garbage_queue[i].height = height;
 192   garbage_queue[i].width = width;
 193   garbage_queue[i].flavor = flavor;
 194   garbage_queue[i].alarm = determineDropTime(time_stamp);
 195
 196   waiting_count++;
 197 }
 198
 199 void GarbageGenerator::dealSpecialLocalGarbage ( int flavor, int time_stamp )
 200 {
 201   switch (flavor) {
 202   case GF_GRAY: case GF_WHITE: case GF_COLOR_2:
 203     dealLocalGarbage(1, GC_PLAY_WIDTH, flavor, time_stamp);
 204     break;
 205
 206   case GF_BLACK:
 207     dealLocalGarbage(1, 2, GF_BLACK, time_stamp);
 208     break;
 209
 210   case GF_COLOR_1:
 211     if (Random::chanceIn2(4)) {
 212       dealLocalGarbage(2, 2, GF_COLOR_1, time_stamp);
 213       for (int n = 1 + Random::number(3); n--; )
 214         dealLocalGarbage(1, 1, GF_COLOR_1, time_stamp);
 215     } else
 216       for (int n = 5 + Random::number(3); n--; )
 217         dealLocalGarbage(1, 1, GF_COLOR_1, time_stamp);
 218     break;
 219
 220   case GF_COLOR_3:
 221     dealLocalGarbage(1, 4, GF_COLOR_3, time_stamp);
 222     break;
 223
 224   case GF_COLOR_4:
 225     dealLocalGarbage(1, 3, GF_COLOR_4, time_stamp);
 226     break;
 227
 228   case GF_COLOR_5:
 229     dealLocalGarbage(3, 2, GF_COLOR_5, time_stamp);
 230     break;
 231   }
 232 }
 233
 234 void GarbageGenerator::timeStep (   )
 235 {
 236   int c = waiting_count;
 237
 238   for (int n = 0; c; n++)
 239     if (garbage_queue[n].active) {
 240       GarbageQueueElement &e = garbage_queue[n];
 241       c--;
 242
 243       // if this garbage's ready, let's try to drop it
 244       if (e.alarm < Game::time_step) {
 245         // if we successfully drop it, take it away
 246         if (GarbageManager::newFallingGarbage(e.height, e.width, e.flavor)) {
 247           waiting_count--;
 248           e.active = false;
 249
 250         // otherwise, reset the alarm
 251         } else
 252           e.alarm = Game::time_step + GC_AVERAGE_GARBAGE_DROP_DELAY;
 253       }
 254     }
 255 }
 256
 257 void GarbageGenerator::sendGarbage ( int height, int width, int flavor )
 258 {
 259   if (!(MetaState::mode & CM_SOLO))
 260     Communicator::sendGarbage(height, width, flavor);
 261   else
 262     if (MetaState::mode & CM_AI)
 263       ComputerPlayer::addGarbage(height, width, flavor);
 264     else
 265       dealLocalGarbage(height, width, flavor, Game::time_step);
 266 }
 267
 268 void GarbageGenerator::sendSpecialGarbage ( int flavor )
 269 {
 270   if (!(MetaState::mode & CM_SOLO))
 271     Communicator::sendGarbage(0, 0, flavor);
 272   else
 273     if (MetaState::mode & CM_AI)
 274       ComputerPlayer::addGarbage(1, GC_PLAY_WIDTH, flavor);
 275     else
 276       dealSpecialLocalGarbage(flavor, Game::time_step);
 277 }