openboe/oboe
2
0
Fork 0
Code Issues 146 Pull Requests 4 Actions Packages Projects Releases Wiki Activity
Files
8d4cea7d0b7df1547f4ca8975fcac22021902a6e
oboe/src/tools/fileio_scen.cpp

593 lines
19 KiB
C++
Raw Blame History

//
// fileio_scen.cpp
// BoE
//
// Created by Celtic Minstrel on 15-01-24.
//
//
#include "fileio.hpp"
#include <fstream>
#include <boost/filesystem/operations.hpp>
#include "dlogutil.hpp"
#include "scenario.h"
#include "regtown.h"
#include "map_parse.hpp"
#include "graphtool.hpp"
#include "mathutil.hpp"
#include "gzstream.h"
#include "tarball.hpp"
#include "porting.hpp"
#include "restypes.hpp"
bool cur_scen_is_mac = true;
extern sf::Texture items_gworld,tiny_obj_gworld,fields_gworld,roads_gworld,boom_gworld,missiles_gworld;
extern sf::Texture dlogpics_gworld,monst_gworld[],terrain_gworld[],anim_gworld,talkfaces_gworld,pc_gworld;
extern sf::Texture status_gworld, vehicle_gworld, small_ter_gworld;
extern cCustomGraphics spec_scen_g;
//fs::path progDir, tempDir;
void load_spec_graphics(fs::path scen_file);
// Load old scenarios (town talk is handled by the town loading function)
static bool load_scenario_v1(fs::path file_to_load, cScenario& scenario);
static bool load_outdoors_v1(fs::path scen_file, location which_out,cOutdoors& the_out, legacy::scenario_data_type& scenario);
static bool load_town_v1(fs::path scen_file,short which_town,cTown& the_town,legacy::scenario_data_type& scenario,std::vector<shop_info_t>& shops);
// Load new scenarios
static bool load_scenario_v2(fs::path file_to_load, cScenario& scenario);
static bool load_outdoors(fs::path out_base, location which_out, cOutdoors& the_out);
static bool load_town(fs::path town_base, short which_town, cTown*& the_town);
static bool load_town_talk(fs::path town_base, short which_town, cSpeech& the_talk);
bool load_scenario(fs::path file_to_load, cScenario& scenario) {
scenario = cScenario();
std::string fname = file_to_load.filename().string();
size_t dot = fname.find_last_of('.');
if(fname.substr(dot) == ".boes")
return load_scenario_v2(file_to_load, scenario);
else if(fname.substr(dot) == ".exs")
return load_scenario_v1(file_to_load, scenario);
giveError("That is not a Blades of Exile scenario.");
return false;
}
template<typename Container> static void port_shop_spec_node(cSpecial& spec, std::vector<shop_info_t>& shops, Container strs) {
int which_shop;
if(spec.ex1b < 4) {
shops.push_back({eShopItemType(spec.ex1b + 1), spec.ex1a, spec.ex2a, strs[spec.m1]});
which_shop = shops.size() + 5;
} else if(spec.ex1b == 4)
which_shop = 5;
else which_shop = spec.ex1b - 5;
spec.ex1a = which_shop;
spec.ex1b = spec.ex2b;
spec.ex2a = spec.ex2b = -1;
}
bool load_scenario_v1(fs::path file_to_load, cScenario& scenario){
short i,n;
bool file_ok = false;
long len;
char temp_str[256];
legacy::scenario_data_type *temp_scenario = new legacy::scenario_data_type;
legacy::scen_item_data_type *item_data = new legacy::scen_item_data_type;
// TODO: Convert this (and all the others in this file) to use C++ streams
FILE* file_id = fopen(file_to_load.string().c_str(),"rb");
if(file_id == NULL) {
// TODO: The third parameter to oopsError is supposed to specify whether we're in the scenario editor or the game, but I don't think this code knows that.
// TODO: Alternatively, nuke oopsError and just use giveError. It's more informative, anyway.
oopsError(10, 0, 0);
return false;
}
len = (long) sizeof(scenario_header_flags);
if(fread(&scenario.format, len, 1, file_id) < 1){
fclose(file_id);
oopsError(11, 0, 0);
return false;
}
if((scenario.format.flag1 == 10) && (scenario.format.flag2 == 20) &&
(scenario.format.flag3 == 30) && (scenario.format.flag4 == 40)) {
cur_scen_is_mac = true;
file_ok = true;
}
else if((scenario.format.flag1 == 20) && (scenario.format.flag2 == 40) &&
(scenario.format.flag3 == 60) && (scenario.format.flag4 == 80)) {
cur_scen_is_mac = false;
file_ok = true;
} else if(scenario.format.flag1 == 'O' && scenario.format.flag2 == 'B' && scenario.format.flag3 == 'O' && scenario.format.flag4 == 'E') {
// This means we're looking at the scenario header file of an unpacked new-format scenario.
return load_scenario_v2(file_to_load.parent_path(), scenario);
}
if(!file_ok) {
fclose(file_id);
giveError("This is not a legitimate Blades of Exile scenario.");
return false;
}
len = (long) sizeof(legacy::scenario_data_type);
n = fread(temp_scenario, len, 1, file_id);
if(n < 1){
fclose(file_id);
oopsError(12, 0, 0);
return false;
}
port_scenario(temp_scenario);
len = sizeof(legacy::scen_item_data_type); // item data
n = fread(item_data, len, 1, file_id);
if(n < 1){
fclose(file_id);
oopsError(13, 0, 0);
return false;
}
port_item_list(item_data);
scenario.append(*temp_scenario);
scenario.append(*item_data);
// TODO: Consider skipping the fread and assignment when len is 0
for(i = 0; i < 270; i++) {
len = (long) (temp_scenario->scen_str_len[i]);
n = fread(temp_str, len, 1, file_id);
temp_str[len] = 0;
if(i == 0) scenario.scen_name = temp_str;
else if(i == 1 || i == 2)
scenario.who_wrote[i-1] = temp_str;
else if(i == 3)
scenario.contact_info = temp_str;
else if(i >= 4 && i < 10)
scenario.intro_strs[i-4] = temp_str;
else if(i >= 10 && i < 60)
scenario.journal_strs[i-10] = temp_str;
else if(i >= 60 && i < 160) {
if(i % 2 == 0) scenario.special_items[(i-60)/2].name = temp_str;
else scenario.special_items[(i-60)/2].descr = temp_str;
} else if(i >= 260) continue; // These were never ever used, for some reason.
else scenario.spec_strs[i-160] = temp_str;
}
fclose(file_id);
scenario.ter_types[23].fly_over = false;
scenario.scen_file = file_to_load;
load_spec_graphics(scenario.scen_file);
// Now load all the outdoor sectors
scenario.outdoors.resize(temp_scenario->out_width, temp_scenario->out_height);
for(int x = 0; x < temp_scenario->out_width; x++) {
for(int y = 0; y < temp_scenario->out_height; y++) {
scenario.outdoors[x][y] = new cOutdoors(scenario);
load_outdoors_v1(scenario.scen_file, loc(x,y), *scenario.outdoors[x][y], *temp_scenario);
}
}
// Need to build a list of shops used in the scenario
std::vector<shop_info_t> shops;
// Then load all the towns
scenario.towns.resize(scenario.format.num_towns);
for(int i = 0; i < scenario.format.num_towns; i++) {
switch(temp_scenario->town_size[i]) {
case 0: scenario.towns[i] = new cBigTown(scenario); break;
case 1: scenario.towns[i] = new cMedTown(scenario); break;
case 2: scenario.towns[i] = new cTinyTown(scenario); break;
}
load_town_v1(scenario.scen_file, i, *scenario.towns[i], *temp_scenario, shops);
}
// Enable character creation in starting town
scenario.towns[scenario.which_town_start]->has_tavern = true;
// Check special nodes in case there were outdoor shops
for(cSpecial& spec : scenario.scen_specials) {
if(spec.type == eSpecType::ENTER_SHOP)
port_shop_spec_node(spec, shops, scenario.spec_strs);
}
for(cOutdoors* out : scenario.outdoors) {
for(cSpecial& spec : out->specials) {
if(spec.type == eSpecType::ENTER_SHOP)
port_shop_spec_node(spec, shops, out->spec_strs);
}
}
// We'll check town nodes too, just in case.
for(cTown* town : scenario.towns) {
for(cSpecial& spec : town->specials) {
if(spec.type == eSpecType::ENTER_SHOP)
port_shop_spec_node(spec, shops, town->spec_strs);
}
}
// Now we have to build all those shops
for(shop_info_t info : shops) {
pic_num_t face = 0;
if(info.type == eShopItemType::MAGE_SPELL || info.type == eShopItemType::PRIEST_SPELL || info.type == eShopItemType::ALCHEMY)
face = 43;
else if(info.type == eShopItemType::ITEM) {
bool is_food_shop = true;
for(int i = info.first; i < info.first + info.count && i < scenario.scen_items.size(); i++) {
if(scenario.scen_items[i].variety != eItemType::FOOD)
is_food_shop = false;
}
if(is_food_shop)
face = 42;
}
eShopType type = eShopType::NORMAL;
eShopPrompt prompt = eShopPrompt::SHOPPING;
if(info.type == eShopItemType::MAGE_SPELL)
prompt = eShopPrompt::MAGE;
else if(info.type == eShopItemType::PRIEST_SPELL)
prompt = eShopPrompt::PRIEST;
else if(info.type == eShopItemType::ALCHEMY) {
prompt = eShopPrompt::ALCHEMY;
type = eShopType::ALLOW_DEAD;
}
cShop shop(type, prompt, face, 0, info.name);
if(info.type == eShopItemType::ITEM) {
int end = info.first + info.count;
end = min(end, scenario.scen_items.size());
shop.addItems(info.first, scenario.scen_items.begin() + info.first, scenario.scen_items.begin() + end, cShop::INFINITE);
} else {
int max = 62;
if(info.type == eShopItemType::ALCHEMY)
max = 20;
int end = min(max, info.first + info.count);
for(int i = info.first; i < end; i++)
shop.addSpecial(info.type, i);
}
scenario.shops.push_back(shop);
}
delete temp_scenario;
delete item_data;
return true;
}
bool load_scenario_v2(fs::path file_to_load, cScenario& scenario) {
// First determine whether we're dealing with a packed or unpacked scenario.
bool is_packed;
tarball pack;
std::ifstream fin;
if(fs::is_directory(file_to_load)) { // Unpacked
is_packed = false;
} else { // Packed
igzstream gzin(file_to_load.string().c_str());
pack.readFrom(gzin);
}
auto getFile = [&](std::string relpath) -> std::istream& {
if(is_packed) return pack.getFile(relpath);
if(fin.is_open()) fin.close();
fin.open((file_to_load/relpath).string().c_str());
// TODO: Suppress the warning about returning reference to local
return fin;
};
// From here on, we don't have to care about whether it's packed or unpacked.
return false;
}
static long get_town_offset(short which_town, legacy::scenario_data_type& scenario){
int i,j;
long len_to_jump,store;
len_to_jump = sizeof(scenario_header_flags);
len_to_jump += sizeof(legacy::scenario_data_type);
len_to_jump += sizeof(legacy::scen_item_data_type);
for(i = 0; i < 300; i++)
len_to_jump += (long) scenario.scen_str_len[i];
store = 0;
for(i = 0; i < 100; i++)
for(j = 0; j < 2; j++)
store += (long) (scenario.out_data_size[i][j]);
for(i = 0; i < which_town; i++)
for(j = 0; j < 5; j++)
store += (long) (scenario.town_data_size[i][j]);
len_to_jump += store;
return len_to_jump;
}
bool load_town_v1(fs::path scen_file, short which_town, cTown& the_town, legacy::scenario_data_type& scenario, std::vector<shop_info_t>& shops) {
short i,n;
long len,len_to_jump = 0;
char temp_str[256];
legacy::town_record_type store_town;
legacy::talking_record_type store_talk;
legacy::big_tr_type t_d;
legacy::ave_tr_type ave_t;
legacy::tiny_tr_type tiny_t;
FILE* file_id = fopen(scen_file.string().c_str(), "rb");
if(file_id == NULL) {
oopsError(14, 0, 0);
return false;
}
len_to_jump = get_town_offset(which_town, scenario);
n = fseek(file_id, len_to_jump, SEEK_SET);
if(n != 0) {
fclose(file_id);
oopsError(15, 0, 0);
return false;
}
len = sizeof(legacy::town_record_type);
n = fread(&store_town, len, 1, file_id);
if(n < 1) {
fclose(file_id);
oopsError(16, 0, 0);
return false;
}
port_town(&store_town);
switch(scenario.town_size[which_town]) {
case 0:
len = sizeof(legacy::big_tr_type);
n = fread(&t_d, len, 1, file_id);
port_t_d(&t_d);
the_town.append(store_town);
the_town.append(t_d, which_town);
break;
case 1:
len = sizeof(legacy::ave_tr_type);
n = fread(&ave_t, len, 1, file_id);
port_ave_t(&ave_t);
the_town.append(store_town);
the_town.append(ave_t, which_town);
break;
case 2:
len = sizeof(legacy::tiny_tr_type);
n = fread(&tiny_t, len, 1, file_id);
port_tiny_t(&tiny_t);
the_town.append(store_town);
the_town.append(tiny_t, which_town);
break;
}
for(i = 0; i < 140; i++) {
len = (long) (store_town.strlens[i]);
n = fread(temp_str, len, 1, file_id);
temp_str[len] = 0;
if(i == 0) the_town.town_name = temp_str;
else if(i >= 1 && i < 17)
the_town.room_rect[i-1].descr = temp_str;
else if(i >= 17 && i < 20)
the_town.comment[i-17] = temp_str;
else if(i >= 20 && i < 120)
the_town.spec_strs[i-20] = temp_str;
else if(i >= 120 && i < 140)
the_town.sign_strs[i-120] = temp_str;
}
len = sizeof(legacy::talking_record_type);
n = fread(&store_talk, len, 1, file_id);
if(n < 1) {
fclose(file_id);
oopsError(17, 0, 0);
return false;
}
port_talk_nodes(&store_talk);
for(i = 0; i < 170; i++) {
len = (long) (store_talk.strlens[i]);
n = fread(temp_str, len, 1, file_id);
temp_str[len] = 0;
if(i >= 0 && i < 10)
the_town.talking.people[i].title = temp_str;
else if(i >= 10 && i < 20)
the_town.talking.people[i-10].look = temp_str;
else if(i >= 20 && i < 30)
the_town.talking.people[i-20].name = temp_str;
else if(i >= 30 && i < 40)
the_town.talking.people[i-30].job = temp_str;
else if(i >= 160)
the_town.talking.people[i-160].dunno = temp_str;
else {
if(i % 2 == 0)
the_town.talking.talk_nodes[(i-40)/2].str1 = temp_str;
else the_town.talking.talk_nodes[(i-40)/2].str2 = temp_str;
}
}
// Do this after strings are loaded because porting shops requires access to strings
the_town.talking.append(store_talk, shops);
n = fclose(file_id);
if(n != 0) {
oopsError(18, 0, 0);
}
return true;
}
bool load_town(fs::path town_base, short which_town, cTown*& the_town) {
// TODO: This stuff goes in load_scenario() now
// fs::path town_base = scenario.scen_file/"towns";
std::string base_fname = "t" + std::to_string(which_town), fname;
// TODO: Implement all this.
// First load the main town data.
fname = base_fname + ".xml";
// Next, load in the town map.
fname = base_fname + ".map";
map_data map = load_map(town_base/fname, true);
// Then load the town's special nodes.
fname = base_fname + ".spec";
// Load the town's special encounter strings
fname = base_fname + ".txt";
// And finally, load the town's dialogue nodes.
load_town_talk(town_base, which_town, the_town->talking);
return false;
}
bool load_town_talk(fs::path town_base, short which_town, cSpeech& the_talk) {
// TODO: Implement this.
std::string fname = "t" + std::to_string(which_town) + "talk.xml";
return false;
}
static long get_outdoors_offset(location& which_out, legacy::scenario_data_type& scenario){
int i,j,out_sec_num;
long len_to_jump,store;
out_sec_num = scenario.out_width * which_out.y + which_out.x;
len_to_jump = sizeof(scenario_header_flags);
len_to_jump += sizeof(legacy::scenario_data_type);
len_to_jump += sizeof(legacy::scen_item_data_type);
for(i = 0; i < 300; i++)
len_to_jump += (long) scenario.scen_str_len[i];
store = 0;
for(i = 0; i < out_sec_num; i++)
for(j = 0; j < 2; j++)
store += (long) (scenario.out_data_size[i][j]);
len_to_jump += store;
return len_to_jump;
}
//mode -> 0 - primary load 1 - add to top 2 - right 3 - bottom 4 - left
bool load_outdoors_v1(fs::path scen_file, location which_out,cOutdoors& the_out, legacy::scenario_data_type& scenario){
short i,n;
long len,len_to_jump;
char temp_str[256];
legacy::outdoor_record_type store_out;
FILE* file_id = fopen(scen_file.string().c_str(), "rb");
if(file_id == NULL) {
oopsError(32, 0, 0);
return false;
}
len_to_jump = get_outdoors_offset(which_out, scenario);
n = fseek(file_id, len_to_jump, SEEK_SET);
if(n != 0) {
fclose(file_id);
oopsError(33, 0, 0);
return false;
}
len = sizeof(legacy::outdoor_record_type);
n = fread(&store_out, len, 1, file_id);
if(n < 1) {
fclose(file_id);
oopsError(34, 0, 0);
return false;
}
the_out.x = which_out.x;
the_out.y = which_out.y;
port_out(&store_out);
the_out.append(store_out);
for(i = 0; i < 108; i++) {
len = (long) (store_out.strlens[i]);
n = fread(temp_str, len, 1, file_id);
temp_str[len] = 0;
if(i == 0) the_out.out_name = temp_str;
else if(i == 9) the_out.comment = temp_str;
else if(i < 9) the_out.info_rect[i-1].descr = temp_str;
else if(i >= 10 && i < 100)
the_out.spec_strs[i-10] = temp_str;
else if(i >= 100 && i < 108)
the_out.sign_strs[i-100] = temp_str;
}
n = fclose(file_id);
if(n != 0) {
oopsError(35, 0, 0);
}
return true;
}
bool load_outdoors(fs::path out_base, location which_out,cOutdoors& the_out) {
// TODO: This bit goes in load_scenario() now
// fs::path town_base = scenario.scen_file/"outdoors";
std::string base_fname = "tut" + std::to_string(which_out.x) + "~" + std::to_string(which_out.y), fname;
// TODO: Implement all this.
// First load the main sector data.
fname = base_fname + ".xml";
// Next, load in the sector map.
fname = base_fname + ".map";
map_data map = load_map(out_base/fname, false);
// Then load the sector's special nodes.
fname = base_fname + ".spec";
// Load the sector's special encounter strings
fname = base_fname + ".txt";
return false;
}
#ifdef __APPLE__
bool tryLoadPictFromResourceFile(fs::path& gpath, sf::Image& graphics_store);
#endif
void load_spec_graphics(fs::path scen_file) {
static const char*const noGraphics = "The game will still work without the custom graphics, but some things will not look right.";
short i;
fs::path path(scen_file);
std::cout << "Loading scenario graphics... (" << path << ")\n";
// Tried path.replace_extension, but that only deleted the extension, so I have to do it manually
std::string filename = path.stem().string();
path = path.parent_path();
if(spec_scen_g) spec_scen_g.clear();
// TODO: Load new-style sheets
{
static sf::Image graphics_store;
bool foundGraphics = false;
#ifdef __APPLE__
fs::path gpath = path/(filename + ".meg");
if(fs::exists(gpath))
foundGraphics = tryLoadPictFromResourceFile(gpath, graphics_store);
#endif
if(!foundGraphics) {
fs::path gpath = path/(filename + ".bmp");
if(fs::exists(gpath)) {
if(graphics_store.loadFromFile(gpath.string()))
foundGraphics = true;
else giveError("An old-style .bmp graphics file was found, but there was an error reading from the file.",noGraphics);
}
}
if(foundGraphics) {
// If we're here, we found old-style graphics.
// This means they need an alpha channel
graphics_store.createMaskFromColor(sf::Color::White);
spec_scen_g.is_old = true;
spec_scen_g.sheets = new sf::Texture[1];
spec_scen_g.sheets[0].loadFromImage(graphics_store);
} else {
// Check for new-style graphics
}
}//else{}
// TODO: This should really reload ALL textures...
// Now load regular graphics
items_gworld.loadFromImage(*ResMgr::get<ImageRsrc>("objects"));
tiny_obj_gworld.loadFromImage(*ResMgr::get<ImageRsrc>("tinyobj"));
fields_gworld.loadFromImage(*ResMgr::get<ImageRsrc>("fields"));
roads_gworld.loadFromImage(*ResMgr::get<ImageRsrc>("trim"));
boom_gworld.loadFromImage(*ResMgr::get<ImageRsrc>("booms"));
missiles_gworld.loadFromImage(*ResMgr::get<ImageRsrc>("missiles"));
dlogpics_gworld.loadFromImage(*ResMgr::get<ImageRsrc>("dlogpics"));
status_gworld.loadFromImage(*ResMgr::get<ImageRsrc>("staticons"));
for(i = 0; i < NUM_MONST_SHEETS; i++){
std::ostringstream sout;
sout << "monst" << i + 1;
monst_gworld[i].loadFromImage(*ResMgr::get<ImageRsrc>(sout.str()));
}
for(i = 0; i < NUM_TER_SHEETS; i++){
std::ostringstream sout;
sout << "ter" << i + 1;
terrain_gworld[i].loadFromImage(*ResMgr::get<ImageRsrc>(sout.str()));
}
anim_gworld.loadFromImage(*ResMgr::get<ImageRsrc>("teranim"));
talkfaces_gworld.loadFromImage(*ResMgr::get<ImageRsrc>("talkportraits"));
pc_gworld.loadFromImage(*ResMgr::get<ImageRsrc>("pcs"));
vehicle_gworld.loadFromImage(*ResMgr::get<ImageRsrc>("vehicle"));
small_ter_gworld.loadFromImage(*ResMgr::get<ImageRsrc>("termap"));
// TODO: Scenario icons ...
}
Reference in New Issue View Git Blame Copy Permalink