src/ComputerPlayerAI.cxx

   1 /*
   2  * ComputerPlayerAI.cxx
   3  * Andrew Sayman - 3/27/05
   4  *
   5  * Copyright (C) 2005  Andrew Sayman
   6  * Copyright (C) 2005  Kevin Webb
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21  */
  22 #include "ComputerPlayerAI.h"
  23 #include "Score.h"
  24 #include "Garbage.h"
  25 #include "GarbageGenerator.h"
  26 #include "Game.h"
  27
  28 #include <cassert>
  29
  30 #define loop(v,m) for(int v = 0; v<(m); v++)
  31 #define loopi(m) loop(i,m)
  32
  33 /* Begin ComputerPlayerAI */
  34 ComputerPlayerAI::ComputerPlayerAI ()
  35 {
  36   resetAlarm();
  37   last_shatter_height = 0;
  38   state = AI_WAITING;
  39   queue = new GarbageQueue();
  40 }
  41
  42 int ComputerPlayerAI::baseSteps()
  43 {
  44   return GC_STEPS_PER_SECOND;
  45 }
  46
  47 int ComputerPlayerAI::stateSteps()
  48 {
  49   if (state == AI_WAITING) {
  50     return (GC_CREEP_ADVANCE_VELOCITY * 5) // increase five lines
  51       + (GC_DYING_DELAY * 5); // five combos
  52   }
  53   if (state == AI_SHATTERING) {
  54     return garbageShatterDelay();
  55   }
  56 }
  57
  58 int ComputerPlayerAI::lossHeight()
  59 {
  60   return 4;
  61 }
  62
  63 void ComputerPlayerAI::resetAlarm()
  64 {
  65   last_time = Game::time_step;
  66 }
  67
  68 int ComputerPlayerAI::alarm()
  69 {
  70   return last_time + baseSteps() + stateSteps();
  71 }
  72
  73 int ComputerPlayerAI::garbageShatterDelay()
  74 {
  75   int delay = GC_INITIAL_POP_DELAY + (last_shatter_height * GC_PLAY_WIDTH * GC_INTERNAL_POP_DELAY) + GC_FINAL_POP_DELAY;
  76   return delay;
  77 }
  78
  79 GarbageQueue *ComputerPlayerAI::garbageQueue ()
  80 {
  81   return queue;
  82 }
  83
  84 GarbageQueue *ComputerPlayerAI::garbageAmount( )
  85 {
  86   GarbageQueue *q = new GarbageQueue();
  87   size_t const size = 20;
  88   size_t i = 0;
  89   BufferElement garbage;
  90   int working_height = GC_SAFE_HEIGHT - 1 - garbageQueue()->height();
  91   int num_grays, num_normals;
  92
  93   MESSAGE("Hard garbageAmount");
  94
  95   if (working_height > 0) {
  96     num_grays = working_height % 3;
  97   } else {
  98     num_grays = 0;
  99   }
 100
 101   num_normals = garbageQueue()->height() + working_height;
 102
 103   LOG("garbageQueue height " << garbageQueue()->height());
 104   LOG("grays: " << num_grays << " normals: " << num_normals);
 105   loopi(num_grays)
 106     q->add(1, 6, GF_GRAY);
 107
 108   int norm_div = num_normals / 3;
 109   int norm_mod = num_normals % 3;
 110   int more_gray = norm_mod / 2;
 111   LOG("div: " << norm_div << " mod: " << norm_mod << " gray: " << more_gray);
 112   if (norm_div > 0) q->add(norm_div, 6, GF_NORMAL);
 113   loopi(norm_mod) q->add(1, 6, GF_NORMAL);
 114   //loopi(more_gray) q->add(1, 6, GF_GRAY);
 115
 116   shatter();
 117   return q;
 118 }
 119
 120 void ComputerPlayerAI::shatter()
 121 {
 122   MESSAGE("Resetting garbageQueue " << garbageQueue()->height());
 123   if (garbageQueue()->height() > 0) {
 124     state = AI_SHATTERING;
 125     int gray_height = garbageQueue()->specialHeight();
 126     last_shatter_height = garbageQueue()->removeWithSpecials();
 127     MESSAGE(last_shatter_height << " shattered and " << garbageQueue()->height() << " remaining.");
 128     if (gray_height != 0) assert(garbageQueue()->height() != 0);
 129     loopi(last_shatter_height) {
 130       if (Random::chanceIn(GC_GARBAGE_TO_GARBAGE_SHATTER)) {
 131         garbageQueue()->add(1, 6, GF_NORMAL);
 132         MESSAGE("Adding garbage on AI shatter " << garbageQueue()->height());
 133       }
 134     }
 135   } else {
 136     state = AI_WAITING;
 137     last_shatter_height = 0;
 138   }
 139 }
 140
 141 bool ComputerPlayerAI::determineLoss()
 142 {
 143   GarbageQueue *queue = garbageQueue();
 144   static int height = queue->height();
 145   int h = queue->height();
 146   if (h != height) {
 147     MESSAGE("Height change in determine loss old: " << height << " new: " << h);
 148     height = h;
 149   }
 150   return queue->height() > lossHeight();
 151 }
 152
 153 /* End ComputerPlayerAI */
 154
 155 int EasyAI::baseSteps()
 156 {
 157   //cout << "easy baseSteps" << endl;
 158   int a = ComputerPlayerAI::baseSteps() * 15;
 159   return a;
 160 }
 161
 162 int EasyAI::lossHeight()
 163 {
 164   return 4;
 165 }
 166
 167 int MediumAI::baseSteps()
 168 {
 169   return ComputerPlayerAI::baseSteps() * 10;
 170 }
 171
 172 int MediumAI::lossHeight()
 173 {
 174   return 10;
 175 }
 176
 177 /* Begin HardAI */
 178 int HardAI::baseSteps()
 179 {
 180   return ComputerPlayerAI::baseSteps() * 5;
 181 }
 182
 183 int HardAI::lossHeight()
 184 {
 185   return 20;
 186 }
 187
 188 /* End HardAI */