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; |
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 |
|
|
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 |
//---------------------------------------- |
//---------------------------------------- |
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 |
} |
} |
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 |
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"; |
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; |