Marc
/
server
forked from github/server
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

kil xmlreport files. 

remove unnecessary includes.
This commit is contained in:
Enno Rehling 2016-11-14 01:23:41 +01:00
parent 0472ac761e
commit 2b07ae810c
6 changed files with 0 additions and 830 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/kernel/connection.c
View File

@ -21,7 +21,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "connection.h"
#include "region.h"
#include "save.h"
#include "terrain.h"
#include "unit.h"

1
src/kernel/group.c
View File

@ -23,7 +23,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* kernel includes */
#include "ally.h"
#include "faction.h"
#include "save.h"
#include "unit.h"
/* attrib includes */

1
src/magic.c
View File

@ -38,7 +38,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/pool.h>
#include <kernel/race.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <kernel/ship.h>
#include <kernel/spell.h>
#include <kernel/spellbook.h>

1
src/modules/gmcmd.c
View File

@ -29,7 +29,6 @@
#include <kernel/order.h>
#include <kernel/plane.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <kernel/terrain.h>
#include <kernel/terrainid.h>
#include <kernel/unit.h>

800
src/xmlreport.c
View File

@ -1,800 +0,0 @@
/*
+-------------------+ Enno Rehling <enno@eressea.de>
| Eressea PBEM host | Christian Schlittchen <corwin@amber.kn-bremen.de>
| (c) 1998 - 2008 | Katja Zedel <katze@felidae.kn-bremen.de>
+-------------------+
This program may not be used, modified or distributed
without prior permission by the authors of Eressea.
*/
#include <platform.h>
#include <kernel/config.h>
#include "xmlreport.h"
#define XML_ATL_NAMESPACE (const xmlChar *) "http://www.eressea.de/XML/2008/atlantis"
#define XML_XML_LANG (const xmlChar *) "lang"
/* modules include */
#include <modules/score.h>
/* attributes include */
#include <attributes/follow.h>
#include <attributes/racename.h>
#include <attributes/orcification.h>
#include <attributes/otherfaction.h>
#include <attributes/raceprefix.h>
/* gamecode includes */
#include "laws.h"
#include "economy.h"
#include "move.h"
/* kernel includes */
#include <kernel/alchemy.h>
#include <kernel/alliance.h>
#include <kernel/ally.h>
#include <kernel/connection.h>
#include <kernel/curse.h>
#include <kernel/building.h>
#include <kernel/faction.h>
#include <kernel/group.h>
#include <kernel/item.h>
#include <kernel/magic.h>
#include <kernel/messages.h>
#include <kernel/order.h>
#include <kernel/plane.h>
#include <kernel/race.h>
#include <kernel/region.h>
#include <kernel/reports.h>
#include <kernel/resources.h>
#include <kernel/ship.h>
#include <kernel/skill.h>
#include <kernel/teleport.h>
#include <kernel/terrain.h>
#include <kernel/unit.h>
#include <kernel/save.h>
/* util includes */
#include <util/attrib.h>
#include <util/base36.h>
#include <util/goodies.h>
#include <util/language.h>
#include <util/message.h>
#include <quicklist.h>
#include <util/xml.h>
#ifdef USE_LIBXML2
/* libxml2 includes */
#include <libxml/tree.h>
#include <libxml/encoding.h>
#ifdef USE_ICONV
#include <iconv.h>
#endif
#endif
/* libc includes */
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#define L10N(x) x
typedef struct xml_context {
xmlDocPtr doc;
xmlNsPtr ns_atl;
xmlNsPtr ns_xml;
} xml_context;
static xmlNodePtr
xml_link(report_context * ctx, const xmlChar * rel, const xmlChar * ref)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr node = xmlNewNode(xct->ns_atl, BAD_CAST "link");
xmlNewNsProp(node, xct->ns_atl, BAD_CAST "rel", rel);
xmlNewNsProp(node, xct->ns_atl, BAD_CAST "ref", ref);
return node;
}
static const xmlChar *xml_ref_unit(const unit * u)
{
static char idbuf[20];
_snprintf(idbuf, sizeof(idbuf), "unit_%d", u->no);
return (const xmlChar *)idbuf;
}
static const xmlChar *xml_ref_faction(const faction * f)
{
static char idbuf[20];
_snprintf(idbuf, sizeof(idbuf), "fctn_%d", f->no);
return (const xmlChar *)idbuf;
}
static const xmlChar *xml_ref_group(const group * g)
{
static char idbuf[20];
_snprintf(idbuf, sizeof(idbuf), "grp_%d", g->gid);
return (const xmlChar *)idbuf;
}
static const xmlChar *xml_ref_prefix(const char *str)
{
static char idbuf[20];
_snprintf(idbuf, sizeof(idbuf), "pref_%s", str);
return (const xmlChar *)idbuf;
}
static const xmlChar *xml_ref_building(const building * b)
{
static char idbuf[20];
_snprintf(idbuf, sizeof(idbuf), "bldg_%d", b->no);
return (const xmlChar *)idbuf;
}
static const xmlChar *xml_ref_ship(const ship * sh)
{
static char idbuf[20];
_snprintf(idbuf, sizeof(idbuf), "shp_%d", sh->no);
return (const xmlChar *)idbuf;
}
static const xmlChar *xml_ref_region(const region * r)
{
static char idbuf[20];
_snprintf(idbuf, sizeof(idbuf), "rgn_%d", r->uid);
return (const xmlChar *)idbuf;
}
static xmlNodePtr xml_inventory(report_context * ctx, item * items, unit * u)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr node = xmlNewNode(xct->ns_atl, BAD_CAST "items");
item *itm;
for (itm = items; itm; itm = itm->next) {
xmlNodePtr child;
const char *name;
int n;
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "item"));
report_item(u, itm, ctx->f, NULL, &name, &n, true);
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", (xmlChar *) name);
xmlNodeAddContent(child, (xmlChar *) itoab(n, 10));
}
return node;
}
#ifdef TODO /*spellbooks */
static xmlNodePtr
xml_spells(report_context * ctx, quicklist * slist, int maxlevel)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr child, node = xmlNewNode(xct->ns_atl, BAD_CAST "spells");
quicklist *ql;
int qi;
for (ql = slist, qi = 0; ql; ql_advance(&ql, &qi, 1)) {
spell *sp = (spell *) ql_get(ql, qi);
if (sp->level <= maxlevel) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "spell"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "name", BAD_CAST sp->sname);
}
}
return node;
}
#endif
static xmlNodePtr xml_skills(report_context * ctx, unit * u)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr child, node = xmlNewNode(xct->ns_atl, BAD_CAST "skills");
skill *sv;
for (sv = u->skills; sv != u->skills + u->skill_size; ++sv) {
if (sv->level > 0) {
skill_t sk = sv->id;
int esk = eff_skill(u, sk, u->region);
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "skill", BAD_CAST itoab(esk,
10));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", BAD_CAST skillnames[sk]);
}
}
return node;
}
static xmlNodePtr xml_unit(report_context * ctx, unit * u, int mode)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr node = xmlNewNode(xct->ns_atl, BAD_CAST "unit");
static const curse_type *itemcloak_ct = 0;
static bool init = false;
xmlNodePtr child;
const char *str, *rcname, *rcillusion;
bool disclosure = (ctx->f == u->faction || omniscient(ctx->f));
/* TODO: hitpoints, aura, combatspells, curses */
xmlNewNsProp(node, xct->ns_xml, XML_XML_ID, xml_ref_unit(u));
xmlNewNsProp(node, xct->ns_atl, BAD_CAST "key", BAD_CAST itoa36(u->no));
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "name", (const xmlChar *)u->name);
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "number",
(const xmlChar *)itoab(u->number, 10));
/* optional description */
str = u_description(u, ctx->f->locale);
if (str) {
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "text", (const xmlChar *)str);
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "public");
if (str != u->display) {
xmlNewNsProp(child, xct->ns_atl, XML_XML_LANG,
BAD_CAST locale_name(ctx->f->locale));
}
}
/* possible <guard/> info */
if (is_guard(u, GUARD_ALL) != 0) {
xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "guard"));
}
/* siege */
if (fval(u, UFL_SIEGE)) {
building *b = usiege(u);
if (b) {
xmlAddChild(node, xml_link(ctx, BAD_CAST "siege", xml_ref_building(b)));
}
}
/* TODO: temp/alias */
/* race information */
report_race(u, &rcname, &rcillusion);
if (disclosure) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "race"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "true");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", (const xmlChar *)rcname);
if (rcillusion) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "race"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "stealth");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
(const xmlChar *)rcillusion);
}
} else {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "race"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
(const xmlChar *)(rcillusion ? rcillusion : rcname));
}
/* group and prefix information. we only write the prefix if we really must */
if (fval(u, UFL_GROUP)) {
attrib *a = a_find(u->attribs, &at_group);
if (a != NULL) {
const group *g = (const group *)a->data.v;
if (disclosure) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "group"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", xml_ref_group(g));
} else {
const char *prefix = get_prefix(g->attribs);
if (prefix) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "prefix"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
xml_ref_prefix(prefix));
}
}
}
}
if (disclosure) {
unit *mage;
str = uprivate(u);
if (str) {
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "text",
(const xmlChar *)str);
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "private");
}
/* familiar info */
mage = get_familiar_mage(u);
if (mage)
xmlAddChild(node, xml_link(ctx, BAD_CAST "familiar_of",
xml_ref_unit(mage)));
/* combat status */
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "status"));
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "combat");
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "value",
BAD_CAST combatstatus[u->status]);
if (fval(u, UFL_NOAID)) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "status"));
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "aid");
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "value", BAD_CAST "false");
}
if (fval(u, UFL_STEALTH)) {
int i = u_geteffstealth(u);
if (i >= 0) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "status"));
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "stealth");
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "value", BAD_CAST itoab(i,
10));
}
}
if (fval(u, UFL_HERO)) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "status"));
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "hero");
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "value", BAD_CAST "true");
}
if (fval(u, UFL_HUNGER)) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "status"));
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "hunger");
xmlSetNsProp(child, xct->ns_atl, BAD_CAST "value", BAD_CAST "true");
}
/* skills */
if (u->skill_size) {
xmlAddChild(node, xml_skills(ctx, u));
}
#ifdef TODO /*spellbooks */
/* spells */
if (is_mage(u)) {
sc_mage *mage = get_mage(u);
quicklist *slist = mage->spells;
if (slist) {
xmlAddChild(node, xml_spells(ctx, slist, effskill(u, SK_MAGIC)));
}
}
#endif
}
/* faction information w/ visibiility */
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "faction"));
if (disclosure) {
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "true");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
xml_ref_faction(u->faction));
if (fval(u, UFL_ANON_FACTION)) {
const faction *sf = visible_faction(NULL, u);
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "faction"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "stealth");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", xml_ref_faction(sf));
}
} else {
const faction *sf = visible_faction(ctx->f, u);
if (sf == ctx->f) {
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "stealth");
}
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", xml_ref_faction(sf));
}
/* the inventory */
if (u->items) {
item result[MAX_INVENTORY];
item *show = NULL;
if (!init) {
init = true;
itemcloak_ct = ct_find("itemcloak");
}
if (disclosure) {
show = u->items;
} else {
bool see_items = (mode >= see_unit);
if (see_items) {
if (itemcloak_ct && curse_active(get_curse(u->attribs, itemcloak_ct))) {
see_items = false;
} else {
see_items = effskill(u, SK_STEALTH) < 3;
}
}
if (see_items) {
int n = report_items(u->items, result, MAX_INVENTORY, u, ctx->f);
assert(n >= 0);
if (n > 0)
show = result;
else
show = NULL;
} else {
show = NULL;
}
}
if (show) {
xmlAddChild(node, xml_inventory(ctx, show, u));
}
}
return node;
}
static xmlNodePtr xml_resources(report_context * ctx, const seen_region * sr)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr node = NULL;
resource_report result[MAX_RAWMATERIALS];
int n, size = report_resources(sr, result, MAX_RAWMATERIALS, ctx->f);
if (size) {
node = xmlNewNode(xct->ns_atl, BAD_CAST "resources");
for (n = 0; n < size; ++n) {
if (result[n].number >= 0) {
xmlNodePtr child;
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "resource"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
(xmlChar *) result[n].name);
if (result[n].level >= 0) {
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "level",
(xmlChar *) itoab(result[n].level, 10));
}
xmlNodeAddContent(child, (xmlChar *) itoab(result[n].number, 10));
}
}
}
return node;
}
static xmlNodePtr xml_diplomacy(report_context * ctx, const struct ally *allies)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr child, node = xmlNewNode(xct->ns_atl, BAD_CAST "diplomacy");
const struct ally *sf;
for (sf = allies; sf; sf = sf->next) {
int i, status = sf->status;
for (i = 0; helpmodes[i].name; ++i) {
if (sf->faction && (status & helpmodes[i].status) == helpmodes[i].status) {
status -= helpmodes[i].status;
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "status"));
xmlNewNsProp(child, xct->ns_xml, BAD_CAST "faction",
xml_ref_faction(sf->faction));
xmlNewNsProp(child, xct->ns_xml, BAD_CAST "status",
(xmlChar *) helpmodes[i].name);
}
}
}
return node;
}
static xmlNodePtr xml_groups(report_context * ctx, const group * groups)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr child, node = xmlNewNode(xct->ns_atl, BAD_CAST "faction");
const group *g;
for (g = groups; g; g = g->next) {
const char *prefix = get_prefix(g->attribs);
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "group"));
xmlNewNsProp(child, xct->ns_xml, XML_XML_ID, xml_ref_group(g));
xmlNewTextChild(child, xct->ns_atl, BAD_CAST "name",
(const xmlChar *)g->name);
if (g->allies)
xmlAddChild(child, xml_diplomacy(ctx, g->allies));
if (prefix) {
child = xmlAddChild(child, xmlNewNode(xct->ns_atl, BAD_CAST "prefix"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", xml_ref_prefix(prefix));
}
}
return node;
}
static xmlNodePtr xml_faction(report_context * ctx, faction * f)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr child, node = xmlNewNode(xct->ns_atl, BAD_CAST "faction");
/* TODO: alliance, locale */
xmlNewNsProp(node, xct->ns_xml, XML_XML_ID, xml_ref_faction(f));
xmlNewNsProp(node, xct->ns_atl, BAD_CAST "key", BAD_CAST itoa36(f->no));
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "name", (const xmlChar *)f->name);
if (f->email)
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "email",
(const xmlChar *)f->email);
if (f->banner) {
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "text",
(const xmlChar *)f->banner);
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "public");
}
if (ctx->f == f) {
xmlAddChild(node, xml_link(ctx, BAD_CAST "race",
BAD_CAST f->race->_name[0]));
if (f->items)
xmlAddChild(node, xml_inventory(ctx, f->items, NULL));
if (f->allies)
xmlAddChild(node, xml_diplomacy(ctx, f->allies));
if (f->groups)
xmlAddChild(node, xml_groups(ctx, f->groups));
/* TODO: age, options, score, prefix, magic, immigrants, heroes, nmr, groups */
}
return node;
}
static xmlNodePtr
xml_building(report_context * ctx, seen_region * sr, const building * b,
const unit * owner)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr node = xmlNewNode(xct->ns_atl, BAD_CAST "building");
xmlNodePtr child;
const char *bname, *billusion;
xmlNewNsProp(node, xct->ns_xml, XML_XML_ID, xml_ref_building(b));
xmlNewNsProp(node, xct->ns_atl, BAD_CAST "key", BAD_CAST itoa36(b->no));
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "name", (const xmlChar *)b->name);
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "size",
(const xmlChar *)itoab(b->size, 10));
if (b->display && b->display[0]) {
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "text",
(const xmlChar *)b->display);
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "public");
}
if (b->besieged) {
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "siege",
(const xmlChar *)itoab(b->besieged, 10));
}
if (owner)
xmlAddChild(node, xml_link(ctx, BAD_CAST "owner", xml_ref_unit(owner)));
report_building(b, &bname, &billusion);
if (owner && owner->faction == ctx->f) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "type"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "true");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", (const xmlChar *)bname);
if (billusion) {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "type"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "illusion");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
(const xmlChar *)billusion);
}
} else {
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "type"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
(const xmlChar *)(billusion ? billusion : bname));
}
return node;
}
static xmlNodePtr
xml_ship(report_context * ctx, const seen_region * sr, const ship * sh,
const unit * owner)
{
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr child, node = xmlNewNode(xct->ns_atl, BAD_CAST "ship");
xmlNewNsProp(node, xct->ns_xml, XML_XML_ID, xml_ref_ship(sh));
xmlNewNsProp(node, xct->ns_atl, BAD_CAST "key", BAD_CAST itoa36(sh->no));
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "name",
(const xmlChar *)sh->name);
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "size",
(const xmlChar *)itoab(sh->size, 10));
if (sh->damage) {
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "damage",
(const xmlChar *)itoab(sh->damage, 10));
}
if (fval(sr->r->terrain, SEA_REGION) && sh->coast != NODIRECTION) {
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "coast",
BAD_CAST directions[sh->coast]);
}
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "type"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
(const xmlChar *)sh->type->name[0]);
if (sh->display && sh->display[0]) {
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "text",
(const xmlChar *)sh->display);
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "public");
}
if (owner)
xmlAddChild(node, xml_link(ctx, BAD_CAST "owner", xml_ref_unit(owner)));
if ((owner && owner->faction == ctx->f) || omniscient(ctx->f)) {
int n = 0, p = 0;
getshipweight(sh, &n, &p);
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "cargo",
(const xmlChar *)itoab(n, 10));
}
return node;
}
static xmlNodePtr xml_region(report_context * ctx, seen_region * sr)
{
xml_context *xct = (xml_context *) ctx->userdata;
const region *r = sr->r;
xmlNodePtr node = xmlNewNode(xct->ns_atl, BAD_CAST "region");
xmlNodePtr child;
int stealthmod = stealth_modifier(sr->mode);
unit *u;
ship *sh = r->ships;
building *b = r->buildings;
plane *pl = rplane(r);
int nx = r->x, ny = r->y;
pnormalize(&nx, &ny, pl);
adjust_coordinates(ctx->f, &nx, &ny, pl, r);
/* TODO: entertain-quota, recruits, salary, prices, curses, borders, apparitions (Schemen), spells, travelthru, messages */
xmlNewNsProp(node, xct->ns_xml, XML_XML_ID, xml_ref_region(r));
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "coordinate"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "x", xml_i(nx));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "y", xml_i(ny));
if (pl && pl->name) {
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "plane", (xmlChar *) pl->name);
}
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "terrain"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref", (xmlChar *) terrain_name(r));
if (r->land != NULL) {
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "name",
(const xmlChar *)r->land->name);
if (r->land->items) {
xmlAddChild(node, xml_inventory(ctx, r->land->items, NULL));
}
}
if (r->display && r->display[0]) {
child =
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "text",
(const xmlChar *)r->display);
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "rel", BAD_CAST "public");
}
child = xml_resources(ctx, sr);
if (child)
xmlAddChild(node, child);
child = xmlNewNode(xct->ns_atl, BAD_CAST "terrain");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "ref",
(const xmlChar *)terrain_name(r));
if (sr->mode > see_neighbour) {
/* report all units. they are pre-sorted in an efficient manner */
u = r->units;
while (b) {
while (b && (!u || u->building != b)) {
xmlAddChild(node, xml_building(ctx, sr, b, NULL));
b = b->next;
}
if (b) {
child = xmlAddChild(node, xml_building(ctx, sr, b, u));
while (u && u->building == b) {
xmlAddChild(child, xml_unit(ctx, u, sr->mode));
u = u->next;
}
b = b->next;
}
}
while (u && !u->ship) {
if (stealthmod > INT_MIN) {
if (u->faction == ctx->f || cansee(ctx->f, r, u, stealthmod)) {
xmlAddChild(node, xml_unit(ctx, u, sr->mode));
}
}
u = u->next;
}
while (sh) {
while (sh && (!u || u->ship != sh)) {
xmlAddChild(node, xml_ship(ctx, sr, sh, NULL));
sh = sh->next;
}
if (sh) {
child = xmlAddChild(node, xml_ship(ctx, sr, sh, u));
while (u && u->ship == sh) {
xmlAddChild(child, xml_unit(ctx, u, sr->mode));
u = u->next;
}
sh = sh->next;
}
}
}
return node;
}
static xmlNodePtr report_root(report_context * ctx)
{
int qi;
quicklist *address;
region *r = ctx->first, *rend = ctx->last;
xml_context *xct = (xml_context *) ctx->userdata;
xmlNodePtr node, child, xmlReport = xmlNewNode(NULL, BAD_CAST "atlantis");
const char *mailto = locale_string(ctx->f->locale, "mailto");
const char *mailcmd = locale_string(ctx->f->locale, "mailcmd");
char zText[128];
/* TODO: locale, age, options, messages */
xct->ns_xml = xmlNewNs(xmlReport, XML_XML_NAMESPACE, BAD_CAST "xml");
xct->ns_atl = xmlNewNs(xmlReport, XML_ATL_NAMESPACE, NULL);
xmlSetNs(xmlReport, xct->ns_atl);
node = xmlAddChild(xmlReport, xmlNewNode(xct->ns_atl, BAD_CAST "server"));
if (mailto) {
_snprintf(zText, sizeof(zText), "mailto:%s?subject=%s", mailto, mailcmd);
child = xmlAddChild(node, xmlNewNode(xct->ns_atl, BAD_CAST "delivery"));
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "method", BAD_CAST "mail");
xmlNewNsProp(child, xct->ns_atl, BAD_CAST "href", BAD_CAST zText);
}
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "game",
(xmlChar *) global.gamename);
strftime(zText, sizeof(zText), "%Y-%m-%dT%H:%M:%SZ",
gmtime(&ctx->report_time));
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "time", (xmlChar *) zText);
xmlNewTextChild(node, xct->ns_atl, BAD_CAST "turn", (xmlChar *) itoab(turn,
10));
for (qi = 0, address = ctx->addresses; address; ql_advance(&address, &qi, 1)) {
faction *f = (faction *) ql_get(address, qi);
xmlAddChild(xmlReport, xml_faction(ctx, f));
}
for (; r != rend; r = r->next) {
seen_region *sr = find_seen(ctx->seen, r);
if (sr != NULL)
xmlAddChild(xmlReport, xml_region(ctx, sr));
}
return xmlReport;
}
/* main function of the xmlreport. creates the header and traverses all regions */
static int
report_xml(const char *filename, report_context * ctx, const char *encoding)
{
xml_context xct;
xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
xct.doc = doc;
assert(ctx->userdata == NULL);
ctx->userdata = &xct;
xmlDocSetRootElement(doc, report_root(ctx));
xmlKeepBlanksDefault(0);
xmlSaveFormatFileEnc(filename, doc, "utf-8", 1);
xmlFreeDoc(doc);
ctx->userdata = NULL;
return 0;
}
void register_xr(void)
{
register_reporttype("xml", &report_xml, 1 << O_XML);
#ifdef USE_ICONV
utf8 = iconv_open("UTF-8", "");
#endif
}
void xmlreport_cleanup(void)
{
#ifdef USE_ICONV
iconv_close(utf8);
#endif
}

26
src/xmlreport.h
View File

@ -1,26 +0,0 @@
/*
+-------------------+ Christian Schlittchen <corwin@amber.kn-bremen.de>
| Eressea PBEM host | Katja Zedel <katze@felidae.kn-bremen.de>
| (c) 1998 - 2005 | Enno Rehling <enno@eressea.de>
+-------------------+
This program may not be used, modified or distributed
without prior permission by the authors of Eressea.
*/
#ifndef H_GC_XMLREPORT
#define H_GC_XMLREPORT
#ifdef __cplusplus
extern "C" {
#endif
#include <time.h>
extern void xmlreport_cleanup(void);
extern void register_xr(void);
extern int crwritemap(const char *filename);
#ifdef __cplusplus
}
#endif
#endif