forked from github/server
311 lines
7.4 KiB
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();
|
|
}
|