Map.cpp

   1 #include <cstdio>
   2
   3 #include "Map.h"
   4 #include "Game.h"
   5 #include "Tile.h"
   6 #include "globalfunc.h"
   7 #include "Objects.h"
   8
   9 namespace botor
  10 {
  11
  12         Map::Map() : tiles( MAP_WIDTH, std::vector<Tile>( MAP_HEIGHT ) ), robots()
  13         {}
  14
  15         void Map::Initialize()
  16         {
  17                 for( int i = 0; i < 10; i++ )
  18                 {
  19                         robots.push_back( new Robot( i+3, 12 ) );
  20                 }
  21                         robots.push_back( new Robot( 19, 14 ) );
  22
  23                 objects.push_back( new OAcid( 5, 2 ) );
  24                 objects.push_back( new OAcid( 6, 2 ) );
  25                 objects.push_back( new OAcid( 7, 2 ) );
  26                 objects.push_back( new OAcid( 5, 3 ) );
  27
  28                 objects.push_back( new OBlueman( 5,4 ) );
  29         }
  30
  31         bool Map::load( const char *fmap )
  32         {
  33                 char tilefile[255];
  34                 FILE *in = fopen( fmap, "r" );
  35                 if( !in )
  36                         return false;
  37
  38                 fscanf( in, "%s", (char*)tilefile );
  39
  40                 if( !tileset.load( tilefile ) )
  41                         return false;
  42
  43                 for( unsigned int y = 0; y < MAP_HEIGHT; y++ )
  44                 {
  45                         for( unsigned int x = 0; x < MAP_WIDTH; x++ )
  46                         {
  47                                 Tile temp;
  48                                 temp.moving = false;
  49                                 temp.acid = 0;
  50
  51                                 fscanf( in, "%d:%d ", &temp.tileID, &temp.typeMask );
  52
  53                                 tiles[x][y] = temp;
  54                         }
  55                         fscanf( in, "\n" );
  56                 }
  57
  58                 fclose( in );
  59
  60                 return true;
  61
  62         }
  63
  64         void Map::unload()
  65         {
  66                 tileset.unload();
  67         }
  68
  69         void Map::Update()
  70         {
  71                 for( unsigned int x = 0; x < MAP_WIDTH; x++ )
  72                 {
  73                         for( unsigned int y = 0; y < MAP_HEIGHT; y++ )
  74                         {
  75                                 Tile &t = tiles[x][y];
  76                                 if( t.moving )
  77                                 {
  78
  79                                         Sint16 sx,sy;
  80                                         Map::transformM2S( x, y, sx, sy );
  81                                         if( dst( t.movementX, t.movementY, (float)sx, (float)sy ) < 0.5 )
  82                                         {
  83                                                 t.moving = false;
  84                                         }
  85                                         else
  86                                         {
  87                                                 float dirX, dirY;
  88
  89                                                 dirX = sign( sx - t.movementX ) * Player::PLAYER_SPEED;
  90                                                 dirY = sign( sy - t.movementY ) * Player::PLAYER_SPEED;
  91
  92                                                 t.movementX += dirX;
  93                                                 t.movementY += dirY;
  94                                         }
  95                                 }
  96
  97                                 if( t.acid > 0 )
  98                                 {
  99                                         if( time(0) > t.timer )
 100                                         {
 101                                                 t.acid--;
 102                                                 if(!t.acid)
 103                                                         RemoveTile(x,y);
 104                                                 t.timer = time(0)+1;
 105                                         }
 106
 107                                 }
 108                         }
 109                 }
 110
 111                 for( unsigned int i = 0; i < robots.size(); i++ )
 112                 {
 113                         Robot *r = robots[i];
 114
 115                         r->Update();
 116
 117                         if( !r->isAlive() )
 118                         {
 119                                 robots.erase( robots.begin() + i );
 120                                 delete r;
 121                         }
 122                 }
 123
 124                 for( unsigned int i = 0; i < objects.size(); i++ )
 125                 {
 126                         Object *o = objects[i];
 127
 128                         o->Update();
 129
 130                         if( o->getLocation() != Object::LOC_GROUND )
 131                         {
 132                                 objects.erase( objects.begin() + i );
 133                         }
 134                 }
 135
 136         }
 137
 138         void Map::Draw( )
 139         {
 140
 141                 for( unsigned int x = 0; x < MAP_WIDTH; x++ )
 142                 {
 143                         for( unsigned int y = 0; y < MAP_HEIGHT; y++ )
 144                         {
 145                                 Tile &t = tiles[x][y];
 146
 147                                 if( t.tileID == -1 )
 148                                         continue;
 149
 150                                 if( t.moving )
 151                                 {
 152                                         tileset.Draw( (Sint16)t.movementX, (Sint16)t.movementY, t.tileID );
 153                                 }
 154                                 else if( t.acid > 0 )
 155                                 {
 156                                         Sint16 sx,sy;
 157                                         Map::transformM2S( (Uint8)x, (Uint8)y, sx, sy );
 158
 159                                         tileset.Draw( sx, sy, 5+(4-t.acid) );
 160
 161                                 }
 162                                 else
 163                                 {
 164                                         Sint16 sx,sy;
 165                                         Map::transformM2S( (Uint8)x, (Uint8)y, sx, sy );
 166                                         tileset.Draw( sx, sy, tiles[x][y].tileID );
 167                                 }
 168
 169                         }
 170                 }
 171
 172
 173                 for( std::vector<Object*>::iterator o = objects.begin(); o != objects.end(); o++ )
 174                 {
 175                         if((*o)->getLocation() == Object::LOC_GROUND )
 176                                 (*o)->Draw();
 177                 }
 178
 179                 for( std::vector<Robot*>::iterator r = robots.begin(); r != robots.end(); r++ )
 180                 {
 181                         (*r)->Draw();
 182
 183                 }
 184
 185
 186         }
 187
 188         Tile *Map::tileAt( Uint8 mapX, Uint8 mapY )
 189         {
 190                 return &tiles[mapX][mapY];
 191         }
 192
 193         bool Map::PushPushable( Uint8 fromX, Uint8 fromY, Uint8 dirX, Uint8 dirY )
 194         {
 195                 Uint8 toX = fromX+dirX;
 196                 Uint8 toY = fromY+dirY;
 197
 198                 Sint16 posX, posY;
 199
 200                 if( isBitSet( tiles[toX][toY].typeMask, Tile::TILE_NOTPUSHABLE ) ||
 201                         isBitSet( tiles[toX][toY].typeMask, Tile::TILE_WALL ) ||
 202                         isRobotOn( toX, toY ) )
 203                 {
 204                         return false;
 205                 }
 206
 207                 if( isBitSet( tiles[toX][toY].typeMask, Tile::TILE_PUSHABLE ) )
 208                 {
 209                         if(!PushPushable( toX, toY, dirX, dirY ) )
 210                         {
 211                                 return false;
 212                         }
 213                 }
 214
 215                 Map::transformM2S( fromX, fromY, posX, posY );
 216
 217                 tiles[toX][toY] = tiles[fromX][fromY];
 218                 tiles[toX][toY].moving = true;
 219                 tiles[toX][toY].movementX = (float)posX;
 220                 tiles[toX][toY].movementY = (float)posY;
 221
 222                 RemoveTile( fromX, fromY );
 223
 224                 return true;
 225
 226         }
 227
 228         void Map::RemoveTile( Uint8 mapX, Uint8 mapY )
 229         {
 230                 tiles[mapX][mapY].typeMask = Tile::TILE_WALKABLE;
 231                 tiles[mapX][mapY].tileID = -1;
 232                 tiles[mapX][mapY].moving = false;
 233                 tiles[mapX][mapY].acid = 0;
 234         }
 235
 236         void Map::transformM2S( Uint8 mapX, Uint8 mapY, Sint16 &x, Sint16 &y )
 237         {
 238                 x = mapX*20;
 239                 y = mapY*20 + MAP_SHIFT;
 240         }
 241
 242         bool Map::isRobotOn( Uint8 mapX, Uint8 mapY )
 243         {
 244                 for( std::vector<Robot*>::iterator r = robots.begin(); r != robots.end(); r++ )
 245                 {
 246                         if( (*r)->getMapX() == mapX && (*r)->getMapY() == mapY )
 247                                 return true;
 248                 }
 249                 return false;
 250         }
 251
 252         void Map::Acid( Uint8 cX, Uint8 cY )
 253         {
 254                 for( Uint8 y = cY-1; y <= cY+1; y++ )
 255                 {
 256                         for( Uint8 x = cX-1; x <= cX+1; x++ )
 257                         {
 258                                 Tile &t = tiles[x][y];
 259                                 if( isBitSet( t.typeMask, Tile::TILE_WALL ) &&
 260                                         !isBitSet( t.typeMask, Tile::TILE_SOLID) &&
 261                                         !t.acid )
 262                                 {
 263                                         t.acid = 4;
 264                                         t.timer = time(0)+1;
 265                                 }
 266                         }
 267                 }
 268         }
 269
 270         Object *Map::getObject( Uint8 X, Uint8 Y )
 271         {
 272                 for( std::vector<Object*>::iterator o = objects.begin(); o != objects.end(); o++ )
 273                 {
 274                         if((*o)->getLocation() == Object::LOC_GROUND )
 275                         {
 276                                 if( (*o)->getMapX() == X && (*o)->getMapY() == Y )
 277                                         return *o;
 278                         }
 279                 }
 280
 281                 return 0;
 282         }
 283
 284         void Map::insertObject( Object *o, Uint8 X, Uint8 Y )
 285         {
 286                 o->setLocation( Object::LOC_GROUND );
 287                 o->Teleport( X, Y );
 288
 289                 objects.push_back( o );
 290         }
 291
 292 }
 293