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         return GC_DYING_DELAY * 5;
  57 }
  58
  59 int ComputerPlayerAI::lossHeight()
  60 {
  61   return 4;
  62 }
  63
  64 void ComputerPlayerAI::resetAlarm()
  65 {
  66   last_time = Game::time_step;
  67 }
  68
  69 int ComputerPlayerAI::alarm()
  70 {
  71   return last_time + baseSteps() + stateSteps();
  72 }
  73
  74 int ComputerPlayerAI::garbageShatterDelay()
  75 {
  76   int delay = GC_INITIAL_POP_DELAY + (last_shatter_height * GC_PLAY_WIDTH * GC_INTERNAL_POP_DELAY) + GC_FINAL_POP_DELAY;
  77   return delay;
  78 }
  79
  80 GarbageQueue *ComputerPlayerAI::garbageQueue ()
  81 {
  82   return queue;
  83 }
  84
  85 GarbageQueue *ComputerPlayerAI::garbageAmount( )
  86 {
  87   GarbageQueue *q = new GarbageQueue();
  88   int working_height = GC_SAFE_HEIGHT - 1 - garbageQueue()->height();
  89   int num_grays, num_normals;
  90
  91   MESSAGE("Hard garbageAmount");
  92
  93   if (working_height > 0) {
  94     num_grays = working_height % 3;
  95   } else {
  96     num_grays = 0;
  97   }
  98
  99   num_normals = garbageQueue()->height() + working_height;
 100
 101   LOG("garbageQueue height " << garbageQueue()->height());
 102   LOG("grays: " << num_grays << " normals: " << num_normals);
 103   loopi(num_grays)
 104     q->add(1, 6, GF_GRAY);
 105
 106   int norm_div = num_normals / 3;
 107   int norm_mod = num_normals % 3;
 108   int more_gray = norm_mod / 2;
 109   LOG("div: " << norm_div << " mod: " << norm_mod << " gray: " << more_gray);
 110   if (norm_div > 0) q->add(norm_div, 6, GF_NORMAL);
 111   loopi(norm_mod) q->add(1, 6, GF_NORMAL);
 112   //loopi(more_gray) q->add(1, 6, GF_GRAY);
 113
 114   shatter();
 115   return q;
 116 }
 117
 118 void ComputerPlayerAI::shatter()
 119 {
 120   MESSAGE("Resetting garbageQueue " << garbageQueue()->height());
 121   if (garbageQueue()->height() > 0) {
 122     state = AI_SHATTERING;
 123     int gray_height = garbageQueue()->specialHeight();
 124     last_shatter_height = garbageQueue()->removeWithSpecials();
 125     MESSAGE(last_shatter_height << " shattered and " << garbageQueue()->height() << " remaining grays:" << gray_height);
 126     loopi(last_shatter_height) {
 127       if (Random::chanceIn(GC_GARBAGE_TO_GARBAGE_SHATTER)) {
 128         garbageQueue()->add(1, 6, GF_NORMAL);
 129         MESSAGE("Adding garbage on AI shatter " << garbageQueue()->height());
 130       }
 131     }
 132   } else {
 133     state = AI_WAITING;
 134     last_shatter_height = 0;
 135   }
 136 }
 137
 138 bool ComputerPlayerAI::determineLoss()
 139 {
 140   GarbageQueue *queue = garbageQueue();
 141   static int height = queue->height();
 142   int h = queue->height();
 143   if (h != height) {
 144     MESSAGE("Height change in determine loss old: " << height << " new: " << h);
 145     height = h;
 146   }
 147   return queue->height() > lossHeight();
 148 }
 149
 150 /* End ComputerPlayerAI */
 151
 152 int EasyAI::baseSteps()
 153 {
 154   //cout << "easy baseSteps" << endl;
 155   int a = ComputerPlayerAI::baseSteps() * 15;
 156   return a;
 157 }
 158
 159 int EasyAI::lossHeight()
 160 {
 161   return 4;
 162 }
 163
 164 int MediumAI::baseSteps()
 165 {
 166   return ComputerPlayerAI::baseSteps() * 10;
 167 }
 168
 169 int MediumAI::lossHeight()
 170 {
 171   return 10;
 172 }
 173
 174 /* Begin HardAI */
 175 int HardAI::baseSteps()
 176 {
 177   return ComputerPlayerAI::baseSteps() * 5;
 178 }
 179
 180 int HardAI::lossHeight()
 181 {
 182   return 20;
 183 }
 184
 185 /* End HardAI */