Map.cpp

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