Hosting courtesy of Sourceforge

               

---

MapEditor.cpp

Go to the documentation of this file.

//
//                                 MapEditor.cpp
//                             -------------------
//    begin                : Tue Mar 19 2002
//    copyright           : (C) 2002 by Rob Renaud
//    email                : rrenaud@eden.rutgers.edu
//
//   This program is free software; you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation; either version 2 of the License, or
//   (at your option) any later version.
//

#include "MapEditor.h"
#include <iostream>
#include <algorithm>

using namespace Editor;

const int MapEditor::WndPos::TILE_MAT_HORIZ_OFFSET = 50;
const int MapEditor::WndPos::TILE_MAT_VERT_OFFSET =10;
const int MapEditor::WndPos::TILE_SET_HORIZ_OFFSET=10;
const int MapEditor::WndPos::TILE_SET_VERT_OFFSET = 50;

MapEditor::EditorTileMatrixReader::EditorTileMatrixReader(MapEditor& ed) :
editor(ed)
{ }

void MapEditor::EditorTileMatrixReader::getValue(std::istream& in) {
        Util::Matrix<int> tileIndicies(editor.tileMatrix.numRows(), editor.tileMatrix.numCols(), -1);
        in >> tileIndicies;
        for (int r = 0; r < tileIndicies.numRows(); r++) {
                for (int c = 0; c < tileIndicies.numCols(); c++) {
        //              std::cout << tileIndicies(r,c) << " ";
                        int tileIndex = tileIndicies(r,c);
                        editor.tileMatrix(r,c) = new EditorTile(editor.tileSetEd.copyTile(tileIndex), tileIndex);
                }
        //      std::cout << "\n" << std::endl;
        }
}

void MapEditor::EditorTileMatrixReader::finishingAction() {
        // validate readings
        for (int r = 0; r < editor.tileMatrix.numRows(); r++) {
                for (int c = 0; c < editor.tileMatrix.numCols(); c++) {
                        if (editor.tileMatrix(r,c) == NULL) {
                                throw Util::GeneralException("NULL tile after reading file " + editor.filename+ " at (" +
                                 Util::toString(r) + " , " + Util::toString(c) + ")", __FILE__, __LINE__);
                        }
                }
        }
}

MapEditor::MapEditor(const std::string& name) :
tileMatrix(Game::Constants::MAP_NUM_ROWS, Game::Constants::MAP_NUM_COLS, NULL),
filename(name),
startLocPic(new Graphics::SingleFrameImage("Editor/Data/StartPic.bmp"))
{
        std::ifstream in(name.c_str());
        if (!in.good()) throw Util::GeneralException("Could not open " + filename + " for reading", __FILE__, __LINE__);
        Parse::SimpleParser parser(in);

        parser.addAction("TileSet",                     new Parse::StdRead<TileSetEditor>(tileSetEd));
        parser.addAction("StartLocation",       new Parse::NaturalListParser<Game::MapLocation>(startLocs));
        parser.addAction("MapData",                     new EditorTileMatrixReader(*this));     

        parser.read();

}

void MapEditor::changeMapName(const std::string& str) {
        filename = str;
}

void MapEditor::handleMouseClick(SDL_MouseButtonEvent& event) {
        int r = (event.x - WndPos::TILE_MAT_HORIZ_OFFSET) / Game::Constants::TILE_WIDTH;
        int c = (event.y - WndPos::TILE_MAT_VERT_OFFSET) / Game::Constants::TILE_HEIGHT;
        
        if (r < tileMatrix.numRows() && c < tileMatrix.numCols() && r >= 0 && c>=0) {
                if (SDL_BUTTON_LEFT  == event.button  ) tileMatrix(r,c)->incrementTile(tileSetEd);
                else if (SDL_BUTTON_RIGHT == event.button ) toggleStartLoc(r,c);
                else if (SDL_BUTTON_MIDDLE == event.button) tileMatrix(r,c)->decrementTile(tileSetEd);
        }
}

MapEditor::~MapEditor() {
        saveMap();
        for (int i = 0; i < tileMatrix.numRows(); i++) {
                for (int j = 0; j < tileMatrix.numCols(); j++) {
                        delete tileMatrix(i,j);
                }
        }
        delete startLocPic;
        Util::freeDynamicContainer(startLocs);
}

void MapEditor::saveMap() {
        std::ofstream out(filename.c_str());
        out << tileSetEd;
        out << "MapData=\n";
        for (int c = 0; c < tileMatrix.numCols(); c++) {
                for (int r = 0; r < tileMatrix.numRows(); r++) {
                        out << tileMatrix(r,c)->getIndex() << " ";
                }
                out << std::endl;
        }
        for (std::list<Game::MapLocation*>::iterator i = startLocs.begin(); i != startLocs.end(); i++) {
                out << "StartLocation {\n";
                out << "\tx=" << (*i)->getMapX() << "\n";
                out << "\ty=" << (*i)->getMapY() << "\n";
                out << "}\n";
        }
}

void MapEditor::toggleStartLoc(int row, int col) {
        std::list<Game::MapLocation*>::iterator check = std::find_if(startLocs.begin(), startLocs.end(), Game::MapLocAt(row, col));
        if (check != startLocs.end()) {
                delete *check;
                startLocs.erase(check);
        } else {
                startLocs.push_back(new Game::MapLocation(row,col));
        }               
}

void MapEditor::draw(SDL_Surface* surf) {
        SDL_Rect rect;

        // draw tile matrix
        rect.x = WndPos::TILE_MAT_HORIZ_OFFSET;
        rect.y = WndPos::TILE_MAT_VERT_OFFSET;
        for (int r = 0; r < tileMatrix.numRows(); r++) {
                rect.y = WndPos::TILE_MAT_VERT_OFFSET;
                for (int c = 0; c < tileMatrix.numCols(); c++) {
                        tileMatrix(r,c)->drawAt(surf,&rect);
                        rect.y += Game::Constants::TILE_HEIGHT;
                }
                rect.x += Game::Constants::TILE_WIDTH;
        }

        for (std::list<Game::MapLocation*>::iterator it = startLocs.begin(); it != startLocs.end(); it++) {
                rect.x = (*it)->getMapX()*Game::Constants::TILE_WIDTH+WndPos::TILE_MAT_HORIZ_OFFSET;
                rect.y = (*it)->getMapY()*Game::Constants::TILE_HEIGHT+WndPos::TILE_MAT_VERT_OFFSET;            
                startLocPic->drawAt(surf,&rect);
        }

        // draw tile set editor
        rect.x = WndPos::TILE_MAT_HORIZ_OFFSET + WndPos::TILE_SET_HORIZ_OFFSET
                + Game::Constants::TILE_WIDTH * tileMatrix.numRows();

        rect.y = WndPos::TILE_MAT_VERT_OFFSET + WndPos::TILE_SET_VERT_OFFSET;

        tileSetEd.drawAt(surf, &rect);  
}               

---