/[enigma]/enigma/src/oxyd.cc
ViewVC logotype

Diff of /enigma/src/oxyd.cc

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.46 by reallysoft, Sun Jun 1 18:50:23 2003 UTC revision 1.47 by reallysoft, Mon Jun 2 22:50:12 2003 UTC
# Line 72  namespace Line 72  namespace
72              return m_created;              return m_created;
73          }          }
74    
75            int get_default_SoundSet() const { return m_version+2; }
76    
77      protected:      protected:
78          /* Conversion tables from Oxyd bytecodes to Enigma object names. */          /* Conversion tables from Oxyd bytecodes to Enigma object names. */
79          enigma_mapping::Mapping m_mapping;          enigma_mapping::Mapping m_mapping;
# Line 91  namespace Line 93  namespace
93    
94          // Variables          // Variables
95          OxydVersion  m_version;          OxydVersion  m_version;
96          DatFile     *m_datfile;          DatFile     *m_datfile; // just a reference (owned by GameInfo)
97          time_t       m_created; // creation date of datafile          time_t       m_created; // creation date of datafile
98          Level       *m_level;   // Level currently being loaded          Level       *m_level;   // Level currently being loaded
99    
# Line 581  namespace Line 583  namespace
583      class GameInfo {      class GameInfo {
584      public:      public:
585          GameInfo();          GameInfo();
586          GameInfo (const string &game_, const string &datfile_);          GameInfo (OxydVersion ver_, const string &game_, const string &datfile_name_);
587            ~GameInfo() {
588    //             delete datfile;
589            }
590    
591          bool isPresent() const { return is_present; }          bool isPresent() const { return is_present; }
592          const string& datfilePath() const { return datfile_path; }          DatFile *getDatfile() { return datfile; }
593          time_t getModTime() const { return modified; }  
594    //         const string& datfilePath() const { return datfile_path; }
595    //         time_t getModTime() const { return modified; }
596    
597      private:      private:
598          // Variables.          // Variables.
599          string game;          OxydVersion  ver;
600          string datfile;          string       game;
601          string datfile_path;          DatFile     *datfile;
602          bool   is_present;          string       datfile_path;
603          time_t modified; // !is_present -> 0          bool         is_present;
604            time_t       modified;  // !is_present -> 0
605    
606            void       openDatFile();
607            LevelPack *makeLevelPack(bool twoplayer);
608      };      };
609  }  }
610    
611  GameInfo::GameInfo()  GameInfo::GameInfo()
612      : is_present(false), modified(0)      : ver(OxydVersion_Invalid), datfile(0), is_present(false), modified(0)
613  {}  {}
614    
615    
616  GameInfo::GameInfo (const string &game_, const string &datfile_)  GameInfo::GameInfo (OxydVersion ver_, const string &game_, const string &datfile_name_)
617      : game(game_), datfile(datfile_), is_present(false), modified(0)      : ver(ver_), game(game_), /*datfile_name(datfile_name_), */is_present(false), modified(0)
618  {  {
619      string fname;      string fname;
620      if (FindFile (datfile, datfile_path)) {      if (FindFile (datfile_name_, datfile_path)) {
621          enigma::Log << "Found " << game << " data file\n";          enigma::Log << "Found " << game << " data file\n";
622          is_present = true;          is_present = true;
623          modified   = sysdep::FileModTime(datfile_path);          openDatFile();
624    
625            if (is_present) {
626                if (LevelPack *lp = makeLevelPack(false))
627                    enigma::LevelPacks.push_back(lp);
628                if (LevelPack *lp = makeLevelPack(true))
629                    enigma::LevelPacks.push_back(lp);
630            }
631        }
632    }
633    
634    void GameInfo::openDatFile() {
635        assert(is_present);
636    
637        ByteVec data;
638        readFile (datfile_path, &data);
639    
640        datfile  = new DatFile;
641        modified = sysdep::FileModTime(datfile_path);
642    
643        string errmsg;
644        if (!parseDatFile (data, ver, datfile, &errmsg)) {
645            enigma::Log << "Error loading " << datfile_path << ": " << errmsg << endl;
646            delete datfile;
647            datfile    = 0;
648            is_present = false;
649        } else {
650            enigma::Log << "Loaded "<< datfile_path << endl;
651        }
652    }
653    
654    LevelPack *GameInfo::makeLevelPack(bool twoplayers) {
655        if (datfile == 0 || ver == OxydVersion_Invalid)
656            return 0;
657    
658        if (twoplayers && (ver == OxydVersion_OxydExtra ||
659                           ver == OxydVersion_OxydMagnum ||
660                           ver == OxydVersion_OxydMagnumGold))
661            return 0;           // no twoplayer levels available
662    
663        switch (ver) {
664            case OxydVersion_Oxyd1:
665                return new LP_Oxyd1 (datfile, modified, twoplayers);
666            case OxydVersion_PerOxyd:
667                return new LP_PerOxyd (datfile, modified, twoplayers);
668            case OxydVersion_OxydMagnum:
669            case OxydVersion_OxydMagnumGold:
670                return new LP_OxydMagnum (ver, datfile, modified);
671            default: {
672                int firstlevel = twoplayers ? 100 : 0;
673                int lastlevel = twoplayers ? 199 : 99;
674                return new LevelPack_Oxyd(ver, datfile, modified, firstlevel, lastlevel);
675            }
676      }      }
677    
678  }  }
679    
680  //----------------------------------------  //----------------------------------------
# Line 618  GameInfo::GameInfo (const string &game_, Line 682  GameInfo::GameInfo (const string &game_,
682  //----------------------------------------  //----------------------------------------
683  namespace  namespace
684  {  {
685      vector<GameInfo>  games;      vector<GameInfo> games;
686      DatFile          *datfile = 0;  
687      time_t            datfile_modtime; // modification date of datfile      int active_soundset              = 1; // 1: enigma  2..: OxydVersion+2;
688      OxydVersion       oxyd_version;      DatFile *active_soundset_datfile = 0;
689    
690      map <string,string> soundfx_map;      map <string,string> soundfx_map;
691  }  }
# Line 631  enigma::oxyd::Init() Line 695  enigma::oxyd::Init()
695  {  {
696      games.clear();      games.clear();
697      games.resize(OxydVersion_Count);      games.resize(OxydVersion_Count);
     games[OxydVersion_PerOxyd]        = GameInfo("Per.Oxyd",         "peroxyd.dat");  
     games[OxydVersion_Oxyd1]          = GameInfo("Oxyd 1",           "oxyd1ibm.dat");  
     games[OxydVersion_OxydMagnum]     = GameInfo("Oxyd magnum",      "oxydmibm.dat");  
     games[OxydVersion_OxydMagnumGold] = GameInfo("Oxyd magnum gold", "oxydmgg.dat");  
     games[OxydVersion_OxydExtra]      = GameInfo("Oxyd extra",       "oxydex.dat");  
698    
699      oxyd_version = OxydVersion_Invalid;      games[OxydVersion_Oxyd1]          = GameInfo(OxydVersion_Oxyd1,          "Oxyd 1",           "oxyd1ibm.dat");
700        games[OxydVersion_OxydMagnum]     = GameInfo(OxydVersion_OxydMagnum,     "Oxyd magnum",      "oxydmibm.dat");
701        games[OxydVersion_OxydMagnumGold] = GameInfo(OxydVersion_OxydMagnumGold, "Oxyd magnum gold", "oxydmgg.dat");
702        games[OxydVersion_OxydExtra]      = GameInfo(OxydVersion_OxydExtra,      "Oxyd extra",       "oxydex.dat");
703        games[OxydVersion_PerOxyd]        = GameInfo(OxydVersion_PerOxyd,        "Per.Oxyd",         "peroxyd.dat");
704    
705    //     oxyd_version = OxydVersion_Invalid;
706  }  }
707    
708  bool  bool
# Line 646  enigma::oxyd::FoundOxyd (OxydVersion ver Line 711  enigma::oxyd::FoundOxyd (OxydVersion ver
711      return games[ver].isPresent();      return games[ver].isPresent();
712  }  }
713    
 DatFile *  
 enigma::oxyd::GetDatFile ()  
 {  
     return datfile;  
 }  
   
 bool  
 enigma::oxyd::SetDatFile (DatFile *new_datfile, OxydVersion ver)  
 {  
     assert(new_datfile != 0);  
714    
715      oxyd_version = ver;  void
716      datfile      = new_datfile;  enigma::oxyd::ChangeSoundset (int sound_set, int default_sound_set)
   
     return( true);  
 }  
   
 bool  
 enigma::oxyd::OpenDatFile (OxydVersion ver)  
717  {  {
718      if (FoundOxyd(ver)) {      static int last_default_sound_set = 1;
         string fname = games[ver].datfilePath();  
         ByteVec data;  
         readFile (fname, &data);  
719    
720          datfile         = new DatFile;      // if called without knowing default sound set
721          datfile_modtime = games[ver].getModTime();      // take last default or default to enigma
722        // (e.g when called from option menu from inside game)
723        if (default_sound_set == -1)
724            default_sound_set = last_default_sound_set;
725        else
726            last_default_sound_set = default_sound_set;
727    
728          string errmsg;      if (sound_set == 0) {       // use specific soundset for each levelpack
729          if (!parseDatFile (data, ver, datfile, &errmsg)) {          sound_set = default_sound_set;
             enigma::Log << "Error loading " << fname << ": " << errmsg << endl;  
             delete datfile;  
             datfile = 0;  
         } else {  
             enigma::Log << "Loaded "<< fname << endl;  
         }  
730      }      }
     if (datfile)  
         oxyd_version = ver;  
     return true;  
 }  
   
 LevelPack *  
 enigma::oxyd::MakeLevelPack (bool twoplayers)  
 {  
     if (datfile == 0 || oxyd_version == OxydVersion_Invalid)  
         return 0;  
   
     if (twoplayers && (oxyd_version == OxydVersion_OxydExtra  
                        || oxyd_version == OxydVersion_OxydMagnum  
                        || oxyd_version == OxydVersion_OxydMagnumGold))  
         return 0;           // no twoplayer levels available  
731    
732      switch (oxyd_version) {      if (sound_set == active_soundset) {
733      case OxydVersion_Oxyd1:          return;
         return new LP_Oxyd1 (datfile, datfile_modtime, twoplayers);  
     case OxydVersion_PerOxyd:  
         return new LP_PerOxyd (datfile, datfile_modtime, twoplayers);  
     case OxydVersion_OxydMagnum:  
     case OxydVersion_OxydMagnumGold:  
         return new LP_OxydMagnum (oxyd_version, datfile, datfile_modtime);  
     default:  
         {  
             int firstlevel = twoplayers ? 100 : 0;  
             int lastlevel = twoplayers ? 199 : 99;  
             return new LevelPack_Oxyd (oxyd_version, datfile, datfile_modtime, firstlevel, lastlevel);  
         }  
734      }      }
 }  
735    
736        // reset to enigma soundset
737        soundfx_map.clear();
738        active_soundset         = 1;
739        active_soundset_datfile = 0;
740        sound::ClearSoundCache();
741    
742  void      if (sound_set == 1) {       // enigma -> no mapping
 enigma::oxyd::UseOxydSounds (bool ok)  
 {  
     if (!ok) {  
         soundfx_map.clear();  
743          return;          return;
744      }      }
745    
746        OxydVersion ver = OxydVersion(sound_set-2);
747        GameInfo&   gi  = games[ver];
748    
749        if (!gi.isPresent())
750            return;                 // not installed -> use enigma soundset
751    
752        active_soundset         = sound_set;
753        active_soundset_datfile = gi.getDatfile();
754    
755      soundfx_map["intro"]         = "OXINTRO.SDD";      soundfx_map["intro"]         = "OXINTRO.SDD";
756      soundfx_map["exit"]          = "OXEXIT.SDD";      soundfx_map["exit"]          = "OXEXIT.SDD";
757      soundfx_map["finished"]      = "OXFINITO.SDD";      soundfx_map["finished"]      = "OXFINITO.SDD";
# Line 780  Mix_Chunk * Line 807  Mix_Chunk *
807  enigma::oxyd::LoadSound (const std::string &name)  enigma::oxyd::LoadSound (const std::string &name)
808  {  {
809      Mix_Chunk *chunk = 0;      Mix_Chunk *chunk = 0;
810      if (datfile) {      if (active_soundset_datfile) {
811          string chunkname = soundfx_map[name];          string         chunkname = soundfx_map[name];
812          const ByteVec *snddata = datfile->getChunk(chunkname);          const ByteVec *snddata   = active_soundset_datfile->getChunk(chunkname);
813    
814          if (snddata) {          if (snddata) {
815              enigma::Log << "Loaded sound file " << name << " =^= " << chunkname<<endl;              enigma::Log << "Loaded sound file " << name << " =^= " << chunkname<<endl;
816              const int offset = 16;              const int offset = 16;

Legend:
Removed from v.1.46  
changed lines
  Added in v.1.47

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26