server/src/curses.c

311 lines
7.4 KiB
C

#include <platform.h>
#include <kernel/types.h>
#include "curses.h"
#include <kernel/connection.h>
#include <kernel/curse.h>
#include <kernel/config.h>
#include <kernel/faction.h>
#include <kernel/message.h>
#include <kernel/region.h>
#include <kernel/save.h>
#include <kernel/terrain.h>
#include <kernel/unit.h>
#include <kernel/version.h>
#include "spells/regioncurse.h"
#include "spells/unitcurse.h"
#include "spells/shipcurse.h"
#include "spells/buildingcurse.h"
#include <util/attrib.h>
#include <util/language.h>
#include <util/rand.h>
#include <util/rng.h>
#include <util/resolve.h>
#include <storage.h>
#include <assert.h>
typedef struct wallcurse {
curse *buddy;
connection *wall;
} wallcurse;
void cw_init(attrib * a)
{
curse *c;
curse_init(a);
c = (curse *) a->data.v;
c->data.v = calloc(sizeof(wallcurse), 1);
}
void cw_write(const attrib * a, const void *target, storage * store)
{
connection *b = ((wallcurse *) ((curse *) a->data.v)->data.v)->wall;
curse_write(a, target, store);
WRITE_INT(store, b->id);
}
typedef struct bresolve {
unsigned int id;
curse *self;
} bresolve;
static int resolve_buddy(variant data, void *addr);
static int cw_read(attrib * a, void *target, storage * store)
{
bresolve *br = calloc(sizeof(bresolve), 1);
curse *c = (curse *) a->data.v;
wallcurse *wc = (wallcurse *) c->data.v;
variant var;
curse_read(a, store, target);
br->self = c;
READ_UINT(store, &br->id);
var.i = br->id;
ur_add(var, &wc->wall, resolve_borderid);
var.v = br;
ur_add(var, &wc->buddy, resolve_buddy);
return AT_READ_OK;
}
/* ------------------------------------------------------------- */
/* Name: Feuerwand
* Stufe:
* Gebiet: Draig
* Kategorie: Region, negativ
* Flag:
* Kosten: SPC_LINEAR
* Aura:
* Komponenten:
*
* Wirkung:
* eine Wand aus Feuer entsteht in der angegebenen Richtung
*
* Was fuer eine Wirkung hat die?
*/
void wall_vigour(curse * c, float delta)
{
wallcurse *wc = (wallcurse *) c->data.v;
assert(wc->buddy->vigour == c->vigour);
wc->buddy->vigour += delta;
if (wc->buddy->vigour <= 0) {
erase_border(wc->wall);
wc->wall = NULL;
((wallcurse *) wc->buddy->data.v)->wall = NULL;
}
}
const curse_type ct_firewall = {
"Feuerwand",
CURSETYP_NORM, 0, (M_DURATION | M_VIGOUR | NO_MERGE),
NULL, /* curseinfo */
wall_vigour /* change_vigour */
};
attrib_type at_cursewall = {
"cursewall",
cw_init,
curse_done,
curse_age,
cw_write,
cw_read,
ATF_CURSE
};
static int resolve_buddy(variant data, void *addr)
{
curse *result = NULL;
bresolve *br = (bresolve *) data.v;
connection *b;
assert(br->id > 0);
b = find_border(br->id);
if (b && b->from && b->to) {
attrib *a = a_find(b->from->attribs, &at_cursewall);
while (a && a->data.v != br->self) {
curse *c = (curse *) a->data.v;
wallcurse *wc = (wallcurse *) c->data.v;
if (wc->wall->id == br->id)
break;
a = a->next;
}
if (!a || a->type != &at_cursewall) {
a = a_find(b->to->attribs, &at_cursewall);
while (a && a->type == &at_cursewall && a->data.v != br->self) {
curse *c = (curse *) a->data.v;
wallcurse *wc = (wallcurse *) c->data.v;
if (wc->wall->id == br->id)
break;
a = a->next;
}
}
if (a && a->type == &at_cursewall) {
curse *c = (curse *) a->data.v;
free(br);
result = c;
}
} else {
/* fail, object does not exist (but if you're still loading then
* you may want to try again later) */
*(curse **) addr = NULL;
return -1;
}
*(curse **) addr = result;
return 0;
}
static void wall_init(connection * b)
{
wall_data *fd = (wall_data *) calloc(sizeof(wall_data), 1);
fd->countdown = -1; /* infinite */
b->data.v = fd;
}
static void wall_destroy(connection * b)
{
free(b->data.v);
}
static void wall_read(connection * b, storage * store)
{
static wall_data dummy;
wall_data *fd = b->data.v ? (wall_data *) b->data.v : &dummy;
variant mno;
if (global.data_version < STORAGE_VERSION) {
READ_INT(store, &mno.i);
fd->mage = findunit(mno.i);
if (!fd->mage && b->data.v) {
ur_add(mno, &fd->mage, resolve_unit);
}
} else {
read_reference(&fd->mage, store, read_unit_reference, resolve_unit);
}
READ_INT(store, &fd->force);
if (global.data_version >= NOBORDERATTRIBS_VERSION) {
READ_INT(store, &fd->countdown);
}
fd->active = true;
}
static void wall_write(const connection * b, storage * store)
{
wall_data *fd = (wall_data *) b->data.v;
write_unit_reference(fd->mage, store);
WRITE_INT(store, fd->force);
WRITE_INT(store, fd->countdown);
}
static int wall_age(connection * b)
{
wall_data *fd = (wall_data *) b->data.v;
--fd->countdown;
return (fd->countdown > 0) ? AT_AGE_KEEP : AT_AGE_REMOVE;
}
static region *wall_move(const connection * b, struct unit *u,
struct region *from, struct region *to, bool routing)
{
wall_data *fd = (wall_data *) b->data.v;
if (!routing && fd->active) {
int hp = dice(3, fd->force) * u->number;
hp = MIN(u->hp, hp);
u->hp -= hp;
if (u->hp) {
ADDMSG(&u->faction->msgs, msg_message("firewall_damage",
"region unit", from, u));
} else
ADDMSG(&u->faction->msgs, msg_message("firewall_death", "region unit",
from, u));
if (u->number > u->hp) {
scale_number(u, u->hp);
u->hp = u->number;
}
}
return to;
}
static const char *b_namefirewall(const connection * b, const region * r,
const faction * f, int gflags)
{
const char *bname;
unused(f);
unused(r);
unused(b);
if (gflags & GF_ARTICLE)
bname = "a_firewall";
else
bname = "firewall";
if (gflags & GF_PURE)
return bname;
return LOC(f->locale, mkname("border", bname));
}
border_type bt_firewall = {
"firewall", VAR_VOIDPTR,
b_transparent, /* transparent */
wall_init, /* init */
wall_destroy, /* destroy */
wall_read, /* read */
wall_write, /* write */
b_blocknone, /* block */
b_namefirewall, /* name */
b_rvisible, /* rvisible */
b_finvisible, /* fvisible */
b_uinvisible, /* uvisible */
NULL,
wall_move,
wall_age
};
void convert_firewall_timeouts(connection * b, attrib * a)
{
while (a) {
if (b->type == &bt_firewall && a->type == &at_countdown) {
wall_data *fd = (wall_data *) b->data.v;
fd->countdown = a->data.i;
}
}
}
border_type bt_wisps = { /* only here for reading old data */
"wisps", VAR_VOIDPTR,
b_transparent, /* transparent */
0, /* init */
wall_destroy, /* destroy */
wall_read, /* read */
0, /* write */
b_blocknone, /* block */
0, /* name */
b_rvisible, /* rvisible */
b_fvisible, /* fvisible */
b_uvisible, /* uvisible */
NULL, /* visible */
0
};
void register_curses(void)
{
border_convert_cb = &convert_firewall_timeouts;
at_register(&at_cursewall);
register_bordertype(&bt_firewall);
register_bordertype(&bt_wisps);
register_bordertype(&bt_chaosgate);
register_unitcurse();
register_regioncurse();
register_shipcurse();
register_buildingcurse();
}