[netPanzer-CVS] netpanzer/src/Editor TemplateSelectWidget.cpp T...

[Matthias Braun]

CVSROOT:        /cvsroot/netpanzer
Module name:    netpanzer
Branch:         
Changes by:     Matthias Braun <address@hidden> 03/11/22 17:50:44

Modified files:
        src/Editor     : TemplateSelectWidget.cpp TileSet.cpp 
                         TileSet.hpp TileSetEditor.cpp TileSetList.cpp 
                         TileTemplate.cpp TileTemplate.hpp 

Log message:
        implemented more code for tileset templates

Patches:
Index: netpanzer/src/Editor/TemplateSelectWidget.cpp
diff -u netpanzer/src/Editor/TemplateSelectWidget.cpp:1.2 
netpanzer/src/Editor/TemplateSelectWidget.cpp:1.3
--- netpanzer/src/Editor/TemplateSelectWidget.cpp:1.2   Sat Nov 22 11:00:38 2003
+++ netpanzer/src/Editor/TemplateSelectWidget.cpp       Sat Nov 22 17:50:44 2003
@@ -6,6 +6,7 @@
 #include "TemplateSelectWidget.hpp"
 #include "Util/Exception.hpp"
 #include "TileSet.hpp"
+#include "TileTemplate.hpp"
 
 #define XSIZE 32
 #define YSIZE 32
@@ -147,21 +148,29 @@
 
 TileTemplate* TemplateSelectWidget::createTemplate(TileSet* tileset)
 {
+    std::auto_ptr<TileTemplate> tiletemplate
+        (new TileTemplate(tileset, tilecountx, tilecounty));
+    
     for(int x=0; x< tilecountx; x++) {
         for(int y=0;y< tilecounty; y++) {
-            if(selected[y*tilecountx + x])
+            if(selected[y*tilecountx + x]) {
+                tiletemplate->setTile(x, y, TileTemplate::NOTILE);
                 continue;
+            }
 
             SDL_Rect rect;
             rect.x = x*XSIZE;
             rect.y = y*YSIZE;
             rect.w = XSIZE;
             rect.h = YSIZE;
-            tileset->addTile(image, &rect);
+            size_t tile = tileset->addTile(image, &rect);
+            tiletemplate->setTile(x, y, tile);
         }
     }
 
-    return 0;
+    TileTemplate* result = tiletemplate.get();
+    tileset->addTemplate(tiletemplate.release());
+    return result;
 }
 
 BEGIN_EVENT_TABLE(TemplateSelectWidget, SDLView)
Index: netpanzer/src/Editor/TileSet.cpp
diff -u netpanzer/src/Editor/TileSet.cpp:1.5 
netpanzer/src/Editor/TileSet.cpp:1.6
--- netpanzer/src/Editor/TileSet.cpp:1.5        Sat Nov 22 11:00:38 2003
+++ netpanzer/src/Editor/TileSet.cpp    Sat Nov 22 17:50:44 2003
@@ -9,6 +9,7 @@
 #include "Util/Exception.hpp"
 #include "Util/Log.hpp"
 #include "TileSet.hpp"
+#include "TileTemplate.hpp"
 
 static const char* MAGICSTRING="TLST";
 static const uint32_t FILEFORMATVERSION=0001;
@@ -86,13 +87,24 @@
 
 TileSet::~TileSet()
 {
+    std::vector<TileTemplate*>::iterator i;
+    for(i=templates.begin(); i!=templates.end(); i++) {
+        delete *i;
+    }
+    
     delete header;
     delete[] tiledata;
 }
 
-void TileSet::load(ReadFile& file)
+void TileSet::load(const std::string& dir)
 {
-    std::auto_ptr<TileSetHeader> fileheader (new TileSetHeader(file));
+    std::string filename = dir;
+    filename += "/tiles.dat";
+    
+    std::auto_ptr<ReadFile> file (FileSystem::openRead(filename));
+   
+    // read the header
+    std::auto_ptr<TileSetHeader> fileheader (new TileSetHeader(*file));
 
     if(memcmp(fileheader->magic, MAGICSTRING, 4) != 0)
         throw Exception("File is not a tileset");
@@ -110,20 +122,58 @@
     delete[] tiledata;
     tilebuffersize = 0;
     tiledata = 0;
-    
+   
+    // read tiles
     tilesize = header->tilewidth * header->tileheight * 
(header->tilebitsperpixel / 8);
     if(header->tilecount > 0) {
         resizeBuffer(tilesize * header->tilecount);
-        if(file.read(tiledata, tilesize, header->tilecount) != 
header->tilecount)
+        if(file->read(tiledata, tilesize, header->tilecount) != 
header->tilecount)
             throw Exception("Tileset file is too short.");
     }
+
+    // read templates
+    readTemplates(dir);
+}
+
+void TileSet::readTemplates(const std::string& newdir)
+{
+    dir = newdir;
+    std::string templatedir = dir;
+    templatedir += "/templates/";
+    
+    char** files = FileSystem::enumerateFiles(templatedir);
+    for(char** file = files; *file != 0; file++) {
+        std::string filename = templatedir;
+        filename += *file;
+
+        // ...
+    }
+
+    FileSystem::freeList(files);
 }
 
-void TileSet::save(WriteFile& file)
+void TileSet::save()
 {
-    header->write(file);
+    std::string filename = dir;
+    filename += "/tiles.dat";
+
+    std::auto_ptr<WriteFile> file (FileSystem::openWrite(filename));
+    
+    header->write(*file);
     if(tilesize * header->tilecount != 0)
-        file.write(tiledata, tilesize, header->tilecount);
+        file->write(tiledata, tilesize, header->tilecount);
+
+    // TODO save templates
+}
+
+const std::string& TileSet::getDirectory() const
+{
+    return dir;
+}
+
+void TileSet::setDirectory(const std::string& newdirectory)
+{
+    dir = newdirectory;
 }
 
 size_t TileSet::getTileCount() const
@@ -145,7 +195,7 @@
     return surface;
 }
 
-void TileSet::addTile(SDL_Surface* surface, SDL_Rect* srcrect)
+size_t TileSet::addTile(SDL_Surface* surface, SDL_Rect* srcrect)
 {
     if(surface->format->BitsPerPixel != header->tilebitsperpixel)
         throw Exception("Surface has incompatible format to be added as a tile"
@@ -192,11 +242,28 @@
     }
 
     header->tilecount++;
+
+    return header->tilecount-1;
 }
 
 iXY TileSet::getTileSize() const
 {
     return iXY(header->tilewidth, header->tileheight);
+}
+
+size_t TileSet::getTemplateCount() const
+{
+    return templates.size();
+}
+
+void TileSet::addTemplate(TileTemplate* tiletemplate)
+{
+    templates.push_back(tiletemplate);
+}
+
+TileTemplate* TileSet::getTemplate(size_t num)
+{
+    return templates.at(num);
 }
 
 void TileSet::resizeBuffer(size_t newbuffersize)
Index: netpanzer/src/Editor/TileSet.hpp
diff -u netpanzer/src/Editor/TileSet.hpp:1.2 
netpanzer/src/Editor/TileSet.hpp:1.3
--- netpanzer/src/Editor/TileSet.hpp:1.2        Sat Nov 22 11:00:38 2003
+++ netpanzer/src/Editor/TileSet.hpp    Sat Nov 22 17:50:44 2003
@@ -9,8 +9,6 @@
 #include "Types/iXY.hpp"
 
 class TileSetHeader;
-class ReadFile;
-class WriteFile;
 class Image;
 class TileTemplate;
 
@@ -20,23 +18,37 @@
     TileSet();
     ~TileSet();
 
-    void load(ReadFile& filename);
-    void save(WriteFile& filename);
+    /// loads a tileset from disk
+    void load(const std::string& dir);
+    /// save the tileset
+    void save();
+
+    /// returns the directory containing the tileset
+    const std::string& getDirectory() const;
+
+    void setDirectory(const std::string& newdirectory);
 
     size_t getTileCount() const;
     SDL_Surface* getTile(size_t num);
-    void addTile(SDL_Surface* image, SDL_Rect* sourcerect = 0);
+    size_t addTile(SDL_Surface* image, SDL_Rect* sourcerect = 0);
+
+    size_t getTemplateCount() const;
+    void addTemplate(TileTemplate* tiletemplate);
+    TileTemplate* getTemplate(size_t num);
 
     iXY getTileSize() const;
         
 private:
     void resizeBuffer(size_t newbuffersize);
+
+    void readTemplates(const std::string& dir);
     
     TileSetHeader* header;
     size_t tilesize;
     char* tiledata;
     size_t tilebuffersize;
 
+    std::string dir;
     std::vector<TileTemplate*> templates;
 };
 
Index: netpanzer/src/Editor/TileSetEditor.cpp
diff -u netpanzer/src/Editor/TileSetEditor.cpp:1.3 
netpanzer/src/Editor/TileSetEditor.cpp:1.4
--- netpanzer/src/Editor/TileSetEditor.cpp:1.3  Sat Nov 22 11:00:38 2003
+++ netpanzer/src/Editor/TileSetEditor.cpp      Sat Nov 22 17:50:44 2003
@@ -38,9 +38,7 @@
 {
     try {
         if(currenttileset) {
-            std::auto_ptr<WriteFile>
-                file(FileSystem::openWrite(filename.c_str()));        
-            currenttileset->save(*(file.get()));
+            currenttileset->save();
         }                                                                 
     } catch(std::exception& e) {
         std::string errormsg = "Couldn't save Tileset to '";
@@ -63,11 +61,9 @@
     try {
         filename = "/tileset/";
         filename += newtileset;
-        filename += "/tiles.dat";
-        std::auto_ptr<ReadFile> file (FileSystem::openRead(filename.c_str()));
 
         currenttileset = new TileSet();
-        currenttileset->load(*(file.get()));
+        currenttileset->load(filename);
 
         tilesetview->setTileSet(currenttileset);
     } catch(std::exception& e) {
Index: netpanzer/src/Editor/TileSetList.cpp
diff -u netpanzer/src/Editor/TileSetList.cpp:1.2 
netpanzer/src/Editor/TileSetList.cpp:1.3
--- netpanzer/src/Editor/TileSetList.cpp:1.2    Sat Nov 22 11:00:38 2003
+++ netpanzer/src/Editor/TileSetList.cpp        Sat Nov 22 17:50:44 2003
@@ -76,9 +76,8 @@
 
         std::auto_ptr<TileSet> tileset (new TileSet());
         std::string filename = newtileset;
-        filename += "/tiles.dat";
-        std::auto_ptr<WriteFile> file 
(FileSystem::openWrite(filename.c_str()));
-        tileset->save(*(file.get()));
+        tileset->setDirectory(filename);
+        tileset->save();
 
         populateList();
         long idx = FindItem(-1, "NewTileset");
Index: netpanzer/src/Editor/TileTemplate.cpp
diff -u netpanzer/src/Editor/TileTemplate.cpp:1.1 
netpanzer/src/Editor/TileTemplate.cpp:1.2
--- netpanzer/src/Editor/TileTemplate.cpp:1.1   Sun Nov 16 17:40:59 2003
+++ netpanzer/src/Editor/TileTemplate.cpp       Sat Nov 22 17:50:44 2003
@@ -1,15 +1,67 @@
 #include <config.h>
 
+#include <memory>
+#include <string.h>
+
+#include "Util/FileSystem.hpp"
+#include "Util/Exception.hpp"
+#include "TileSet.hpp"
 #include "TileTemplate.hpp"
 
 TileTemplate::TileTemplate(TileSet* newtileset, size_t newsizex, size_t 
newsizey)
     : tileset(newtileset), sizex(newsizex), sizey(newsizey)
 {
-    tiles = new size_t[sizex * sizey];
+    tiles = new uint16_t[sizex * sizey];
+    for(size_t y=0; y<sizey; y++)
+        for(size_t x=0; x<sizex; x++)
+            tiles[y*sizex + x] = NOTILE;
 }
 
-TileTemplate::TileTemplate(ReadFile* file)
+TileTemplate::TileTemplate(TileSet* newtileset, const std::string& newname)
 {
+    tileset = newtileset;
+    name = newname;
+    
+    std::string filename = tileset->getDirectory();
+    filename += "/";
+    filename += name;
+    
+    std::auto_ptr<ReadFile> file (FileSystem::openRead(filename));
+
+    try {
+        sizex = file->readULE32();
+        sizey = file->readULE32();
+    
+        tiles = new uint16_t[sizex * sizey];
+        for(size_t y=0; y<sizey; y++)
+            for(size_t x=0; x<sizex; x++)
+                tiles[y*sizex + x] = file->readULE16();
+    } catch(std::exception& e) {
+        throw Exception(
+                "Error while reading template file '%s': file too short",
+                filename.c_str());
+    }
+}
+
+void TileTemplate::save()
+{
+    std::string filename = tileset->getDirectory();
+    filename += "/";
+    filename += name;
+    
+    std::auto_ptr<WriteFile> file(FileSystem::openWrite(filename));
+
+    try {
+        file->writeULE32(sizex);
+        file->writeULE32(sizey);
+
+        for(size_t y=0; y<sizey; y++)
+            for(size_t x=0; x<sizex; x++)
+                file->writeULE16(tiles[y*sizex + x]);
+    } catch(std::exception& e) {
+        throw Exception("Error while saving '%s': %s",
+                filename.c_str(), e.what());
+    }           
 }
 
 TileTemplate::~TileTemplate()
Index: netpanzer/src/Editor/TileTemplate.hpp
diff -u netpanzer/src/Editor/TileTemplate.hpp:1.2 
netpanzer/src/Editor/TileTemplate.hpp:1.3
--- netpanzer/src/Editor/TileTemplate.hpp:1.2   Sat Nov 22 11:00:38 2003
+++ netpanzer/src/Editor/TileTemplate.hpp       Sat Nov 22 17:50:44 2003
@@ -2,7 +2,9 @@
 #define __TILETMEPLATE_HPP__
 
 #include <stdio.h>
+#include <stdint.h>
 #include <assert.h>
+#include <string>
 
 #include "Util/NoCopy.hpp"
 
@@ -12,10 +14,16 @@
 class TileTemplate : public NoCopy
 {
 public:
+    enum {
+        NOTILE = 0xffff
+    };
+    
     TileTemplate(TileSet* tileset, size_t sizex, size_t sizey);
-    TileTemplate(ReadFile* file);
+    TileTemplate(TileSet* tileset, const std::string& name);
     ~TileTemplate();
 
+    void save();
+
     void setTile(size_t x, size_t y, size_t tilenum)
     { 
         assert(x < sizex);
@@ -32,7 +40,9 @@
 private:
     TileSet* tileset;
     size_t sizex, sizey;
-    size_t* tiles;
+    uint16_t* tiles;
+
+    std::string name;
 };
 
 #endif