Tile Class Reference

#include <tile.h>

Inheritance diagram for Tile:

[legend]Collaboration diagram for Tile:

[legend]List of all members.

Public Member Functions
	Tile ()
	~Tile ()
void	Dig (const Point2i &position, const Surface &provider)
void	Dig (const Point2i &center, const uint radius)
void	PutSprite (const Point2i pos, Sprite *spr)
void	MergeSprite (const Point2i &position, Surface &provider)
void	LoadImage (Surface &ground_surface)
unsigned char	GetAlpha (const Point2i &pos) const
void	DrawTile ()
void	DrawTile_Clipped (Rectanglei clip_rectangle) const
Surface	GetPart (Rectanglei &rec)
void	CheckEmptyTiles ()
Protected Member Functions
void	InitTile (const Point2i &pSize)
void	FreeMem ()
Point2i	Clamp (const Point2i &v) const
Protected Attributes
Point2i	nbCells
unsigned int	nbr_cell
std::vector< TileItem * >	item

---

Detailed Description

Definition at line 33 of file tile.h.

---

Constructor & Destructor Documentation

Tile::Tile

(

)

Definition at line 24 of file tile.cpp.

          {
}

Tile::~Tile

(

)

Definition at line 34 of file tile.cpp.

           { 
    FreeMem();
}

Here is the call graph for this function:

---

Member Function Documentation

void Tile::CheckEmptyTiles

(

)

Definition at line 272 of file tile.cpp.

{
  for( int i = 0; i < nbCells.x * nbCells.y; i++ )
  {
    if(item[i]->IsTotallyEmpty()) continue;

    TileItem_AlphaSoftware* t = static_cast<TileItem_AlphaSoftware*>(item[i]);
    if(t->need_check_empty)
      t->CheckEmpty();
    if(t->need_delete)
   {
      // no need to display this tile as it can be deleted!
#ifdef DBG_TILE
     printf("Deleting tile %i\n",i);
#endif
      delete item[i];
      item[i] = (TileItem*)new TileItem_Empty;
    }
  }
}

Here is the caller graph for this function:

Point2i Tile::Clamp

(

const Point2i &

v

)

const [protected]

Definition at line 52 of file tile.cpp.

                                         {
        return v.clamp(Point2i(0, 0), nbCells - 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Tile::Dig	(	const Point2i &	center,
		const uint	radius
	)

Definition at line 70 of file tile.cpp.

                                                      {  
   Point2i size = Point2i(2 * (radius + EXPLOSION_BORDER_SIZE),
                          2 * (radius + EXPLOSION_BORDER_SIZE));
   Point2i position = center - Point2i(radius + EXPLOSION_BORDER_SIZE,
                                       radius + EXPLOSION_BORDER_SIZE);

   Rectanglei rect = Rectanglei(position, size);
        Point2i firstCell = Clamp(position/CELL_SIZE);
        Point2i lastCell = Clamp((position+size)/CELL_SIZE);
        Point2i c;

    for( c.y = firstCell.y; c.y <= lastCell.y; c.y++ )
    for( c.x = firstCell.x; c.x <= lastCell.x; c.x++){
            Point2i offset = center - c * CELL_SIZE;
            item[c.y*nbCells.x + c.x]->Dig(offset, radius);
        }
}

Here is the call graph for this function:

void Tile::Dig	(	const Point2i &	position,
		const Surface &	provider
	)

Definition at line 56 of file tile.cpp.

                                                         {
   Rectanglei rect = Rectanglei(position, dig.GetSize());
        Point2i firstCell = Clamp(position/CELL_SIZE);
        Point2i lastCell = Clamp((position + dig.GetSize())/CELL_SIZE);
        Point2i c;

    for( c.y = firstCell.y; c.y <= lastCell.y; c.y++ )
        for( c.x = firstCell.x; c.x <= lastCell.x; c.x++){
            Point2i offset = position - c * CELL_SIZE;

            item[c.y*nbCells.x + c.x]->Dig(offset, dig);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Tile::DrawTile

(

)

Definition at line 202 of file tile.cpp.

                    {
    Point2i firstCell = Clamp(camera.GetPosition() / CELL_SIZE);
    Point2i lastCell = Clamp((camera.GetPosition() + camera.GetSize()) / CELL_SIZE);
        Point2i i;
    for( i.y = firstCell.y; i.y <= lastCell.y; i.y++ )
        for( i.x = firstCell.x; i.x <= lastCell.x; i.x++)
          item[i.y*nbCells.x + i.x]->Draw( i );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Tile::DrawTile_Clipped

(

Rectanglei

clip_rectangle

)

const

Definition at line 211 of file tile.cpp.

{
        worldClip.SetSize( worldClip.GetSize() + 1); // mmm, y aurait t-il quelque chose qui
        // donne des zones trops petites à redessiner ?
    Point2i firstCell = Clamp(worldClip.GetPosition() / CELL_SIZE);
    Point2i lastCell  = Clamp((worldClip.GetBottomRightPoint()) / CELL_SIZE);
        Point2i c;

    for( c.y = firstCell.y; c.y <= lastCell.y; c.y++ )
        for( c.x = firstCell.x; c.x <= lastCell.x; c.x++){
                // For all selected items, clip source and destination blitting rectangles 
                        Rectanglei destRect(c * CELL_SIZE, CELL_SIZE);

                        destRect.Clip(worldClip);
                        if( destRect.Intersect( camera ) ){
                                Point2i ptDest = destRect.GetPosition() - camera.GetPosition();
                                Point2i ptSrc = destRect.GetPosition() - c * CELL_SIZE;
                        
                AppWormux::GetInstance()->video.window.Blit( item[c.y*nbCells.x + c.x]->GetSurface(), Rectanglei(ptSrc, destRect.GetSize()) , ptDest); 
                        }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Tile::FreeMem

(

)

[protected]

Definition at line 27 of file tile.cpp.

                  {
    for (uint i=0; i<nbr_cell; ++i)
        delete item[i];
    nbr_cell = 0;
    item.clear();
}

Here is the caller graph for this function:

uchar Tile::GetAlpha

(

const Point2i &

pos

)

const

Definition at line 197 of file tile.cpp.

                                            {
        int cell = pos.y / CELL_SIZE.y * nbCells.x + pos.x / CELL_SIZE.x;
    return item[cell]->GetAlpha(pos % CELL_SIZE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Surface Tile::GetPart

(

Rectanglei &

rec

)

Definition at line 234 of file tile.cpp.

{
  Surface part(rec.GetSize(), SDL_SWSURFACE|SDL_SRCALPHA, true);
  part.SetAlpha(0,0);
  part.Fill(0x00000000);
  part.SetAlpha(SDL_SRCALPHA,0);

  Point2i firstCell = Clamp(rec.GetPosition() / CELL_SIZE);
  Point2i lastCell = Clamp((rec.GetPosition() + rec.GetSize()) / CELL_SIZE);
  Point2i i = nbCells - 1;

  for( i.y = firstCell.y; i.y <= lastCell.y; i.y++ )
  for( i.x = firstCell.x; i.x <= lastCell.x; i.x++ )
  {
    if(item[i.y*nbCells.x + i.x]->IsTotallyEmpty()) continue;

    Point2i cell_pos = i * CELL_SIZE;
    Rectanglei src;
    Point2i dst;
    src.SetPosition( rec.GetPosition() - cell_pos );
    if(src.GetPositionX() < 0) src.SetPositionX(0);
    if(src.GetPositionY() < 0) src.SetPositionY(0);

    src.SetSize( rec.GetPosition() + rec.GetSize() - cell_pos - src.GetPosition());
    if(src.GetSizeX() + src.GetPositionX() > CELL_SIZE.x) src.SetSizeX(CELL_SIZE.x - src.GetPositionX());
    if(src.GetSizeY() + src.GetPositionY() > CELL_SIZE.y) src.SetSizeY(CELL_SIZE.y - src.GetPositionY());

    dst =  cell_pos - rec.GetPosition();
    if(dst.x < 0) dst.x = 0;
    if(dst.y < 0) dst.y = 0;

    item[i.y*nbCells.x + i.x]->GetSurface().SetAlpha(0, 0);
    part.Blit(item[i.y*nbCells.x + i.x]->GetSurface(), src, dst);
    item[i.y*nbCells.x + i.x]->GetSurface().SetAlpha(SDL_SRCALPHA, 0);
  }
  return part;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Tile::InitTile

(

const Point2i &

pSize

)

[protected]

Definition at line 38 of file tile.cpp.

                                       {
    nbCells = pSize / CELL_SIZE;

    if( (pSize.x % CELL_SIZE.x) != 0 )
        nbCells.x++;

    if( (pSize.y % CELL_SIZE.y) != 0 )
        nbCells.y++;

    size = pSize;

    nbr_cell = nbCells.x * nbCells.y;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Tile::LoadImage

(

Surface &

ground_surface

)

Definition at line 150 of file tile.cpp.

                                     {
    FreeMem();

    InitTile(terrain.GetSize());
    assert(nbr_cell != 0);

    // Create the TileItem objects
    for (uint i=0; i<nbr_cell; ++i)
       item.push_back ( new TileItem_AlphaSoftware(CELL_SIZE) );

    // Fill the TileItem objects
        Point2i i;
    for( i.y = 0; i.y < nbCells.y; i.y++ )
        for( i.x = 0; i.x < nbCells.x; i.x++ ){
            int piece = i.y * nbCells.x + i.x;
            Rectanglei sr( i * CELL_SIZE, CELL_SIZE);

            terrain.SetAlpha(0, 0);
            item[piece]->GetSurface().Blit(terrain, sr, Point2i(0, 0));
        }

    // Replace transparent tiles by TileItem_Empty tiles
    for( uint i=0; i<nbr_cell; ++i )
    {
      TileItem_AlphaSoftware* t = static_cast<TileItem_AlphaSoftware*>(item[i]);
      while(t->need_check_empty)
        t->CheckEmpty();
      if(t->NeedDelete())
      {
#ifdef DBG_TILE
        printf("\nDeleting tile %i",i);
#endif
        delete item[i];
        item[i] = (TileItem*)new TileItem_Empty;
      }
#ifdef DBG_TILE
      else
      {
        if(i % nbCells.x % 2 == (i / nbCells.x) % 2)
          item[i]->FillWithRGB(0, 0, 255);
        else
          item[i]->FillWithRGB(0, 255, 0);
      }
#endif
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Tile::MergeSprite	(	const Point2i &	position,
		Surface &	provider
	)

Definition at line 131 of file tile.cpp.

                                                            {
  Rectanglei rect = Rectanglei(position, surf.GetSize());
  Point2i firstCell = Clamp(position/CELL_SIZE);
  Point2i lastCell = Clamp((position + surf.GetSize())/CELL_SIZE);
  Point2i c;

  for( c.y = firstCell.y; c.y <= lastCell.y; c.y++ )
    for( c.x = firstCell.x; c.x <= lastCell.x; c.x++){
      Point2i offset = position - c * CELL_SIZE;
      if(item[c.y*nbCells.x + c.x]->IsTotallyEmpty()) {
        delete item[c.y*nbCells.x + c.x];
        item[c.y*nbCells.x + c.x] = new TileItem_AlphaSoftware(CELL_SIZE);
        item[c.y*nbCells.x + c.x]->GetSurface().SetAlpha(0,0);
        item[c.y*nbCells.x + c.x]->GetSurface().Fill(0x00000000);
        item[c.y*nbCells.x + c.x]->GetSurface().SetAlpha(SDL_SRCALPHA,0);
      }
      item[c.y*nbCells.x + c.x]->MergeSprite(offset, surf);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Tile::PutSprite	(	const Point2i	pos,
		Sprite *	spr
	)

Definition at line 88 of file tile.cpp.

{
  Rectanglei rec = Rectanglei(pos, spr->GetSizeMax());
  Point2i firstCell = Clamp(pos/CELL_SIZE);
  Point2i lastCell = Clamp((pos + spr->GetSizeMax())/CELL_SIZE);
  Point2i c;
  Surface s = spr->GetSurface();
  s.SetAlpha(0, 0);

  for( c.y = firstCell.y; c.y <= lastCell.y; c.y++ )
  for( c.x = firstCell.x; c.x <= lastCell.x; c.x++)
  {
    if(item[c.y*nbCells.x + c.x]->IsTotallyEmpty())
    {
      delete item[c.y*nbCells.x + c.x];
      item[c.y*nbCells.x + c.x] = new TileItem_AlphaSoftware(CELL_SIZE);
      item[c.y*nbCells.x + c.x]->GetSurface().SetAlpha(0,0);
      item[c.y*nbCells.x + c.x]->GetSurface().Fill(0x00000000);
      item[c.y*nbCells.x + c.x]->GetSurface().SetAlpha(SDL_SRCALPHA,0);
    }

    Point2i cell_pos = c * CELL_SIZE;
    Rectanglei src;
    Rectanglei dst;
    src.SetPosition( rec.GetPosition() - cell_pos );
    if(src.GetPositionX() < 0) src.SetPositionX(0);
    if(src.GetPositionY() < 0) src.SetPositionY(0);

    src.SetSize( rec.GetPosition() + rec.GetSize() - cell_pos - src.GetPosition());
    if(src.GetSizeX() + src.GetPositionX() > CELL_SIZE.x) src.SetSizeX(CELL_SIZE.x - src.GetPositionX());
    if(src.GetSizeY() + src.GetPositionY() > CELL_SIZE.y) src.SetSizeY(CELL_SIZE.y - src.GetPositionY());

    dst.SetPosition( cell_pos - rec.GetPosition() );
    if(dst.GetPositionX() < 0) dst.SetPositionX(0);
    if(dst.GetPositionY() < 0) dst.SetPositionY(0);
    dst.SetSize(src.GetSize());

    item[c.y*nbCells.x + c.x]->GetSurface().Blit(s, dst, src.GetPosition());
    static_cast<TileItem_AlphaSoftware*>(item[c.y*nbCells.x + c.x])->ResetEmptyCheck();
  }
  s.SetAlpha(SDL_SRCALPHA, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Member Data Documentation

std::vector<TileItem *> Tile::item [protected]

Definition at line 78 of file tile.h.

Point2i Tile::nbCells [protected]

Definition at line 74 of file tile.h.

unsigned int Tile::nbr_cell [protected]

Definition at line 75 of file tile.h.

---

The documentation for this class was generated from the following files:

• src/map/tile.h
• src/map/tile.cpp

---