void
ResourceManager::parse(const std::string& section, FileReader& reader)
{
if (reader.get_name() == "section")
{
parse_section(section, reader);
}
else if (reader.get_name() == "sprite")
{
std::string name;
reader.read_string("name", name);
if (!section.empty())
name = section + "/" + name;
if (resources[name])
delete resources[name];
resources[name] = new SpriteDescription(reader);
}
else if (reader.get_name() == "alias")
{
std::string name;
std::string link;
reader.read_string("name", name);
reader.read_string("link", link);
//std::cout << "alias: " << name << " -> " << link << std::endl;
}
else if (reader.get_name() == "name")
{
// ignore (ugly)
}
else
{
std::cout << "ResourceManager: unknown token: '" << reader.get_name() << "'" << std::endl;
}
}
void
SectorBuilder::parse_object(const FileReader& reader)
{
GameObjectHandle obj;
if(reader.get_name() == "tilemap")
{
std::auto_ptr<TileMap> tilemap(new TileMap(reader));
if (tilemap->get_name() == "interactive")
m_sector.interactive_tilemap = tilemap.get();
else if (tilemap->get_name() == "interactivebackground")
m_sector.interactivebackground_tilemap = tilemap.get();
obj.reset(tilemap.release());
}
else if (reader.get_name() == "navgraph-edge-ref")
{
// FIXME: Implement me
}
else if(reader.get_name() == "background")
{
// TODO
}
else if(reader.get_name() == "layer")
{
parse_layer(reader);
}
else
{
obj = ObjectFactory::create(reader);
if (!obj)
{
std::cout << "Skipping unknown Object: " << reader.get_name() << "\n";
}
}
if (obj)
{
std::string id_str;
if (reader.read("id", id_str))
{
id_table[id_str] = obj;
}
std::string parent_str;
if (reader.read("parent", parent_str))
{
if (!parent_str.empty())
parent_table[obj] = parent_str;
}
m_sector.add(obj);
}
}
TileFactory::TileFactory(const Pathname& filename) :
tiles(),
packers(),
color_packer(),
descriptions()
{
packers.push_back(new TilePacker(1024, 1024));
packers.push_back(new TilePacker(1024, 1024));
color_packer = 0;
FileReader reader = FileReader::parse(filename);
if(reader.get_name() != "windstille-tiles")
{
std::ostringstream msg;
msg << "'" << filename << "' is not a windstille tiles file";
throw std::runtime_error(msg.str());
}
std::vector<FileReader> sections = reader.get_sections();
for(std::vector<FileReader>::iterator i = sections.begin(); i != sections.end(); ++i)
{
if (i->get_name() == "tiles") {
parse_tiles(*i);
} else if (i->get_name() == "tilegroup") {
// ignore
}
}
}
ServerEvent::ServerEvent(const FileReader& reader) :
type(PINGU_ACTION_EVENT),
time_stamp(0),
pingu_id(0),
pos(),
pingu_action(ActionName::WALKER)
{
if (reader.get_name() == "armageddon")
{
type = ARMAGEDDON_EVENT;
reader.read_int("time", time_stamp);
}
else if (reader.get_name() == "end")
{
type = END_EVENT;
reader.read_int("time", time_stamp);
}
else if (reader.get_name() == "finish")
{
type = FINISH_EVENT;
reader.read_int("time", time_stamp);
}
else if (reader.get_name() == "pingu-action")
{
std::string raw_x;
std::string raw_y;
type = PINGU_ACTION_EVENT;
reader.read_int ("time", time_stamp);
reader.read_int ("id", pingu_id);
if (reader.read_string("raw-x", raw_x))
pos.x = Math::string2float(raw_x);
if (reader.read_string("raw-y", raw_y))
pos.y = Math::string2float(raw_y);
reader.read_enum("action", pingu_action, &ActionName::from_string);
}
else
{
throw std::runtime_error(std::string("ServerEvent: Parse error: Unknown event: ")
+ reader.get_name());
}
}
void
WorldObjRenderer::process_object_with_surface(const FileReader& reader)
{
Vector3f pos;
ResDescriptor desc;
if (!(reader.read_vector("position", pos) &&
reader.read_desc("surface", desc)))
{
log_error("object (%1%) does not have 'position' and 'surface'", reader.get_name());
}
else
{
if (reader.get_name() == "exit" ||
reader.get_name() == "hotspots")
{
render_sprite(desc, pos);
}
else if (reader.get_name() == "groundpiece")
{
std::string type;
reader.read_string("type", type);
if (type == "remove")
{
// FIXME: don't have blit_remove()
render_surface(desc, pos);
}
else
{
render_surface(desc, pos);
}
}
else
{
int repeat = 1;
reader.read_int("repeat", repeat);
render_surface(desc, pos, repeat);
}
}
}
Options
Options::from_file(const Pathname& filename)
{
FileReader reader = FileReader::parse(filename);
if (reader.get_name() != "pingus-config")
{
raise_exception(std::runtime_error, "Error: " << filename << ": not a (pingus-config) file");
}
return from_file_reader(reader);
}
FontDescription::FontDescription(const Pathname& pathname_) :
pathname(pathname_),
char_spacing(),
vertical_spacing(),
size(),
images()
{
char_spacing = 1.0f;
vertical_spacing = 1.0f;
FileReader reader = FileReader::parse(pathname);
if (reader.get_name() != "pingus-font")
{
raise_exception(std::runtime_error, "FontDescription: not a pingus-font file");
}
else
{
reader.read_float("char-spacing", char_spacing);
reader.read_float("vertical-spacing", vertical_spacing);
reader.read_int("size", size);
FileReader images_reader;
if (reader.read_section("images", images_reader))
{
std::vector<FileReader> images_lst = images_reader.get_sections();
for(std::vector<FileReader>::iterator i = images_lst.begin(); i != images_lst.end(); ++i)
{
GlyphImageDescription image_desc;
i->read_path("filename", image_desc.pathname);
FileReader glyph_section;
if (i->read_section("glyphs", glyph_section))
{
std::vector<FileReader> glyph_reader = glyph_section.get_sections();
for(std::vector<FileReader>::iterator j = glyph_reader.begin(); j != glyph_reader.end(); ++j)
{
image_desc.glyphs.push_back(GlyphDescription(*j));
}
}
images.push_back(image_desc);
}
}
}
}
SectorBuilder::SectorBuilder(const Pathname& filename, Sector& sector) :
m_filename(filename),
m_sector(sector),
id_table(),
parent_table()
{
FileReader reader = FileReader::parse(m_filename);
if(reader.get_name() != "windstille-sector")
{
std::ostringstream msg;
msg << "'" << m_filename << "' is not a windstille-sector file";
throw std::runtime_error(msg.str());
}
else
{
parse_body(reader);
}
}
Levelset::Levelset(const Pathname& pathname)
: completion(0)
{
FileReader reader = FileReader::parse(pathname);
if (reader.get_name() != "pingus-levelset")
{
PingusError::raise("Error: " + pathname.str() + ": not a 'pingus-levelset' file");
}
else
{
reader.read_string("title", title);
reader.read_string("description", description);
std::string image;
if (reader.read_string("image", image))
this->image = Resource::load_sprite(image);
FileReader level_reader = reader.read_section("levels");
std::vector<FileReader> sections = level_reader.get_sections();
for(std::vector<FileReader>::iterator i = sections.begin(); i != sections.end(); ++i)
{
if (i->get_name() == "level")
{
Level* level = new Level();
if (i->read_string("filename", level->resname))
{
level->plf = PLFResMgr::load_plf(level->resname);
level->accessible = false;
level->finished = false;
levels.push_back(level);
}
else
{
std::cout << "Levelset: " << pathname.str() << " is missing filename tag" << std::endl;
delete level;
}
}
}
}
refresh();
}
std::string get_name() const
{
return m_reader.get_name();
}
void
WorldObjRenderer::process(const FileReader& reader)
{
// FIXME: does not handle sprite alignment
// FIXME: does not handle remove groundpieces
// FIXME: does not handle liquid
if (reader.get_name() == "surface-background" ||
reader.get_name() == "starfield-background" ||
reader.get_name() == "solidcolor-background" ||
reader.get_name() == "snow-generator" ||
reader.get_name() == "rain-generator")
{
// ignore
}
else if (reader.get_name() == "groundpiece" ||
reader.get_name() == "liquid" ||
reader.get_name() == "exit" ||
reader.get_name() == "hotspot")
{
process_object_with_surface(reader);
}
else if (reader.get_name() == "entrance")
{
Vector3f pos;
reader.read_vector("position", pos);
render_sprite(ResDescriptor("entrances/generic"), pos);
}
else if (reader.get_name() == "spike")
{
Vector3f pos;
reader.read_vector("position", pos);
render_surface(ResDescriptor("traps/spike_editor"), pos);
}
else if (reader.get_name() == "switchdoor-switch")
{
Vector3f pos;
reader.read_vector("position", pos);
render_surface(ResDescriptor("worldobjs/switchdoor_switch"), pos);
}
else if (reader.get_name() == "switchdoor-door")
{
Vector3f pos;
reader.read_vector("position", pos);
render_surface(ResDescriptor("worldobjs/switchdoor_box"), pos);
}
else if (reader.get_name() == "group")
{
FileReader objects = reader.read_section("objects");
process(objects.get_sections());
}
else if (reader.get_name() == "prefab")
{
std::string name;
if (!reader.read_string("name", name))
{
log_error("'name' tag missing for prefab");
}
else
{
PrefabFile prefab = PrefabFile::from_resource(name);
Vector3f position;
reader.read_vector("position", position);
push_translate(static_cast<int>(position.x),
static_cast<int>(position.y));
process(prefab.get_objects());
pop_translate();
}
}
else
{
log_error("unknown object type: %1%", reader.get_name());
}
}
SpriteData::SpriteData(const Pathname& pathname) :
actions()
{
if (pathname.exists())
{
const std::string ext = pathname.get_extension();
if (ext == "sprite")
{
FileReader reader = FileReader::parse(pathname);
if(reader.get_name() != "sprite") {
std::ostringstream msg;
msg << "File " << pathname << " is not a windstille sprite";
throw std::runtime_error(msg.str());
}
parse(pathname.get_dirname(), reader);
}
else if (ext == "png" || ext == "jpg")
{
std::auto_ptr<SpriteAction> action(new SpriteAction());
action->name = "default";
action->speed = 1.0;
action->scale = 1.0f;
action->offset = Vector2f(0, 0);
action->surfaces.push_back(Surface::create(pathname));
actions.push_back(action.release());
}
else
{
std::ostringstream str;
str << "Sprite " << pathname << " has unknown suffix: '" << ext << "'";
throw std::runtime_error(str.str());
}
}
else if (pathname.get_raw_path().length() > std::string(".sprite").length())
{ // If sprite file is not found, we search for a file with the
// same name ending in .png
Pathname pngfile(pathname.get_raw_path().substr(0, pathname.get_raw_path().length() - std::string(".sprite").length()) + ".png",
pathname.get_type());
if (pngfile.exists())
{
std::auto_ptr<SpriteAction> action(new SpriteAction);
action->name = "default";
action->speed = 1.0;
action->scale = 1.0f;
action->offset = Vector2f(0, 0);
action->surfaces.push_back(Surface::create(pngfile));
actions.push_back(action.release());
}
else
{
std::ostringstream str;
str << "Couldn't find " << pngfile;
throw std::runtime_error(str.str());
}
}
else
{
std::ostringstream str;
str << "Couldn't find " << pathname;
throw std::runtime_error(str.str());
}
}
Controller*
Manager::create_controller(const Pathname& filename)
{
std::unique_ptr<Controller> controller(new Controller(desc));
FileReader reader = FileReader::parse(filename);
if (reader.get_name() != "pingus-controller")
{
throw std::runtime_error("Controller: invalid config file '" + filename.str() + "'");
}
else
{
const std::vector<FileReader>& sections = reader.get_sections();
for (std::vector<FileReader>::const_iterator i = sections.begin();
i != sections.end(); ++i)
{
if (StringUtil::has_suffix(i->get_name(), "pointer"))
{
const std::vector<FileReader>& pointers = i->get_sections();
for(std::vector<FileReader>::const_iterator j = pointers.begin(); j != pointers.end(); ++j)
{
int id = desc.get_definition(i->get_name()).id;
ControllerPointer* ctrl_pointer = controller->get_pointer(id);
Pointer* pointer = create_pointer(*j, ctrl_pointer);
if (pointer)
ctrl_pointer->add_pointer(pointer);
else
std::cout << "Manager: pointer: Couldn't create pointer " << j->get_name() << std::endl;
}
}
else if (StringUtil::has_suffix(i->get_name(), "scroller"))
{
const std::vector<FileReader>& scrollers = i->get_sections();
for(std::vector<FileReader>::const_iterator j = scrollers.begin(); j != scrollers.end(); ++j)
{
int id = desc.get_definition(i->get_name()).id;
ControllerScroller* ctrl_scroller = controller->get_scroller(id);
Scroller* scroller = create_scroller(*j, ctrl_scroller);
if (scroller)
ctrl_scroller->add_scroller(scroller);
else
std::cout << "Manager: scroller: Couldn't create scroller " << j->get_name() << std::endl;
}
}
else if (StringUtil::has_suffix(i->get_name(), "button"))
{
const std::vector<FileReader>& buttons = i->get_sections();
for(std::vector<FileReader>::const_iterator j = buttons.begin(); j != buttons.end(); ++j)
{
int id = desc.get_definition(i->get_name()).id;
ControllerButton* ctrl_button = controller->get_button(id);
Button* button = create_button(*j, ctrl_button);
if (button)
ctrl_button->add_button(button);
else
std::cout << "Manager: button: Couldn't create button " << j->get_name() << std::endl;
}
}
else if (StringUtil::has_suffix(i->get_name(), "axis"))
{
const std::vector<FileReader>& axes = i->get_sections();
for(std::vector<FileReader>::const_iterator j = axes.begin(); j != axes.end(); ++j)
{
int id = desc.get_definition(i->get_name()).id;
ControllerAxis* ctrl_axis = controller->get_axis(id);
Axis* axis = create_axis(*j, ctrl_axis);
if (axis)
ctrl_axis->add_axis(axis);
else
std::cout << "Manager: axis: Couldn't create axis " << j->get_name() << std::endl;
}
}
else if (StringUtil::has_suffix(i->get_name(), "keyboard"))
{
const std::vector<FileReader>& keyboards = i->get_sections();
for(std::vector<FileReader>::const_iterator j = keyboards.begin(); j != keyboards.end(); ++j)
{
int id = desc.get_definition(i->get_name()).id;
ControllerKeyboard* ctrl_keyboard = controller->get_keyboard(id);
Keyboard* keyboard = create_keyboard(*j, ctrl_keyboard);
if (keyboard)
ctrl_keyboard->add_keyboard(keyboard);
else
std::cout << "Manager: keyboard: Couldn't create keyboard " << j->get_name() << std::endl;
}
}
else
{
throw std::runtime_error(std::string("Manager: Unkown Element in Controller Config: ")
+ i->get_name());
}
}
}
Controller* ctrl = controller.release();
controllers.push_back(ctrl);
return ctrl;
}
void
PingusLevel::load(const std::string& resname,
const Pathname& pathname)
{
impl->resname = resname;
FileReader reader = FileReader::parse(pathname);
if (reader.get_name() != "pingus-level")
{
PingusError::raise("Error: " + pathname.str() + ": not a 'pingus-level' file");
}
else
{
int version;
if (reader.read_int("version", version))
pout(PINGUS_DEBUG_LOADING) << "Levelfile Version: " << version << std::endl;
else
pout(PINGUS_DEBUG_LOADING) << "Unknown Levelfile Version: " << version << std::endl;
FileReader head;
if (!reader.read_section("head", head))
{
PingusError::raise("Error: (head) section not found in '" + pathname.str() + "'");
}
else
{
pout(PINGUS_DEBUG_LOADING) << "Reading head" << std::endl;
head.read_string("levelname", impl->levelname);
head.read_string("description", impl->description);
head.read_size ("levelsize", impl->size);
head.read_string("music", impl->music);
head.read_int ("time", impl->time);
head.read_int ("difficulty", impl->difficulty);
head.read_int ("number-of-pingus", impl->number_of_pingus);
head.read_int ("number-to-save", impl->number_to_save);
head.read_color ("ambient-light", impl->ambient_light);
head.read_string("author", impl->author);
pout(PINGUS_DEBUG_LOADING) << "Size: " << impl->size.width << " " << impl->size.height << std::endl;
FileReader actions;
if (head.read_section("actions", actions))
{
std::vector<std::string> lst = actions.get_section_names();
for(std::vector<std::string>::iterator i = lst.begin(); i != lst.end(); ++i)
{
int count = 0;
pout(PINGUS_DEBUG_LOADING) << "Actions: " << i->c_str() << std::endl;
if (actions.read_int(i->c_str(), count))
impl->actions[*i] = count;
}
}
else
{
PingusError::raise("Error: (pingus-level head actions) not found in '" + pathname.str() + "'");
}
}
FileReader objects;
if (reader.read_section("objects", objects))
{
std::vector<FileReader> object_lst = objects.get_sections();
for(std::vector<FileReader>::iterator i = object_lst.begin(); i != object_lst.end(); ++i)
{
impl->objects.push_back(*i);
}
}
}
}
