[Moeng-cvs] BBRpg/src/shared module.cpp,1.1,1.2 module.h,1.1,1.2 tiled_map.cpp,1.8,1.9

[Bj?rn L. <b_l...@us...>]

Update of /cvsroot/moeng/BBRpg/src/shared
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv28988/src/shared

Modified Files:
	module.cpp module.h tiled_map.cpp 
Log Message:
Merged engine changes from DGE RPG agian.


Index: module.h
===================================================================
RCS file: /cvsroot/moeng/BBRpg/src/shared/module.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** module.h	13 Apr 2004 12:28:33 -0000	1.1
--- module.h	25 Apr 2004 16:39:53 -0000	1.2
***************
*** 16,19 ****
--- 16,20 ----
  #include <map>
  #include <set>
+ #include <string>
  #include "tiled_map.h"
  
***************
*** 28,54 ****
          ~Module();
  
!         void loadScript(const char *name);
          void loadScripts();
!         TiledMap* loadMap(const char *name);
  
!         BITMAP* findBitmap(const char *name);
!         MIDI* findMidi(const char *name);
!         SAMPLE* findSample(const char *name);
!         FONT* findFont(const char *name);
!         char* findScript(const char *name);
  
      private:
          char* makeFilename(const char *name, const char *subdir);
          
!         DATAFILE *datafile;
          char *path;
          int loadLevel;
          
!         map<const char*, BITMAP*, ltstr> bitmaps;
!         map<const char*, MIDI*, ltstr> midis;
!         map<const char*, SAMPLE*, ltstr> samples;
!         map<const char*, FONT*, ltstr> fonts;
!         map<const char*, char*, ltstr> scripts;
!         set<const char*> loadedScripts;
  };
  
--- 29,56 ----
          ~Module();
  
!         void loadScript(std::string name);
          void loadScripts();
!         TiledMap* loadMap(std::string name);
  
!         BITMAP* findBitmap(std::string name);
!         MIDI* findMidi(std::string name);
!         SAMPLE* findSample(std::string name);
!         FONT* findFont(std::string name);
!         char* findScript(std::string name);
  
      private:
          char* makeFilename(const char *name, const char *subdir);
+         char* addMagic(const char *file);
          
!         DATAFILE *script_data;
          char *path;
+         char *datafile_name;
          int loadLevel;
          
!         map<std::string, BITMAP*> bitmaps;
!         map<std::string, MIDI*> midis;
!         map<std::string, SAMPLE*> samples;
!         map<std::string, FONT*> fonts;
!         map<std::string, char*> scripts;
  };
  

Index: tiled_map.cpp
===================================================================
RCS file: /cvsroot/moeng/BBRpg/src/shared/tiled_map.cpp,v
retrieving revision 1.8
retrieving revision 1.9
diff -C2 -d -r1.8 -r1.9
*** tiled_map.cpp	13 Apr 2004 12:26:08 -0000	1.8
--- tiled_map.cpp	25 Apr 2004 16:39:53 -0000	1.9
***************
*** 653,658 ****
  int TiledMap::loadMap(const char* filename)
  {
!     xmlDocPtr doc = xmlParseFile(filename);
      if (doc) {
          xmlNodePtr cur = xmlDocGetRootElement(doc);
  
--- 653,683 ----
  int TiledMap::loadMap(const char* filename)
  {
!     console.log(CON_LOG, CON_VDEBUG, "- Attempting to parse XML map data");
! 
!     FILE* f = fopen(filename, "rb");
!     char *map_string;
! 
!     if (!f) {
!         console.log(CON_QUIT, CON_ALWAYS, "Error: %s failed to open!",
!                 filename);
!     }
! 
!     // Get size of file
!     fseek(f, 0, SEEK_END);
!     long size = ftell(f);
!     rewind(f);
! 
!     // Read file into character array
!     map_string = new char[size + 1];
!     fread(map_string, 1, size, f);
!     map_string[size] = '\0';
! 
!     fclose(f);
!     
!     xmlDocPtr doc = xmlReadMemory(map_string, size, NULL, NULL, 0);
!     delete[] map_string;
!     
      if (doc) {
+         console.log(CON_LOG, CON_VDEBUG, "- Looking for root node");
          xmlNodePtr cur = xmlDocGetRootElement(doc);
  
***************
*** 663,670 ****
--- 688,697 ----
          }
          
+         console.log(CON_LOG, CON_VDEBUG, "- Loading map from XML tree");
          loadFrom(cur, tileRepository);
          xmlFreeDoc(doc);
      }
      else {
+         console.log(CON_LOG, CON_VDEBUG, "- Attempting to load packfile map");
          PACKFILE *file = pack_fopen(filename, F_READ_PACKED);
  
***************
*** 675,678 ****
--- 702,706 ----
          }
          
+         console.log(CON_LOG, CON_VDEBUG, "- Loading map from packfile");
          this->loadFrom(file, tileRepository);
          pack_fclose(file);
***************
*** 738,741 ****
--- 766,771 ----
          if (xmlStrEqual(cur->name, BAD_CAST "layer")) {
              if (layerNr < 2) {
+                 console.log(CON_LOG, CON_VDEBUG, "- Loading layer %d",
+                         layerNr + 1);
                  mapLayers[layerNr]->loadFrom(cur, tileRepository);
                  layerNr++;
***************
*** 752,755 ****
--- 782,788 ----
              // Spawn the object
              prop = xmlGetProp(cur, BAD_CAST "type");
+             
+             console.log(CON_LOG, CON_VDEBUG, "- Adding %s at (%d, %d)",
+                     (char*)prop, x, y);
              addObject(
                      double(x) / TILES_W,
***************
*** 869,878 ****
                  dest, font,
                  cameraScreenRect.x + 10, cameraScreenRect.y + 10,
!                 makecol(200,200,200), -1, "%i entities",
                  objects.size());
          textprintf_ex(
                  dest, font,
                  cameraScreenRect.x + 10, cameraScreenRect.y + 20,
!                 makecol(200,200,200), -1, "%i drawn entities",
                  visibleEnts.size());
      }
--- 902,911 ----
                  dest, font,
                  cameraScreenRect.x + 10, cameraScreenRect.y + 10,
!                 makecol(200,200,200), -1, "%d entities",
                  objects.size());
          textprintf_ex(
                  dest, font,
                  cameraScreenRect.x + 10, cameraScreenRect.y + 20,
!                 makecol(200,200,200), -1, "%d drawn entities",
                  visibleEnts.size());
      }
***************
*** 903,913 ****
          textprintf_ex(
                  dest, font,
!                 cameraScreenRect.x + 10, cameraScreenRect.y + 10,
!                 makecol(200,200,200), -1, "%i entities",
!                 objects.size());
!         textprintf_ex(
!                 dest, font,
!                 cameraScreenRect.x + 10, cameraScreenRect.y + 20,
!                 makecol(200,200,200), -1, "%i drawn entities",
                  visibleEnts.size());
      }
--- 936,941 ----
          textprintf_ex(
                  dest, font,
!                 cameraScreenRect.x + 10, cameraScreenRect.y + 30,
!                 makecol(200,200,200), -1, "%d drawn sky entities",
                  visibleEnts.size());
      }

Index: module.cpp
===================================================================
RCS file: /cvsroot/moeng/BBRpg/src/shared/module.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** module.cpp	13 Apr 2004 12:28:33 -0000	1.1
--- module.cpp	25 Apr 2004 16:39:53 -0000	1.2
***************
*** 18,21 ****
--- 18,22 ----
  #include <string.h>
  #include <dirent.h>
+ #include <string>
  #include "../common.h"
  #include "module.h"
***************
*** 31,39 ****
      
      // Open the datafile
!     char *filename = new char[strlen(name) + 1 + 4];
!     strcpy(filename, name);
!     strcat(filename, ".dat");
!     datafile = load_datafile(filename);
!     delete[] filename;
  }
  
--- 32,39 ----
      
      // Open the datafile
!     datafile_name = new char[strlen(name) + 1 + 4];
!     sprintf(datafile_name, "%s.dat", name);
! 
!     script_data = NULL;
  }
  
***************
*** 41,47 ****
  {
      delete[] path;
  }
  
! void Module::loadScript(const char *name)
  {
      // Create the indent
--- 41,48 ----
  {
      delete[] path;
+     delete[] datafile_name;
  }
  
! void Module::loadScript(std::string name)
  {
      // Create the indent
***************
*** 50,70 ****
      for (i = 0; i < loadLevel; i++) spaces[i] = ' ';
      spaces[loadLevel] = '\0';
  
      char *script = findScript(name);
      if (script) {
!         if (loadedScripts.find(script) == loadedScripts.end()) {
!             loadedScripts.insert(script);
!             console.log(CON_LOG, CON_ALWAYS, "%s> \"%s\"", spaces, name);
!             if (luaL_loadbuffer(L, script, strlen(script), name))
!             {
!                 lua_error(L);
!             }
!             loadLevel++;
!             lua_call(L, 0, 0); // call main
!             loadLevel--;
          }
      }
      else {
!         console.log(CON_LOG, CON_ALWAYS, "%sX \"%s\" not found!", spaces, name);
      }
      
--- 51,75 ----
      for (i = 0; i < loadLevel; i++) spaces[i] = ' ';
      spaces[loadLevel] = '\0';
+     map<std::string, char*, ltstr>::iterator script_i = scripts.find(name);
+ 
+     if (script_i != scripts.end()) {
+         console.log(CON_LOG, CON_VDEBUG, "%s# Already loaded \"%s\"",
+                 spaces, name.c_str());
+         return;
+     }
  
      char *script = findScript(name);
      if (script) {
!         console.log(CON_LOG, CON_ALWAYS, "%s> \"%s\"", spaces, name.c_str());
!         if (luaL_loadbuffer(L, script, strlen(script), name.c_str()))
!         {
!             lua_error(L);
          }
+         loadLevel++;
+         lua_call(L, 0, 0); // call main
+         loadLevel--;
      }
      else {
!         console.log(CON_LOG, CON_ALWAYS, "%sX \"%s\" not found!", spaces, name.c_str());
      }
      
***************
*** 76,80 ****
      console.log(CON_LOG, CON_ALWAYS, "Loading scripts from \"%s\"...", path);
  
-     int i;
      char *dirname = makeFilename("", "/scripts");
      DIR *dir;
--- 81,84 ----
***************
*** 94,127 ****
      else {
          // Read the scripts from the datafile
!         const char *name;
!         for (i = 0; datafile[i].type != DAT_END; i++) {
!             name = get_datafile_property(datafile + i, DAT_NAME);
!             if (datafile[i].type == DAT_LUA) {
!                 loadLevel = 0;
!                 loadScript(name);
              }
          }
      }
  
      delete[] dirname;
  }
  
! TiledMap* Module::loadMap(const char *name)
  {
-     console.log(CON_LOG, CON_ALWAYS, "Loading map \"%s\"...", name);
      TiledMap *mmap = NULL;
!     char *filename = makeFilename(name, "/maps");
  
      if (exists(filename)) {
          mmap = new SquareMap(TILES_W, TILES_H);
!         mmap->loadMap(filename);
      }
!     else if (datafile) {
!         DATAFILE *df = find_datafile_object(datafile, name);
          if (df) {
-             //char *mapstring = new char[df->size + 1];
-             //memcpy(mapstring, df->dat, df->size);
-             //mapstring[df->size] = '\0';
- 
              xmlDocPtr doc = xmlReadMemory((char*)df->dat, df->size,
                      NULL, NULL, 0);
--- 98,149 ----
      else {
          // Read the scripts from the datafile
!         script_data = load_datafile_object(datafile_name, "data/scripts");
!         if (script_data) {
!             DATAFILE *temp = (DATAFILE*)script_data->dat;
!             const char *name;
!             while (temp->type != DAT_END) {
!                 if (temp->type == DAT_DATA) {
!                     name = get_datafile_property(temp, DAT_NAME);
!                     loadLevel = 0;
!                     loadScript(name);
!                 }
!                 temp++;
              }
+             
+             // Unload the datafile
+             unload_datafile_object(script_data);
+             script_data = NULL;
          }
      }
  
+     // Clean up any loaded scripts
+     /*
+     set<const char*>::iterator i;
+     for (i = loadedScripts.begin(); i != loadedScripts.end(); i++) {
+         delete[] (*i);
+     }
+     loadedScripts.clear();
+     */
+ 
      delete[] dirname;
  }
  
! TiledMap* Module::loadMap(std::string name)
  {
      TiledMap *mmap = NULL;
!     char *filename = makeFilename(name.c_str(), "/maps");
!     console.log(CON_LOG, CON_ALWAYS, "Loading map \"%s\"...", filename);
  
      if (exists(filename)) {
          mmap = new SquareMap(TILES_W, TILES_H);
!         if (mmap) {
!             mmap->loadMap(filename);
!         } else {
!             console.log(CON_QUIT, CON_ALWAYS, "Insufficient memory for map!");
!         }
      }
!     else {
!         DATAFILE *df = load_datafile_object(datafile_name, filename);
          if (df) {
              xmlDocPtr doc = xmlReadMemory((char*)df->dat, df->size,
                      NULL, NULL, 0);
***************
*** 132,150 ****
                  xmlFreeDoc(doc);
              }
          }
      }
  
-     //if (mmap) {
-     //    maps.push_front(mmap);
-     //}
- 
      delete[] filename;
      return mmap;
  }
  
! BITMAP* Module::findBitmap(const char *name)
  {
      BITMAP *bitmap = NULL;
!     map<const char*, BITMAP*, ltstr>::iterator i = bitmaps.find(name);
  
      if (i != bitmaps.end()) {
--- 154,169 ----
                  xmlFreeDoc(doc);
              }
+             unload_datafile_object(df);
          }
      }
  
      delete[] filename;
      return mmap;
  }
  
! BITMAP* Module::findBitmap(std::string name)
  {
      BITMAP *bitmap = NULL;
!     map<std::string, BITMAP*, ltstr>::iterator i = bitmaps.find(name);
  
      if (i != bitmaps.end()) {
***************
*** 152,166 ****
      }
      else {
!         char *filename = makeFilename(name, "/bitmaps");
      
          // Attempt to load from disk, and otherwise from the datafile
          if (exists(filename)) {
              bitmap = load_bitmap(filename, NULL);
-             console.log(CON_LOG, CON_DEBUG, "From disk: \"%s\"", name);
          }
!         else if (datafile) {
!             DATAFILE *df = find_datafile_object(datafile, name);
!             if (df) bitmap = (BITMAP*)df->dat;
!             console.log(CON_LOG, CON_DEBUG, "From datafile: \"%s\"", name);
          }
      
--- 171,184 ----
      }
      else {
!         char *filename = makeFilename(name.c_str(), "/bitmaps");
      
          // Attempt to load from disk, and otherwise from the datafile
          if (exists(filename)) {
              bitmap = load_bitmap(filename, NULL);
          }
!         else {
!             char *magicFilename = addMagic(filename);
!             bitmap = load_bitmap(magicFilename, NULL);
!             delete[] magicFilename;
          }
      
***************
*** 172,179 ****
  }
  
! MIDI* Module::findMidi(const char *name)
  {
      MIDI *midi = NULL;
!     map<const char*, MIDI*, ltstr>::iterator i = midis.find(name);
  
      if (i != midis.end()) {
--- 190,198 ----
  }
  
! MIDI* Module::findMidi(std::string name)
  {
      MIDI *midi = NULL;
!     map<std::string, MIDI*, ltstr>::iterator i = midis.find(name);
!     char *filename = makeFilename(name.c_str(), "/music");
  
      if (i != midis.end()) {
***************
*** 181,185 ****
      }
      else {
-         char *filename = makeFilename(name, "/music");
      
          // Attempt to load from disk, and otherwise from the datafile
--- 200,203 ----
***************
*** 187,206 ****
              midi = load_midi(filename);
          }
!         else if (datafile) {
!             DATAFILE *df = find_datafile_object(datafile, name);
!             if (df) midi = (MIDI*)df->dat;
          }
      
          if (midi) midis[name] = midi;
-         delete[] filename;
      }
      
      return midi;
  }
  
! SAMPLE* Module::findSample(const char *name)
  {
      SAMPLE *sample = NULL;
!     map<const char*, SAMPLE*, ltstr>::iterator i = samples.find(name);
  
      if (i != samples.end()) {
--- 205,226 ----
              midi = load_midi(filename);
          }
!         else {
!             char *magicFilename = addMagic(filename);
!             midi = load_midi(magicFilename);
!             delete[] magicFilename;
          }
      
          if (midi) midis[name] = midi;
      }
      
+     delete[] filename;
      return midi;
  }
  
! SAMPLE* Module::findSample(std::string name)
  {
      SAMPLE *sample = NULL;
!     map<std::string, SAMPLE*, ltstr>::iterator i = samples.find(name);
!     char *filename = makeFilename(name.c_str(), "/samples");
  
      if (i != samples.end()) {
***************
*** 208,212 ****
      }
      else {
-         char *filename = makeFilename(name, "/samples");
      
          // Attempt to load from disk, and otherwise from the datafile
--- 228,231 ----
***************
*** 214,233 ****
              sample = load_sample(filename);
          }
!         else if (datafile) {
!             DATAFILE *df = find_datafile_object(datafile, name);
!             if (df) sample = (SAMPLE*)df->dat;
          }
      
          if (sample) samples[name] = sample;
-         delete[] filename;
      }
      
      return sample;
  }
  
! FONT* Module::findFont(const char *name)
  {
      FONT *font = NULL;
!     map<const char*, FONT*, ltstr>::iterator i = fonts.find(name);
  
      if (i != fonts.end()) {
--- 233,253 ----
              sample = load_sample(filename);
          }
!         else {
!             char *magicFilename = addMagic(filename);
!             sample = load_sample(magicFilename);
!             delete[] magicFilename;
          }
      
          if (sample) samples[name] = sample;
      }
      
+     delete[] filename;
      return sample;
  }
  
! FONT* Module::findFont(std::string name)
  {
      FONT *font = NULL;
!     map<std::string, FONT*, ltstr>::iterator i = fonts.find(name);
  
      if (i != fonts.end()) {
***************
*** 236,241 ****
      else {
          // Allegro can only load fonts from a datafile
!         if (datafile) {
!             DATAFILE *df = find_datafile_object(datafile, name);
              if (df) font = (FONT*)df->dat;
          }
--- 256,261 ----
      else {
          // Allegro can only load fonts from a datafile
!         if (engine_data) {
!             DATAFILE *df = find_datafile_object(engine_data, name.c_str());
              if (df) font = (FONT*)df->dat;
          }
***************
*** 247,254 ****
  }
  
! char* Module::findScript(const char *name)
  {
      char *script = NULL;
!     map<const char*, char*, ltstr>::iterator i = scripts.find(name);
  
      if (i != scripts.end()) {
--- 267,275 ----
  }
  
! char* Module::findScript(std::string name)
  {
      char *script = NULL;
!     map<std::string, char*, ltstr>::iterator i = scripts.find(name);
!     char *filename = makeFilename(name.c_str(), "/scripts");
  
      if (i != scripts.end()) {
***************
*** 256,288 ****
      }
      else {
-         char *filename = makeFilename(name, "/scripts");
- 
          if (exists(filename)) {
              FILE* f = fopen(filename, "rb");
  
              // Get size of file
              fseek(f, 0, SEEK_END);
              long size = ftell(f);
              rewind(f);
!             
              // Read file into character array
              script = new char[size + 1];
              fread(script, 1, size, f);
              script[size] = '\0';
              fclose(f);
          }
!         else if (datafile) {
!             DATAFILE *df = find_datafile_object(datafile, name);
              if (df) {
                  script = new char[df->size + 1];
                  memcpy(script, df->dat, df->size);
                  script[df->size] = '\0';
              }
          }
  
          if (script) scripts[name] = script;
-         delete[] filename;
      }
!     
      return script;
  }
--- 277,315 ----
      }
      else {
          if (exists(filename)) {
              FILE* f = fopen(filename, "rb");
  
+             if (!f) {
+                 console.log(CON_QUIT, CON_ALWAYS,
+                         "Error: %s seems to exist but failed to open!",
+                         filename);
+             }
+ 
              // Get size of file
              fseek(f, 0, SEEK_END);
              long size = ftell(f);
              rewind(f);
! 
              // Read file into character array
              script = new char[size + 1];
              fread(script, 1, size, f);
              script[size] = '\0';
+ 
              fclose(f);
          }
!         else {
!             DATAFILE *df = load_datafile_object(datafile_name, filename);
              if (df) {
                  script = new char[df->size + 1];
                  memcpy(script, df->dat, df->size);
                  script[df->size] = '\0';
+                 unload_datafile_object(df);
              }
          }
  
          if (script) scripts[name] = script;
      }
! 
!     delete[] filename;
      return script;
  }
***************
*** 292,299 ****
      int length = strlen(path) + strlen(subdir) + strlen(name) + 2;
      char *filename = new char[length];
!     strcpy(filename, path);
!     strcat(filename, subdir);
!     strcat(filename, "/");
!     strcat(filename, name);
      return filename;
  }
--- 319,331 ----
      int length = strlen(path) + strlen(subdir) + strlen(name) + 2;
      char *filename = new char[length];
!     sprintf(filename, "%s%s/%s", path, subdir, name);
!     return filename;
! }
! 
! char* Module::addMagic(const char *file)
! {
!     int length = strlen(path) + strlen(file) + 6;
!     char *filename = new char[length];
!     sprintf(filename, "%s.dat#%s", path, file);
      return filename;
  }