src/BlockManager.cxx

   1 /*
   2  * BlockManager.cxx
   3  * Daniel Nelson - 8/24/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  * Allocates and frees blocks.
  26  */
  27
  28 using namespace std;
  29
  30 #include "Game.h"
  31 #include "BlockManager.h"
  32 #include "ComboTabulator.h"
  33 #include "Random.h"
  34 #include "X.h"
  35
  36 int BlockManager::block_count;
  37 Block BlockManager::blockStore[GC_BLOCK_STORE_SIZE];
  38 bool BlockManager::storeMap[GC_BLOCK_STORE_SIZE];
  39
  40 int BlockManager::last_flavor_a, BlockManager::second_to_last_flavor_a;
  41 int BlockManager::last_flavor_c, BlockManager::second_to_last_flavor_c;
  42 int BlockManager::last_row_a[GC_PLAY_WIDTH];
  43 int BlockManager::second_to_last_row_a[GC_PLAY_WIDTH];
  44 int BlockManager::last_row_c[GC_PLAY_WIDTH];
  45 int BlockManager::second_to_last_row_c[GC_PLAY_WIDTH];
  46 int BlockManager::special_block_location;
  47
  48 int BlockManager::next_pop_direction;
  49
  50 void BlockManager::gameStart (   )
  51 {
  52   block_count = 0;
  53   for (int n = GC_BLOCK_STORE_SIZE; n--; ) {
  54     storeMap[n] = false;
  55     blockStore[n].id = n;
  56   }
  57
  58   last_flavor_a = second_to_last_flavor_a = 0;
  59   last_flavor_c = second_to_last_flavor_c = 0;
  60   for (int x = GC_PLAY_WIDTH; x--; ) {
  61     last_row_a[x] = 0;
  62     second_to_last_row_a[x] = 0;
  63     last_row_c[x] = 0;
  64     second_to_last_row_c[x] = 0;
  65   }
  66
  67   next_pop_direction = (1 << 0);
  68
  69   special_block_location = -1;
  70 }
  71
  72 void BlockManager::newAwakingBlock ( int x, int y, int pop_delay,
  73  int awake_delay, ComboTabulator *combo, int pop_color )
  74 {
  75   int flavor;
  76
  77   do {
  78     flavor = Random::number(BF_NUMBER_NORMAL);
  79   } while ((flavor == last_flavor_a
  80    && last_flavor_a == second_to_last_flavor_a)
  81    || (flavor == last_row_a[x] && last_row_a[x] == second_to_last_row_a[x]));
  82
  83   second_to_last_row_a[x] = last_row_a[x];
  84   last_row_a[x] = flavor;
  85
  86   second_to_last_flavor_a = last_flavor_a;
  87   last_flavor_a = flavor;
  88
  89   newBlock(x, y, flavor, pop_delay, awake_delay, combo, pop_color);
  90 }
  91
  92 void BlockManager::newCreepBlock ( int x )
  93 {
  94   int flavor = 0;
  95
  96   if (x != special_block_location) {
  97     do
  98       flavor = Random::number(BF_NUMBER_NORMAL);
  99     while ((flavor == last_flavor_c && last_flavor_c
 100      == second_to_last_flavor_c) || (flavor == last_row_c[x] && last_row_c[x]
 101      == second_to_last_row_c[x]));
 102
 103     second_to_last_row_c[x] = last_row_c[x];
 104     last_row_c[x] = flavor;
 105
 106     second_to_last_flavor_c = last_flavor_c;
 107     last_flavor_c = flavor;
 108
 109   } else {
 110     int base_flavor = 0;
 111
 112     if (!(MetaState::mode & CM_X)) {
 113       if ((BF_GRAY == last_flavor_c && last_flavor_c
 114        == second_to_last_flavor_c) || (BF_GRAY == last_row_c[x]
 115        && last_row_c[x] == second_to_last_row_c[x]))
 116         do
 117           flavor = Random::number(BF_NUMBER_NORMAL);
 118         while ((flavor == last_flavor_c && last_flavor_c
 119          == second_to_last_flavor_c) || (flavor == last_row_c[x]
 120          && last_row_c[x] == second_to_last_row_c[x]));
 121       else
 122         flavor = BF_GRAY;
 123       base_flavor = flavor;
 124
 125     } else {
 126       do {
 127         switch (Random::number(10)) {
 128         case 0: case 1: case 2:
 129           base_flavor = flavor = BF_GRAY;
 130           break;
 131         case 3: case 4: case 5: case 6:
 132           base_flavor = mapSpecialColorFlavorToColor(flavor
 133            = Random::number(BF_NUMBER_NORMAL) + BF_SPECIAL_COLOR_1);
 134           if (!X::specialColorAllowed())
 135             flavor = base_flavor;
 136           break;
 137         case 7: case 8:
 138           if (X::wildAllowed())
 139             base_flavor = flavor = BF_WILD;
 140           else
 141             base_flavor = flavor = BF_GRAY;
 142           break;
 143         case 9:
 144           if (Random::chanceIn2(2))
 145             flavor = BF_BLACK;
 146           else
 147             flavor = BF_WHITE;
 148           base_flavor = mapFlavorToBaseFlavor(flavor);
 149           break;
 150         }
 151       } while ((base_flavor == last_flavor_c && last_flavor_c
 152        == second_to_last_flavor_c) || (base_flavor == last_row_c[x]
 153        && last_row_c[x] == second_to_last_row_c[x]));
 154     }
 155
 156     second_to_last_row_c[x] = last_row_c[x];
 157     last_row_c[x] = base_flavor;
 158
 159     second_to_last_flavor_c = last_flavor_c;
 160     last_flavor_c = base_flavor;
 161   }
 162
 163   newBlock(x, 0, flavor);
 164 }