grid.cpp

Go to the documentation of this file.

//            Copyright (C) 2004-2007 by The Allacrost Project
//                         All Rights Reserved
//
// This code is licensed under the GNU GPL version 2. It is free software 
// and you may modify it and/or redistribute it under the terms of this license.
// See http://www.gnu.org/copyleft/gpl.html for details.

/*!****************************************************************************
 * \file    grid.cpp
 * \author  Philip Vorsilak, gorzuate@allacrost.org
 * \brief   Source file for editor's grid, used for the OpenGL map portion
 *          where tiles are painted, edited, etc.
 *****************************************************************************/

#include <iostream>
#include "grid.h"

using namespace hoa_script;
using namespace hoa_editor;
using namespace hoa_video;
using namespace std;

namespace hoa_editor
{
  LAYER_TYPE& operator++(LAYER_TYPE& value, int dummy) 
  {
    value = static_cast<LAYER_TYPE>(static_cast<int>(value) + 1);
    return value;
  }
}

Grid::Grid(QWidget* parent, const QString& name, int width, int height)
  : QGLWidget(parent, (const char*) name)
{ 
  _file_name = name;      // gives the map a name

  // Initial size
  _height = height;
  _width  = width;
  resize(_width * TILE_WIDTH, _height * TILE_HEIGHT);

  // Default properties
  _changed = false;       // map has not yet been modified
  _grid_on = true;        // grid lines default to on
  _ll_on = true;          // lower layer default to on
  _ml_on = false;         // middle layer default to off
  _ul_on = false;         // upper layer default to off

  // Initialize layers
  for (int i = 0; i < _width * _height; i++)
  {
    _lower_layer.push_back(-1);
    _middle_layer.push_back(-1);
    _upper_layer.push_back(-1);
  } // -1 is used for no tiles
  // -1 is used for no tiles

  // Create the video engine's singleton
  VideoManager = GameVideo::SingletonCreate();
} // Grid constructor

Grid::~Grid()
{
  // FIXME
//  VideoManager->DeleteImage();
  GameVideo::SingletonDestroy();
} // Grid destructor



// ********** Public functions **********

void Grid::SetChanged(bool value)
{
  _changed = value;
} // SetChanged(...)

void Grid::SetFileName(QString filename)
{
  _file_name = filename;
} // SetFileName(...)

void Grid::SetHeight(int height)
{
  _height = height;
  _changed = true;
} // SetHeight(...)

void Grid::SetWidth(int width)
{
  _width = width;
  _changed = true;
} // SetWidth(...)

void Grid::SetLLOn(bool value)
{
  _ll_on = value;
  updateGL();
} // SetLLOn(...)

void Grid::SetMLOn(bool value)
{
  _ml_on = value;
  updateGL();
} // SetMLOn(...)

void Grid::SetULOn(bool value)
{
  _ul_on = value;
  updateGL();
} // SetULOn(...)

void Grid::SetGridOn(bool value)
{
  _grid_on = value;
  updateGL();
} // SetGridOn(...)

std::vector<int32>& Grid::GetLayer(LAYER_TYPE layer) 
{
  switch(layer) {
    case LOWER_LAYER:
      return _lower_layer;
    case MIDDLE_LAYER:
      return _middle_layer;
    case UPPER_LAYER:
      return _upper_layer;
    case INVALID_LAYER:
      /* FALLTHRU */
    case TOTAL_LAYER:
      /* FALLTHRU */
    default:
      return _lower_layer;
  } // switch on the current layer
} // GetLayer(...)

void Grid::SetMusic(const QString& music_file) 
{
  _music_file = music_file;
} // SetMusic(...)

const QString& Grid::GetMusic() const 
{
  return _music_file;
} // GetMusic()

void Grid::LoadMap()
{
  ReadScriptDescriptor read_data;
  vector<int32> vect;             // used to read in vectors from the file

  if (!read_data.OpenFile(std::string(_file_name.toAscii())))
    QMessageBox::warning(this, "Loading File...", QString("ERROR: could not open %1 for reading!").arg(_file_name));

  tileset_names.clear();
  tilesets.clear();
  _lower_layer.clear();
  _middle_layer.clear();
  _upper_layer.clear();
  
  _height = read_data.ReadInt("num_tile_rows");
  _width  = read_data.ReadInt("num_tile_cols");
  resize(_width * TILE_WIDTH, _height * TILE_HEIGHT);

  read_data.OpenTable("tileset_filenames");
  uint32 table_size = read_data.GetTableSize();
  for (uint32 i = 1; i <= table_size; i++)
    tileset_names.append(QString(read_data.ReadString(i).c_str()));
  read_data.CloseTable();

  // Loading the tileset images using LoadMultiImage is done in editor.cpp in FileOpen via
  // creation of the TilesetTable(s)

  read_data.OpenTable("lower_layer");
  for (int32 i = 0; i < _height; i++)
  {
    read_data.ReadIntVector(i, vect);
    for (vector<int32>::iterator it = vect.begin(); it != vect.end(); it++)
      _lower_layer.push_back(*it);
    vect.clear();
  } // iterate through the rows of the lower layer
  read_data.CloseTable();

  read_data.OpenTable("middle_layer");
  for (int32 i = 0; i < _height; i++)
  {
    read_data.ReadIntVector(i, vect);
    for (vector<int32>::iterator it = vect.begin(); it != vect.end(); it++)
      _middle_layer.push_back(*it);
    vect.clear();
  } // iterate through the rows of the lower layer
  read_data.CloseTable();

  read_data.OpenTable("upper_layer");
  for (int32 i = 0; i < _height; i++)
  {
    read_data.ReadIntVector(i, vect);
    for (vector<int32>::iterator it = vect.begin(); it != vect.end(); it++)
      _upper_layer.push_back(*it);
    vect.clear();
  } // iterate through the rows of the lower layer
  read_data.CloseTable();
  
  // The map_grid is 4x as big as the map: 2x in the width and 2x in the height. Starting
  // with row 0 (and doing the same thing for every row that is a multiple of 2), we take the first 2 entries,
  // bit-wise AND them, and put them into a temporary vector called walk_temp. We keep doing this for every 2
  // entries until the row is exhausted. walk_temp should now be the same length or size as the width of the map.
  //
  // Now we go on to the next row (and we do the same thing here for every other row, or rows that are not
  // multiples of 2. We do the same thing that we did for the multiples-of-2 rows, except now we bit-wise AND the
  // 2 entries with their corresponding entry in the walk_temp vector. We have now reconstructed the walkability
  // for each tile.
  /*read_data.ReadOpenTable("map_grid");
  uint32 walk_west;
  vector<uint32> walk_temp;
  vector<uint32>::iterator wit;
  for (int32 i = 0; i < _height * 2; i++)
  {
    read_data.ReadIntVector(i, vect);
    wit = walk_temp.begin();
    for (vector<int32>::iterator it = vect.begin(); it != vect.end(); it++)
    {
      walk_west = *it;
      it++;
      if (i % 2 == 0)
        walk_temp.push_back(walk_west & *it);
      else
      {
        indiv_walkable.push_back(*wit & walk_west & *it);
        wit++;
      } // remainder means entire tile has been read
    } // iterate through the row
    vect.clear();
    if (i % 2 != 0)
      walk_temp.clear();
  } // iterate through the rows of the walkability table
  read_data.ReadCloseTable();*/

  // Load music
  read_data.OpenTable("music_filenames");
  if (read_data.IsErrorDetected() == false)
  {
    int size = read_data.GetTableSize();
    if (size == 0)
      _music_file = "None";
    else
      _music_file = QString(read_data.ReadString(1).c_str());
    read_data.CloseTable();
  }

  _grid_on = true;        // grid lines default to on
  _ll_on   = true;        // lower layer default to on
  _ml_on   = true;        // middle layer default to off
  _ul_on   = true;        // upper layer default to off
  _changed = false;       // map has not been changed yet
} // LoadMap()

void Grid::SaveMap()
{
  char buffer[5]; // used for converting an int to a string with sprintf
  int i;          // Lua table index / Loop counter variable
  vector<int32>::iterator it;  // used to iterate through the layers
  vector<int32> layer_row;     // one row of a layer
  WriteScriptDescriptor write_data;
  int tileset_index;
  int tile_index;
  
  if (write_data.OpenFile(std::string(_file_name.toAscii())) == false) {
    QMessageBox::warning(this, "Saving File...", QString("ERROR: could not open %1 for writing!").arg(_file_name));
    return;
  }

  write_data.WriteComment(std::string(_file_name.toAscii()));
  write_data.InsertNewLine();

  write_data.WriteComment("A reference to the C++ MapMode object that was created with this file");
  write_data.WriteLine("map = {}\n");

  write_data.WriteComment("The number of rows and columns of tiles that compose the map");
  write_data.WriteInt("num_tile_cols", _width);
  write_data.WriteInt("num_tile_rows", _height);
  write_data.InsertNewLine();

  write_data.WriteComment("The sound files used on this map.");
  write_data.BeginTable("sound_filenames");
  // TEMP: currently sound_filenames table is not populated with sounds
  write_data.EndTable();
  write_data.InsertNewLine();

  write_data.WriteComment("The music files used as background music on this map.");
  write_data.BeginTable("music_filenames");
  if (_music_file != "None")
    write_data.WriteString(1, std::string(_music_file.toAscii()));
  write_data.EndTable();
  write_data.InsertNewLine();

  write_data.WriteComment("The names of the tilesets used, with the path and file extension omitted");
  write_data.BeginTable("tileset_filenames");
  i = 0;
  for (QStringList::Iterator qit = tileset_names.begin(); qit != tileset_names.end(); ++qit)
  {
    i++;
    write_data.WriteString(i, (*qit).ascii());
  } // iterate through tileset_list writing each element
  write_data.EndTable();
  write_data.InsertNewLine();

  // Create vector of 0s.
  vector<int32> vect_0s(_width, 0);

  write_data.WriteComment("The map grid to indicate walkability. The size of the grid is 4x the size of the tile layer tables");
  write_data.WriteComment("Walkability status of tiles for 32 contexts. Zero indicates walkable. Valid range: [0:2^32-1]");
  write_data.BeginTable("map_grid");
  vector<int32> ll_vect;
  vector<int32> ml_vect;
  vector<int32> ul_vect;
  int row = 0;
  bool twice = false;
  while (row < _height)
  {
    for (int32 i = row * _width; i < row * _width + _width; i++)
    {
      // Get walkability for lower layer tile.
      tileset_index = _lower_layer[i] / 256;
      if (tileset_index == 0)
        tile_index = _lower_layer[i];
      else  // Don't divide by 0
        tile_index = _lower_layer[i] % (tileset_index * 256);
      if (tile_index == -1)
      {
        ll_vect.push_back(0);
        ll_vect.push_back(0);
        ll_vect.push_back(0);
        ll_vect.push_back(0);
      }
      else
        ll_vect = tilesets[tileset_index]->walkability[tile_index];

      // Get walkability for middle layer tile.
      tileset_index = _middle_layer[i] / 256;
      if (tileset_index == 0)
        tile_index = _middle_layer[i];
      else  // Don't divide by 0
        tile_index = _middle_layer[i] % (tileset_index * 256);
      if (tile_index == -1)
      {
        ml_vect.push_back(0);
        ml_vect.push_back(0);
        ml_vect.push_back(0);
        ml_vect.push_back(0);
      }
      else
        ml_vect = tilesets[tileset_index]->walkability[tile_index];

      // Get walkability for upper layer tile.
      tileset_index = _upper_layer[i] / 256;
      if (tileset_index == 0)
        tile_index = _upper_layer[i];
      else  // Don't divide by 0
        tile_index = _upper_layer[i] % (tileset_index * 256);
      if (tile_index == -1)
      {
        ul_vect.push_back(0);
        ul_vect.push_back(0);
        ul_vect.push_back(0);
        ul_vect.push_back(0);
      }
      else
        ul_vect = tilesets[tileset_index]->walkability[tile_index];

      if (twice)
      {
        layer_row.push_back(ll_vect[2] | ml_vect[2] | ul_vect[2]);  // SW corner
        layer_row.push_back(ll_vect[3] | ml_vect[3] | ul_vect[3]);  // SE corner
      }
      else
      {
        layer_row.push_back(ll_vect[0] | ml_vect[0] | ul_vect[0]);  // NW corner
        layer_row.push_back(ll_vect[1] | ml_vect[1] | ul_vect[1]);  // NE corner
      }
      
      ll_vect.clear();
      ml_vect.clear();
      ul_vect.clear();
    } // iterate through the columns of the layers

    if (twice)
      sprintf(buffer, "%d", row*2+1);
    else
      sprintf(buffer, "%d", row*2);
    write_data.WriteIntVector(buffer, layer_row);
    layer_row.clear();
    if (twice)
    {
      twice = false;
      row++;
    }
    else
      twice = true;
  } // iterate through the rows of the layers
  write_data.EndTable();
  write_data.InsertNewLine();

  write_data.WriteComment("The lower tile layer. The numbers are indeces to the tile_mappings table.");
  write_data.BeginTable("lower_layer");
  it = _lower_layer.begin();
  for (int row = 0; row < _height; row++)
  {
    for (int col = 0; col < _width; col++)
    {
      layer_row.push_back(*it);
      it++;
    } // iterate through the columns of the lower layer
    sprintf(buffer, "%d", row);
    write_data.WriteIntVector(buffer, layer_row);
    layer_row.clear();
  } // iterate through the rows of the lower layer
  write_data.EndTable();
  write_data.InsertNewLine();

  write_data.WriteComment("The middle tile layer. The numbers are indeces to the tile_mappings table.");
  write_data.BeginTable("middle_layer");
  it = _middle_layer.begin();
  for (int row = 0; row < _height; row++)
  {
    for (int col = 0; col < _width; col++)
    {
      layer_row.push_back(*it);
      it++;
    } // iterate through the columns of the middle layer
    sprintf(buffer, "%d", row);
    write_data.WriteIntVector(buffer, layer_row);
    layer_row.clear();
  } // iterate through the rows of the middle layer
  write_data.EndTable();
  write_data.InsertNewLine();

  write_data.WriteComment("The upper tile layer. The numbers are indeces to the tile_mappings table.");
  write_data.BeginTable("upper_layer");
  it = _upper_layer.begin();
  for (int row = 0; row < _height; row++)
  {
    for (int col = 0; col < _width; col++)
    {
      layer_row.push_back(*it);
      it++;
    } // iterate through the columns of the upper layer
    sprintf(buffer, "%d", row);
    write_data.WriteIntVector(buffer, layer_row);
    layer_row.clear();
  } // iterate through the rows of the upper layer
  write_data.EndTable();
  write_data.InsertNewLine();

  write_data.CloseFile();

  _changed = false;
} // SaveMap()



// ********** Protected slots **********

void Grid::initializeGL()
{
  VideoManager->SetTarget(VIDEO_TARGET_QT_WIDGET);
  VideoManager->SingletonInitialize();
  VideoManager->ToggleFPS();
} // initializeGL()

void Grid::paintGL()
{
  int32 col;                       // tile array loop index
  vector<int32>::iterator it;      // used to iterate through tile arrays
  int tileset_index;               // index into the tileset_names vector
  int tile_index;                  // ranges from 0-255

  // Setup drawing parameters
  VideoManager->SetCoordSys(0.0f, VideoManager->GetWidth() / TILE_WIDTH,
    VideoManager->GetHeight() / TILE_HEIGHT, 0.0f);
  VideoManager->SetDrawFlags(VIDEO_X_LEFT, VIDEO_Y_TOP, VIDEO_BLEND, 0);
  VideoManager->Clear(Color::black);

  // Draw lower layer
  if (_ll_on)
  {
    VideoManager->Move(0.0f, 0.0f);
    col = 0;
    for (it = _lower_layer.begin(); it != _lower_layer.end(); it++)
    {
      if (*it != -1)
      {
        tileset_index = *it / 256;
        if (tileset_index == 0)
          tile_index = *it;
        else  // Don't divide by 0
          tile_index = *it % (tileset_index * 256);
        VideoManager->DrawImage(tilesets[tileset_index]->tiles[tile_index]);
      } // a tile exists to draw
      col = ++col % _width;
      if (col == 0)
        VideoManager->MoveRelative(-_width + 1, 1.0f);
      else
        VideoManager->MoveRelative(1.0f, 0.0f);
    } // iterate through lower layer
  } // lower layer must be viewable

  // Draw middle layer
  if (_ml_on)
  {
    VideoManager->Move(0.0f, 0.0f);
    col = 0;
    for (it = _middle_layer.begin(); it != _middle_layer.end(); it++)
    {
      if (*it != -1)
      {
        tileset_index = *it / 256;
        if (tileset_index == 0)
          tile_index = *it;
        else  // Don't divide by 0
          tile_index = *it % (tileset_index * 256);
        VideoManager->DrawImage(tilesets[tileset_index]->tiles[tile_index]);
      } // a tile exists to draw
      col = ++col % _width;
      if (col == 0)
        VideoManager->MoveRelative(-_width + 1, 1.0f);
      else
        VideoManager->MoveRelative(1.0f, 0.0f);
    } // iterate through middle layer
  } // middle layer must be viewable

  // Draw upper layer
  if (_ul_on)
  {
    VideoManager->Move(0.0f, 0.0f);
    col = 0;
    for (it = _upper_layer.begin(); it != _upper_layer.end(); it++)
    {
      if (*it != -1)
      {
        tileset_index = *it / 256;
        if (tileset_index == 0)
          tile_index = *it;
        else  // Don't divide by 0
          tile_index = *it % (tileset_index * 256);
        VideoManager->DrawImage(tilesets[tileset_index]->tiles[tile_index]);
      } // a tile exists to draw
      col = ++col % _width;
      if (col == 0)
        VideoManager->MoveRelative(-_width + 1, 1.0f);
      else
        VideoManager->MoveRelative(1.0f, 0.0f);
    } // iterate through upper layer
  } // upper layer must be viewable

  // If grid is toggled on, draw it
  if (_grid_on)
    VideoManager->DrawGrid(0.0f, 0.0f, 1.0f, 1.0f, Color::black);
} // paintGL()

void Grid::resizeGL(int w, int h)
{
  VideoManager->SetResolution(w, h);
  VideoManager->ApplySettings();
} // resizeGL(...)

---