forked from github/server
1252 lines
30 KiB
C
1252 lines
30 KiB
C
/* vi: set ts=2:
|
|
*
|
|
* Eressea PB(E)M host Copyright (C) 1998-2003
|
|
* Christian Schlittchen (corwin@amber.kn-bremen.de)
|
|
* Katja Zedel (katze@felidae.kn-bremen.de)
|
|
* Henning Peters (faroul@beyond.kn-bremen.de)
|
|
* Enno Rehling (enno@eressea-pbem.de)
|
|
* Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de)
|
|
*
|
|
* based on:
|
|
*
|
|
* Atlantis v1.0 13 September 1993 Copyright 1993 by Russell Wallace
|
|
* Atlantis v1.7 Copyright 1996 by Alex Schröder
|
|
*
|
|
* This program may not be used, modified or distributed without
|
|
* prior permission by the authors of Eressea.
|
|
* This program may not be sold or used commercially without prior written
|
|
* permission from the authors.
|
|
*/
|
|
#include <config.h>
|
|
#include "eressea.h"
|
|
#include "reports.h"
|
|
|
|
/* kernel includes */
|
|
#include "building.h"
|
|
#include "faction.h"
|
|
#include "group.h"
|
|
#include "item.h"
|
|
#include "karma.h"
|
|
#include "magic.h"
|
|
#include "message.h"
|
|
#include "order.h"
|
|
#include "plane.h"
|
|
#include "race.h"
|
|
#include "region.h"
|
|
#include "ship.h"
|
|
#include "skill.h"
|
|
#include "unit.h"
|
|
#ifdef USE_UGROUPS
|
|
# include "ugroup.h"
|
|
# include <attributes/ugroup.h>
|
|
#endif
|
|
|
|
/* util includes */
|
|
#include <util/bsdstring.h>
|
|
#include <util/base36.h>
|
|
#include <util/goodies.h>
|
|
|
|
/* libc includes */
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
/* attributes includes */
|
|
#include <attributes/follow.h>
|
|
#include <attributes/otherfaction.h>
|
|
#include <attributes/racename.h>
|
|
|
|
const char * g_reportdir;
|
|
|
|
const char *coasts[MAXDIRECTIONS] =
|
|
{
|
|
"coast::nw",
|
|
"coast::ne",
|
|
"coast::e",
|
|
"coast::se",
|
|
"coast::sw",
|
|
"coast::w"
|
|
};
|
|
|
|
const char *
|
|
reportpath(void)
|
|
{
|
|
static char zText[MAX_PATH];
|
|
if (g_reportdir) return g_reportdir;
|
|
return strcat(strcpy(zText, basepath()), "/reports");
|
|
}
|
|
|
|
static char *
|
|
groupid(const struct group * g, const struct faction * f)
|
|
{
|
|
typedef char name[OBJECTIDSIZE + 1];
|
|
static name idbuf[8];
|
|
static int nextbuf = 0;
|
|
char *buf = idbuf[(++nextbuf) % 8];
|
|
sprintf(buf, "%s (%s)", g->name, factionid(f));
|
|
return buf;
|
|
}
|
|
|
|
static const char *
|
|
report_kampfstatus(const unit * u, const struct locale * lang)
|
|
{
|
|
static char fsbuf[64];
|
|
static const char * azstatus[] = {
|
|
"status_aggressive", "status_front",
|
|
"status_rear", "status_defensive",
|
|
"status_avoid", "status_flee" };
|
|
|
|
strcpy(fsbuf, LOC(lang, azstatus[u->status]));
|
|
if (fval(u, UFL_NOAID)) {
|
|
strcat(fsbuf, ", ");
|
|
strcat(fsbuf, LOC(lang, "status_noaid"));
|
|
}
|
|
|
|
return fsbuf;
|
|
}
|
|
|
|
const char *
|
|
hp_status(const unit * u)
|
|
{
|
|
double p = (double) ((double) u->hp / (double) (u->number * unit_max_hp(u)));
|
|
|
|
if (p > 2.00) return mkname("damage", "critical");
|
|
if (p > 1.50) return mkname("damage", "heavily");
|
|
if (p < 0.50) return mkname("damage", "badly");
|
|
if (p < 0.75) return mkname("damage", "wounded");
|
|
if (p < 0.99) return mkname("damage", "exhausted");
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
report_item(const unit * owner, const item * i, const faction * viewer, const char ** name, const char ** basename, int * number, boolean singular)
|
|
{
|
|
if (owner->faction == viewer) {
|
|
if (name) *name = locale_string(viewer->locale, resourcename(i->type->rtype, ((i->number!=1 && !singular)?GR_PLURAL:0)));
|
|
if (basename) *basename = resourcename(i->type->rtype, 0);
|
|
if (number) *number = i->number;
|
|
} else if (i->type->rtype==r_silver) {
|
|
int pp = i->number/owner->number;
|
|
if (number) *number = 1;
|
|
if (pp > 50000 && dragonrace(owner->race)) {
|
|
if (name) *name = locale_string(viewer->locale, "dragonhoard");
|
|
if (basename) *basename = "dragonhoard";
|
|
} else if (pp > 5000) {
|
|
if (name) *name = locale_string(viewer->locale, "moneychest");
|
|
if (basename) *basename = "moneychest";
|
|
} else if (pp > 500) {
|
|
if (name) *name = locale_string(viewer->locale, "moneybag");
|
|
if (basename) *basename = "moneybag";
|
|
} else {
|
|
if (number) *number = 0;
|
|
if (name) *name = NULL;
|
|
if (basename) *basename = NULL;
|
|
}
|
|
} else {
|
|
if (name) *name = locale_string(viewer->locale, resourcename(i->type->rtype, NMF_APPEARANCE|((i->number!=1 && !singular)?GR_PLURAL:0)));
|
|
if (basename) *basename = resourcename(i->type->rtype, NMF_APPEARANCE);
|
|
if (number) {
|
|
if (fval(i->type, ITF_HERB)) *number = 1;
|
|
else *number = i->number;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#define ORDERS_IN_NR 1
|
|
static size_t
|
|
buforder(char * bufp, size_t size, const order * ord, int mode)
|
|
{
|
|
size_t tsize = 0, rsize;
|
|
|
|
rsize = strlcpy(bufp, ", \"", size);
|
|
tsize += rsize;
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
if (mode<ORDERS_IN_NR) {
|
|
char * cmd = getcommand(ord);
|
|
rsize = strlcpy(bufp, cmd, size);
|
|
free(cmd);
|
|
} else {
|
|
rsize = strlcpy(bufp, "...", size);
|
|
}
|
|
tsize += rsize;
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
|
|
if (size>1) {
|
|
strcpy(bufp, "\"");
|
|
++tsize;
|
|
}
|
|
return tsize;
|
|
}
|
|
|
|
int
|
|
bufunit(const faction * f, const unit * u, int indent, int mode)
|
|
{
|
|
int i, dh;
|
|
skill_t sk;
|
|
int getarnt = fval(u, UFL_PARTEITARNUNG);
|
|
const char *pzTmp;
|
|
building * b;
|
|
boolean isbattle = (boolean)(mode == see_battle);
|
|
int telepath_see = fspecial(f, FS_TELEPATHY);
|
|
attrib *a_fshidden = NULL;
|
|
item * itm;
|
|
item * show;
|
|
faction *fv = visible_faction(f, u);
|
|
char * bufp = buf;
|
|
boolean itemcloak = false;
|
|
static const curse_type * itemcloak_ct = 0;
|
|
static boolean init = false;
|
|
size_t size = sizeof(buf), rsize;
|
|
|
|
if (!init) {
|
|
init = true;
|
|
itemcloak_ct = ct_find("itemcloak");
|
|
}
|
|
if (itemcloak_ct!=NULL) {
|
|
itemcloak = curse_active(get_curse(u->attribs, itemcloak_ct));
|
|
}
|
|
|
|
if (fspecial(u->faction, FS_HIDDEN))
|
|
a_fshidden = a_find(u->attribs, &at_fshidden);
|
|
|
|
rsize = strlcpy(bufp, unitname(u), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
|
|
if (!isbattle) {
|
|
attrib *a_otherfaction = a_find(u->attribs, &at_otherfaction);
|
|
if (u->faction == f) {
|
|
if (fval(u, UFL_GROUP)) {
|
|
attrib *a = a_find(u->attribs, &at_group);
|
|
if (a) {
|
|
group * g = (group*)a->data.v;
|
|
rsize = strlcpy(bufp, ", ", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
rsize = strlcpy(bufp, groupid(g, f), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
}
|
|
if (getarnt) {
|
|
rsize = strlcpy(bufp, ", ", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
rsize = strlcpy(bufp, LOC(f->locale, "anonymous"), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
} else if (a_otherfaction) {
|
|
faction * otherfaction = get_otherfaction(a_otherfaction);
|
|
if (otherfaction) {
|
|
rsize = strlcpy(bufp, ", ", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
rsize = strlcpy(bufp, factionname(otherfaction), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
}
|
|
} else {
|
|
if (getarnt) {
|
|
rsize = strlcpy(bufp, ", ", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
rsize = strlcpy(bufp, LOC(f->locale, "anonymous"), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
} else {
|
|
if (a_otherfaction && alliedunit(u, f, HELP_FSTEALTH)) {
|
|
faction * f = get_otherfaction(a_otherfaction);
|
|
bufp += snprintf(bufp, size, ", %s (%s)", factionname(f), factionname(u->faction));
|
|
size = sizeof(buf)-(bufp-buf);
|
|
} else {
|
|
rsize = strlcpy(bufp, ", ", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
rsize = strlcpy(bufp, factionname(fv), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#ifdef USE_UGROUPS
|
|
if (u->faction == f) {
|
|
attrib *a = a_find(u->attribs, &at_ugroup);
|
|
if (a) {
|
|
ugroup *ug = findugroupid(u->faction, a->data.i);
|
|
if (is_ugroupleader(u, ug)) {
|
|
if (size>1) {
|
|
strcpy(bufp++, "*");
|
|
--size;
|
|
}
|
|
}
|
|
rsize = strlcpy(bufp, itoa36(ug->id), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
rsize = strlcpy(bufp, ", ", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
|
|
if (u->faction != f && a_fshidden && a_fshidden->data.ca[0] == 1 && effskill(u, SK_STEALTH) >= 6) {
|
|
rsize = strlcpy(bufp, "? ", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
} else {
|
|
bufp += snprintf(bufp, size, "%d ", u->number);
|
|
size = sizeof(buf)-(bufp-buf);
|
|
}
|
|
|
|
pzTmp = get_racename(u->attribs);
|
|
if (pzTmp) {
|
|
rsize = strlcpy(bufp, pzTmp, size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
if (u->faction==f && fval(u->race, RCF_SHAPESHIFTANY)) {
|
|
rsize = strlcpy(bufp, " (", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
rsize = strlcpy(bufp, racename(f->locale, u, u->race), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
if (size>1) {
|
|
strcpy(bufp++, ")");
|
|
--size;
|
|
}
|
|
}
|
|
} else {
|
|
rsize = strlcpy(bufp, racename(f->locale, u, u->irace), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
if (u->faction==f && u->irace!=u->race) {
|
|
rsize = strlcpy(bufp, " (", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
rsize = strlcpy(bufp, racename(f->locale, u, u->race), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
if (size>1) {
|
|
strcpy(bufp++, ")");
|
|
--size;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef HEROES
|
|
if (fval(u, UFL_HERO) && (u->faction == f || omniscient(f))) {
|
|
rsize = strlcpy(bufp, ", ", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
rsize = strlcpy(bufp, LOC(f->locale, "hero"), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
#endif
|
|
/* status */
|
|
|
|
if (u->number && (u->faction == f || telepath_see || isbattle)) {
|
|
const char * c = locale_string(f->locale, hp_status(u));
|
|
rsize = strlcpy(bufp, ", ", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
rsize = strlcpy(bufp, report_kampfstatus(u, f->locale), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
if (c || fval(u, UFL_HUNGER)) {
|
|
rsize = strlcpy(bufp, " (", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
if (c) {
|
|
rsize = strlcpy(bufp, c, size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
if (fval(u, UFL_HUNGER)) {
|
|
if (c) rsize = strlcpy(bufp, ", hungert", size);
|
|
else rsize = strlcpy(bufp, "hungert", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
if (size>1) {
|
|
strcpy(bufp++, ")");
|
|
--size;
|
|
}
|
|
}
|
|
}
|
|
if (getguard(u)) {
|
|
rsize = strlcpy(bufp, ", bewacht die Region", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
|
|
if ((b = usiege(u))!=NULL) {
|
|
rsize = strlcpy(bufp, ", belagert ", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
rsize = strlcpy(bufp, buildingname(b), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
|
|
dh = 0;
|
|
if (u->faction == f || telepath_see) {
|
|
for (sk = 0; sk != MAXSKILLS; sk++) {
|
|
rsize = spskill(bufp, size, f->locale, u, sk, &dh, 1);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
}
|
|
|
|
dh = 0;
|
|
if (f == u->faction || telepath_see || omniscient(f)) {
|
|
show = u->items;
|
|
} else if (!itemcloak && mode >= see_unit && !(a_fshidden
|
|
&& a_fshidden->data.ca[1] == 1 && effskill(u, SK_STEALTH) >= 3))
|
|
{
|
|
show = NULL;
|
|
for (itm=u->items;itm;itm=itm->next) {
|
|
item * ishow;
|
|
const char * ic;
|
|
int in;
|
|
report_item(u, itm, f, NULL, &ic, &in, false);
|
|
if (ic && *ic && in>0) {
|
|
for (ishow = show; ishow; ishow=ishow->next) {
|
|
const char * sc;
|
|
int sn;
|
|
if (ishow->type==itm->type) sc=ic;
|
|
else report_item(u, ishow, f, NULL, &sc, &sn, false);
|
|
if (sc==ic || strcmp(sc, ic)==0) {
|
|
ishow->number+=itm->number;
|
|
break;
|
|
}
|
|
}
|
|
if (ishow==NULL) {
|
|
ishow = i_add(&show, i_new(itm->type, itm->number));
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
show = NULL;
|
|
}
|
|
for (itm=show; itm; itm=itm->next) {
|
|
const char * ic;
|
|
int in;
|
|
report_item(u, itm, f, &ic, NULL, &in, false);
|
|
if (in==0 || ic==NULL) continue;
|
|
rsize = strlcpy(bufp, ", ", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
|
|
if (!dh) {
|
|
bufp += snprintf(bufp, size, "%s: ", LOC(f->locale, "nr_inventory"));
|
|
size = sizeof(buf)-(bufp-buf);
|
|
dh = 1;
|
|
}
|
|
if (in == 1) {
|
|
rsize = strlcpy(bufp, ic, size);
|
|
} else {
|
|
rsize = snprintf(bufp, size, "%d %s", in, ic);
|
|
}
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
if (show!=u->items) while (show) i_free(i_remove(&show, show));
|
|
|
|
if (u->faction == f || telepath_see) {
|
|
sc_mage * m = get_mage(u);
|
|
|
|
if (m!=NULL) {
|
|
spell_list *slist = m->spells;
|
|
int t = effskill(u, SK_MAGIC);
|
|
bufp += snprintf(bufp, size, ". Aura %d/%d", get_spellpoints(u), max_spellpoints(u->region,u));
|
|
size = sizeof(buf)-(bufp-buf);
|
|
|
|
for (dh=0; slist; slist=slist->next) {
|
|
spell * sp = slist->data;
|
|
if (sp->level > t) continue;
|
|
if (!dh) {
|
|
rsize = snprintf(bufp, size, ", %s: ", LOC(f->locale, "nr_spells"));
|
|
dh = 1;
|
|
} else {
|
|
rsize = strlcpy(bufp, ", ", size);
|
|
}
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
rsize = strlcpy(bufp, spell_name(sp, f->locale), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
|
|
for (i=0; i!=MAXCOMBATSPELLS; ++i) {
|
|
if (get_combatspell(u, i)) break;
|
|
}
|
|
if (i!=MAXCOMBATSPELLS) {
|
|
bufp += snprintf(bufp, size, ", %s: ", LOC(f->locale, "nr_combatspells"));
|
|
size = sizeof(buf)-(bufp-buf);
|
|
dh = 0;
|
|
for (i = 0; i < MAXCOMBATSPELLS; i++){
|
|
const spell *sp;
|
|
if (!dh){
|
|
dh = 1;
|
|
} else {
|
|
rsize = strlcpy(bufp, ", ", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
sp = get_combatspell(u,i);
|
|
if (sp) {
|
|
int sl = get_combatspelllevel(u, i);
|
|
rsize = strlcpy(bufp, spell_name(sp, u->faction->locale), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
|
|
if (sl > 0) {
|
|
bufp += snprintf(bufp, size, " (%d)", sl);
|
|
size = sizeof(buf)-(bufp-buf);
|
|
}
|
|
} else {
|
|
rsize = strlcpy(bufp, LOC(f->locale, "nr_nospells"), size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#ifdef LASTORDER
|
|
if (!isbattle && u->lastorder) {
|
|
rsize = buforder(bufp, size, u->lastorder, 0);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
#else
|
|
if (!isbattle) {
|
|
boolean printed = 0;
|
|
order * ord;;
|
|
for (ord=u->old_orders;ord;ord=ord->next) {
|
|
if (is_repeated(ord)) {
|
|
if (printed<ORDERS_IN_NR) {
|
|
rsize = buforder(bufp, size, ord, printed++);
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
} else break;
|
|
}
|
|
}
|
|
if (printed<ORDERS_IN_NR) for (ord=u->orders;ord;ord=ord->next) {
|
|
if (is_repeated(ord)) {
|
|
if (printed<ORDERS_IN_NR) {
|
|
rsize = buforder(bufp, size, ord, printed++);
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
} else break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
i = 0;
|
|
|
|
if (u->display && u->display[0]) {
|
|
rsize = strlcpy(bufp, "; ", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
|
|
rsize = strlcpy(bufp, u->display, size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
|
|
i = u->display[strlen(u->display) - 1];
|
|
}
|
|
if (i != '!' && i != '?' && i != '.') {
|
|
if (size>1) {
|
|
strcpy(bufp++, ".");
|
|
--size;
|
|
}
|
|
}
|
|
pzTmp = uprivate(u);
|
|
if (u->faction == f && pzTmp) {
|
|
rsize = strlcpy(bufp, " (Bem: ", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
rsize = strlcpy(bufp, pzTmp, size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
rsize = strlcpy(bufp, ")", size);
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
|
|
dh=0;
|
|
if (!getarnt && f) {
|
|
if (alliedfaction(getplane(u->region), f, fv, HELP_ALL)) {
|
|
dh = 1;
|
|
}
|
|
}
|
|
return dh;
|
|
}
|
|
|
|
/* TODO: telepath_see wird nicht berücksichtigt: Parteien mit
|
|
* telepath_see sollten immer einzelne Einheiten zu sehen
|
|
* bekommen, alles andere ist darstellungsteschnisch kompliziert.
|
|
*/
|
|
|
|
#ifdef USE_UGROUPS
|
|
int
|
|
bufunit_ugroupleader(const faction * f, const unit * u, int indent, int mode)
|
|
{
|
|
int i, dh;
|
|
int getarnt = fval(u, UFL_PARTEITARNUNG);
|
|
faction *fv;
|
|
const char *pzTmp;
|
|
attrib *a_fshidden = NULL;
|
|
item * itm;
|
|
item * show;
|
|
ugroup *ug = findugroup(u);
|
|
boolean guards = false;
|
|
boolean sieges = false;
|
|
boolean itemcloak = false;
|
|
static const curse_type * itemcloak_ct = 0;
|
|
static boolean init = false;
|
|
|
|
if (!init) {
|
|
init = true;
|
|
itemcloak_ct = ct_find("itemcloak");
|
|
}
|
|
if (itemcloak_ct!=NULL) {
|
|
itemcloak = curse_active(get_curse(u->attribs, itemcloak_ct));
|
|
}
|
|
|
|
if(fspecial(u->faction, FS_HIDDEN))
|
|
a_fshidden = a_find(u->attribs, &at_fshidden);
|
|
|
|
strcpy(buf, u->name);
|
|
|
|
fv = visible_faction(f, u);
|
|
|
|
if (getarnt) {
|
|
scat(", ");
|
|
scat(LOC(f->locale, "anonymous"));
|
|
} else {
|
|
scat(", ");
|
|
scat(factionname(fv));
|
|
}
|
|
|
|
scat(", ");
|
|
|
|
for(i = 0; i < ug->members; i++) {
|
|
unit *uc = ug->unit_array[i];
|
|
if(uc->faction != f && a_fshidden
|
|
&& a_fshidden->data.ca[0] == 1 && effskill(uc, SK_STEALTH) >= 6) {
|
|
scat("? ");
|
|
} else {
|
|
icat(uc->number);
|
|
scat(" ");
|
|
}
|
|
pzTmp = get_racename(uc->attribs);
|
|
if (pzTmp || u->irace != uc->race) {
|
|
if (pzTmp)
|
|
scat(pzTmp);
|
|
else
|
|
scat(racename(f->locale, u, u->irace));
|
|
scat(" (");
|
|
scat(itoa36(uc->no));
|
|
scat("), ");
|
|
} else {
|
|
scat(racename(f->locale, u, u->race));
|
|
scat(" (");
|
|
scat(itoa36(uc->no));
|
|
scat("), ");
|
|
}
|
|
if(getguard(uc)) guards = true;
|
|
if(usiege(uc)) sieges = true;
|
|
}
|
|
|
|
if(guards == true) scat(", bewacht die Region");
|
|
|
|
if(sieges == true) {
|
|
scat(", belagert ");
|
|
for(i = 0; i < ug->members; i++) {
|
|
building *b = usiege(ug->unit_array[i]);
|
|
if(b) {
|
|
scat(buildingname(b));
|
|
scat(", ");
|
|
}
|
|
}
|
|
}
|
|
|
|
dh = 0;
|
|
show = NULL;
|
|
for(i = 0; i < ug->members; i++) {
|
|
unit *uc = ug->unit_array[i];
|
|
if (!itemcloak && mode >= see_unit && !(a_fshidden
|
|
&& a_fshidden->data.ca[1] == 1 && effskill(u, SK_STEALTH) >= 3)) {
|
|
for (itm=uc->items;itm;itm=itm->next) {
|
|
item *ishow;
|
|
const char * ic;
|
|
int in;
|
|
report_item(u, itm, f, NULL, &ic, &in, false);
|
|
if (ic && *ic && in>0) {
|
|
for (ishow = show; ishow; ishow=ishow->next) {
|
|
const char * sc;
|
|
int sn;
|
|
if (ishow->type==itm->type) sc=ic;
|
|
else report_item(u, ishow, f, NULL, &sc, &sn, false);
|
|
if (sc==ic || strcmp(sc, ic)==0) {
|
|
ishow->number+=itm->number;
|
|
break;
|
|
}
|
|
}
|
|
if (ishow==NULL) {
|
|
ishow = i_add(&show, i_new(itm->type, itm->number));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (itm=show; itm; itm=itm->next) {
|
|
const char * ic;
|
|
int in;
|
|
report_item(u, itm, f, &ic, NULL, &in, false);
|
|
if (in==0 || ic==NULL) continue;
|
|
scat(", ");
|
|
|
|
if (!dh) {
|
|
sprintf(buf+strlen(buf), "%s: ", LOC(f->locale, "nr_inventory"));
|
|
dh = 1;
|
|
}
|
|
if (in == 1) {
|
|
scat(ic);
|
|
} else {
|
|
icat(in);
|
|
scat(" ");
|
|
scat(ic);
|
|
}
|
|
}
|
|
if(show) while(show) i_free(i_remove(&show, show));
|
|
|
|
i = 0;
|
|
if (u->display && u->display[0]) {
|
|
scat("; ");
|
|
scat(u->display);
|
|
|
|
i = u->display[strlen(u->display) - 1];
|
|
}
|
|
if (i != '!' && i != '?' && i != '.')
|
|
scat(".");
|
|
|
|
dh=0;
|
|
if (!getarnt && f && f->allies) {
|
|
ally *sf;
|
|
|
|
for (sf = f->allies; sf && !dh; sf = sf->next) {
|
|
if (sf->status > 0 && sf->status <= HELP_ALL && sf->faction == fv) {
|
|
dh = 1;
|
|
}
|
|
}
|
|
}
|
|
return dh;
|
|
}
|
|
#endif
|
|
|
|
size_t
|
|
spskill(char * buffer, size_t size, const struct locale * lang, const struct unit * u, skill_t sk, int *dh, int days)
|
|
{
|
|
char * bufp = buffer;
|
|
int i, effsk;
|
|
size_t rsize;
|
|
size_t tsize = 0;
|
|
|
|
if (!u->number) return 0;
|
|
|
|
if (!has_skill(u, sk)) return 0;
|
|
|
|
rsize = strlcpy(bufp, ", ", size);
|
|
tsize += rsize;
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
|
|
if (!*dh) {
|
|
rsize = strlcpy(bufp, LOC(lang, "nr_skills"), size);
|
|
tsize += rsize;
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
|
|
rsize = strlcpy(bufp, ": ", size);
|
|
tsize += rsize;
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
|
|
*dh = 1;
|
|
}
|
|
rsize = strlcpy(bufp, skillname(sk, lang), size);
|
|
tsize += rsize;
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
|
|
rsize = strlcpy(bufp, " ", size);
|
|
tsize += rsize;
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
|
|
if (sk == SK_MAGIC){
|
|
if (find_magetype(u) != M_GRAU){
|
|
rsize = strlcpy(bufp, LOC(lang, mkname("school", magietypen[find_magetype(u)])), size);
|
|
tsize += rsize;
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
|
|
rsize = strlcpy(bufp, " ", size);
|
|
tsize += rsize;
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
}
|
|
|
|
if (sk == SK_STEALTH && fval(u, UFL_STEALTH)) {
|
|
i = u_geteffstealth(u);
|
|
if (i>=0) {
|
|
rsize = slprintf(bufp, size, "%d/", i);
|
|
tsize += rsize;
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
}
|
|
|
|
effsk = effskill(u, sk);
|
|
rsize = slprintf(bufp, size, "%d", effsk);
|
|
tsize += rsize;
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
|
|
if(u->faction->options & Pow(O_SHOWSKCHANGE)) {
|
|
skill *skill = get_skill(u, sk);
|
|
int oldeff = 0;
|
|
int diff;
|
|
|
|
if (skill->old > 0) {
|
|
oldeff = skill->old + get_modifier(u, sk, skill->old, u->region, false);
|
|
}
|
|
|
|
oldeff = max(0, oldeff);
|
|
diff = effsk - oldeff;
|
|
|
|
if (diff != 0) {
|
|
rsize = slprintf(bufp, size, " (%s%d)", (diff>0)?"+":"", diff);
|
|
tsize += rsize;
|
|
if (rsize>size) rsize = size-1;
|
|
size -= rsize;
|
|
bufp += rsize;
|
|
}
|
|
}
|
|
return tsize;
|
|
}
|
|
|
|
void
|
|
lparagraph(struct strlist ** SP, char *s, int indent, char mark)
|
|
{
|
|
|
|
/* Die Liste SP wird mit dem String s aufgefuellt, mit indent und einer
|
|
* mark, falls angegeben. SP wurde also auf 0 gesetzt vor dem Aufruf.
|
|
* Vgl. spunit (). */
|
|
|
|
char *buflocal = calloc(strlen(s) + indent + 1, sizeof(char));
|
|
|
|
if (indent) {
|
|
memset(buflocal, ' ', indent);
|
|
if (mark)
|
|
buflocal[indent - 2] = mark;
|
|
}
|
|
strcpy(buflocal + indent, s);
|
|
addstrlist(SP, buflocal);
|
|
free(buflocal);
|
|
}
|
|
|
|
void
|
|
spunit(struct strlist ** SP, const struct faction * f, const unit * u, int indent,
|
|
int mode)
|
|
{
|
|
int dh;
|
|
#ifdef USE_UGROUPS
|
|
ugroup *ug = findugroup(u);
|
|
|
|
if(ug) {
|
|
if(is_ugroupleader(u, ug)) {
|
|
dh = bufunit_ugroupleader(f, u, indent, mode);
|
|
} else {
|
|
return;
|
|
}
|
|
} else
|
|
#endif
|
|
dh = bufunit(f, u, indent, mode);
|
|
lparagraph(SP, buf, indent, (char) ((u->faction == f) ? '*' : (dh ? '+' : '-')));
|
|
}
|
|
|
|
/* in spy steht der Unterschied zwischen Wahrnehmung des Opfers und
|
|
* Spionage des Spions */
|
|
void
|
|
spy_message(int spy, unit *u, unit *target)
|
|
{
|
|
const char *c;
|
|
|
|
produceexp(u, SK_SPY, u->number);
|
|
|
|
/* Infos:
|
|
* - Kampfstatus
|
|
* - verborgene Gegenstände: Amulette, Ringe, Phiolen, Geld
|
|
* - Partei
|
|
* - Talentinfo
|
|
* - Zaubersprüche
|
|
* - Zauberwirkungen
|
|
*/
|
|
/* mit spy=100 (magische Spionage) soll alles herausgefunden werden */
|
|
|
|
buf[0]='\0';
|
|
if (spy > 99){
|
|
/* magische Spionage */
|
|
/* Zauberwirkungen */
|
|
}
|
|
if (spy > 20){
|
|
sc_mage * m = get_mage(target);
|
|
/* bei Magiern Zaubersprüche und Magiegebiet */
|
|
if (m) {
|
|
spell_list *slist = m->spells;
|
|
boolean first = true;
|
|
|
|
scat("Magiegebiet: ");
|
|
scat(LOC(u->faction->locale, magietypen[find_magetype(target)]));
|
|
scat(", Sprüche: ");
|
|
|
|
for (;slist; slist=slist->next) {
|
|
spell * sp = slist->data;
|
|
if (first) {
|
|
first = false;
|
|
} else {
|
|
scat(", ");
|
|
}
|
|
scat(spell_name(sp, u->faction->locale));
|
|
}
|
|
if (first) scat("Keine");
|
|
scat(". ");
|
|
}
|
|
}
|
|
if (spy > 6){
|
|
/* wahre Partei */
|
|
scat("Partei '");
|
|
scat(factionname(target->faction));
|
|
scat("'. ");
|
|
} else {
|
|
/* ist die Einheit in Spionage nicht gut genug, glaubt sie die
|
|
* Parteitarnung */
|
|
faction *fv = visible_faction(u->faction,target);
|
|
|
|
if (fv != target->faction){
|
|
scat("Partei '");
|
|
scat(factionname(fv));
|
|
scat("'. ");
|
|
} else if (!fval(target, UFL_PARTEITARNUNG)){
|
|
scat("Partei '");
|
|
scat(factionname(target->faction));
|
|
scat("'. ");
|
|
}
|
|
}
|
|
if (spy > 0){
|
|
scat("Talente: ");
|
|
{
|
|
int first = 1;
|
|
int found = 0;
|
|
skill_t sk;
|
|
|
|
for (sk = 0; sk != MAXSKILLS; sk++) {
|
|
if (has_skill(target, sk)) {
|
|
found++;
|
|
if (first == 1) {
|
|
first = 0;
|
|
} else {
|
|
scat(", ");
|
|
}
|
|
scat(skillname(sk, u->faction->locale));
|
|
scat(" ");
|
|
icat(eff_skill(target, sk, target->region));
|
|
}
|
|
}
|
|
if (found == 0) {
|
|
scat("Keine");
|
|
}
|
|
scat(". ");
|
|
}
|
|
|
|
scat("Im Gepäck sind");
|
|
{
|
|
boolean first = true;
|
|
int found = 0;
|
|
item * itm;
|
|
for (itm=target->items;itm;itm=itm->next) {
|
|
if (itm->number>0) {
|
|
resource_type * rtype = itm->type->rtype;
|
|
++found;
|
|
if (first) {
|
|
first = false;
|
|
scat(": ");
|
|
} else {
|
|
scat(", ");
|
|
}
|
|
|
|
if (itm->number == 1) {
|
|
scat("1 ");
|
|
scat(locale_string(u->faction->locale, resourcename(rtype, 0)));
|
|
} else {
|
|
icat(itm->number);
|
|
scat(" ");
|
|
scat(locale_string(u->faction->locale, resourcename(rtype, NMF_PLURAL)));
|
|
}
|
|
}
|
|
}
|
|
if (found == 0) {
|
|
scat(" keine verborgenen Gegenstände");
|
|
}
|
|
scat(". ");
|
|
}
|
|
}
|
|
/* spion ist gleich gut wie Wahrnehmung Opfer */
|
|
/* spion ist schlechter als Wahrnehmung Opfer */
|
|
{ /* immer */
|
|
scat("Kampfstatus: ");
|
|
scat(report_kampfstatus(target, u->faction->locale));
|
|
c = locale_string(u->faction->locale, hp_status(target));
|
|
if (c && strlen(c))
|
|
sprintf(buf, "%s (%s)", buf, c);
|
|
scat(".");
|
|
}
|
|
|
|
ADDMSG(&u->faction->msgs, msg_message("spyreport",
|
|
"spy target report", u, target, strdup(buf)));
|
|
}
|
|
|
|
const struct unit *
|
|
ucansee(const struct faction *f, const struct unit *u, const struct unit *x)
|
|
{
|
|
if (cansee(f, u->region, u, 0)) return u;
|
|
return x;
|
|
}
|
|
|
|
faction_list *
|
|
get_addresses(faction * f, struct seen_region * seehash[])
|
|
{
|
|
/* "TODO: travelthru" */
|
|
region *r, *last = lastregion(f);
|
|
const faction * lastf = NULL;
|
|
faction_list * flist = calloc(1, sizeof(faction_list));
|
|
flist->data = f;
|
|
|
|
for (r=firstregion(f);r!=last;r=r->next) {
|
|
const unit * u = r->units;
|
|
const seen_region * sr = find_seen(seehash, r);
|
|
|
|
if (sr==NULL) continue;
|
|
while (u!=NULL) {
|
|
faction * sf = visible_faction(f, u);
|
|
boolean ballied = sf && sf!=f && sf!=lastf
|
|
&& !fval(u, UFL_PARTEITARNUNG) && cansee(f, r, u, 0);
|
|
if (ballied || ALLIED(f, sf)) {
|
|
faction_list ** fnew = &flist;
|
|
while (*fnew && (*fnew)->data->no < sf->no) {
|
|
fnew =&(*fnew)->next;
|
|
}
|
|
if ((*fnew==NULL) || (*fnew)->data!=sf) {
|
|
faction_list * finsert = malloc(sizeof(faction_list));
|
|
finsert->next = *fnew;
|
|
*fnew = finsert;
|
|
finsert->data = sf;
|
|
}
|
|
lastf = sf;
|
|
}
|
|
u = u->next;
|
|
}
|
|
}
|
|
|
|
if (f->alliance != NULL) {
|
|
faction *f2;
|
|
for(f2 = factions; f2; f2 = f2->next) {
|
|
if(f2->alliance != NULL && f2->alliance == f->alliance) {
|
|
faction_list ** fnew = &flist;
|
|
while (*fnew && (*fnew)->data->no < f2->no) {
|
|
fnew =&(*fnew)->next;
|
|
}
|
|
if ((*fnew==NULL) || (*fnew)->data!=f2) {
|
|
faction_list * finsert = malloc(sizeof(faction_list));
|
|
finsert->next = *fnew;
|
|
*fnew = finsert;
|
|
finsert->data = f2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return flist;
|
|
}
|
|
|
|
#define MAXSEEHASH 10007
|
|
seen_region * reuse;
|
|
|
|
seen_region **
|
|
seen_init(void)
|
|
{
|
|
return (seen_region **)calloc(MAXSEEHASH, sizeof(seen_region*));
|
|
}
|
|
|
|
void
|
|
seen_done(seen_region * seehash[])
|
|
{
|
|
int i;
|
|
for (i=0;i!=MAXSEEHASH;++i) {
|
|
seen_region * sd = seehash[i];
|
|
if (sd==NULL) continue;
|
|
while (sd->nextHash!=NULL) sd = sd->nextHash;
|
|
sd->nextHash = reuse;
|
|
reuse = seehash[i];
|
|
seehash[i] = NULL;
|
|
}
|
|
free(seehash);
|
|
}
|
|
|
|
void
|
|
free_seen(void)
|
|
{
|
|
while (reuse) {
|
|
seen_region * r = reuse;
|
|
reuse = reuse->nextHash;
|
|
free(r);
|
|
}
|
|
}
|
|
|
|
seen_region *
|
|
find_seen(struct seen_region * seehash[], const region * r)
|
|
{
|
|
unsigned int index = reg_hashkey(r) % MAXSEEHASH;
|
|
seen_region * find = seehash[index];
|
|
while (find) {
|
|
if (find->r==r) return find;
|
|
find=find->nextHash;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
get_seen_interval(struct seen_region ** seen, region ** first, region ** last)
|
|
{
|
|
/* this is required to find the neighbour regions of the ones we are in,
|
|
* which may well be outside of [firstregion, lastregion) */
|
|
#ifdef ENUM_REGIONS
|
|
int i;
|
|
for (i=0;i!=MAXSEEHASH;++i) {
|
|
seen_region * sr = seen[i];
|
|
while (sr!=NULL) {
|
|
if (*first==NULL || sr->r->index<(*first)->index) {
|
|
*first = sr->r;
|
|
}
|
|
if (*last!=NULL && sr->r->index>=(*last)->index) {
|
|
*last = sr->r->next;
|
|
}
|
|
sr = sr->nextHash;
|
|
}
|
|
}
|
|
#else
|
|
region * r = regions;
|
|
while (r!=first) {
|
|
if (find_seen(seen, r)!=NULL) {
|
|
*first = r;
|
|
break;
|
|
}
|
|
r = r->next;
|
|
}
|
|
r = *last;
|
|
while (r!=NULL) {
|
|
if (find_seen(seen, r)!=NULL) {
|
|
*last = r->next;
|
|
}
|
|
r = r->next;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
boolean
|
|
add_seen(struct seen_region * seehash[], struct region * r, unsigned char mode, boolean dis)
|
|
{
|
|
seen_region * find = find_seen(seehash, r);
|
|
if (find==NULL) {
|
|
unsigned int index = reg_hashkey(r) % MAXSEEHASH;
|
|
if (!reuse) reuse = (seen_region*)calloc(1, sizeof(struct seen_region));
|
|
find = reuse;
|
|
reuse = reuse->nextHash;
|
|
find->nextHash = seehash[index];
|
|
seehash[index] = find;
|
|
find->r = r;
|
|
} else if (find->mode >= mode) {
|
|
return false;
|
|
}
|
|
find->mode = mode;
|
|
find->disbelieves |= dis;
|
|
return true;
|
|
}
|
|
|