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

indentation rules, strictly applied

Browse source
This commit is contained in:
Enno 2011-03-07 08:03:10 +01:00
parent 6286c3212d
commit 347a888b67
24 changed files with 4472 additions and 3270 deletions

31
src/bindings.c
View file

@ -10,28 +10,34 @@
#include <tolua.h>
static int
tolua_levitate_ship(lua_State * L)
static int tolua_levitate_ship(lua_State * L)
{
ship *sh = (ship *) tolua_tousertype(L, 1, 0);
unit *mage = (unit *) tolua_tousertype(L, 2, 0);
double power = (double)tolua_tonumber(L, 3, 0);
int duration = (int)tolua_tonumber(L, 4, 0);
int cno = levitate_ship(sh, mage, power, duration);
tolua_pushnumber(L, (lua_Number) cno);
return 1;
}
extern void spawn_undead(void);
extern void spawn_dragons(void);
extern void plan_monsters(struct faction *f);
static int
tolua_planmonsters(lua_State * L)
static int tolua_planmonsters(lua_State * L)
{
faction *f = (faction *) tolua_tousertype(L, 1, get_monsters());
if (f) {
plan_monsters(f);
}
@ -39,31 +45,32 @@ tolua_planmonsters(lua_State * L)
return 0;
}
static int
tolua_spawn_dragons(lua_State * L)
static int tolua_spawn_dragons(lua_State * L)
{
spawn_dragons();
return 0;
}
static int
tolua_spawn_undead(lua_State * L)
static int tolua_spawn_undead(lua_State * L)
{
spawn_undead();
return 0;
}
static int
fix_familiars(struct lua_State * L)
static int fix_familiars(struct lua_State *L)
{
faction *f;
for (f = factions; f; f = f->next) {
unit *u;
for (u = f->units; u; u = u->nextF) {
struct sc_mage *mage = get_mage(u);
if (mage && is_familiar(u)) {
if (mage->spells && mage->magietyp == M_GRAY) {
equipment *eq;
char buffer[64];
ql_free(mage->spells);
@ -80,8 +87,7 @@ fix_familiars(struct lua_State * L)
return 0;
}
void
bind_eressea(struct lua_State * L)
void bind_eressea(struct lua_State *L)
{
tolua_module(L, NULL, 0);
tolua_beginmodule(L, NULL);
@ -94,4 +100,3 @@ bind_eressea(struct lua_State * L)
}
tolua_endmodule(L);
}

114
src/curses.c
View file

@ -33,17 +33,19 @@ typedef struct wallcurse {
connection *wall;
} wallcurse;
void
cw_init(attrib * a) {
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) {
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);
store->w_int(store, b->id);
}
@ -55,12 +57,14 @@ typedef struct bresvole {
static int resolve_buddy(variant data, void *addr);
static int
cw_read(attrib * a, void * target, storage * store)
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);
@ -75,8 +79,7 @@ cw_read(attrib * a, void * target, storage * store)
return AT_READ_OK;
}
attrib_type at_cursewall =
{
attrib_type at_cursewall = {
"cursewall",
cw_init,
curse_done,
@ -87,10 +90,10 @@ attrib_type at_cursewall =
};
static int
resolve_buddy(variant data, void * addr)
static int resolve_buddy(variant data, void *addr)
{
curse *result = NULL;
bresolve *br = (bresolve *) data.v;
if (br->id >= 0) {
@ -98,23 +101,31 @@ resolve_buddy(variant data, void * addr)
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;
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;
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;
}
@ -129,25 +140,25 @@ resolve_buddy(variant data, void * addr)
return 0;
}
static void
wall_init(connection * b)
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)
static void wall_destroy(connection * b)
{
free(b->data.v);
}
static void
wall_read(connection * b, storage * store)
static void wall_read(connection * b, storage * store)
{
wall_data *fd = (wall_data *) b->data.v;
variant mno;
assert(fd);
if (store->version < STORAGE_VERSION) {
mno.i = store->r_int(store);
@ -165,36 +176,39 @@ wall_read(connection * b, storage * store)
fd->active = true;
}
static void
wall_write(const connection * b, storage * store)
static void wall_write(const connection * b, storage * store)
{
wall_data *fd = (wall_data *) b->data.v;
write_unit_reference(fd->mage, store);
store->w_int(store, fd->force);
store->w_int(store, fd->countdown);
}
static int
wall_age(connection * b)
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, boolean routing)
static region *wall_move(const connection * b, struct unit *u,
struct region *from, struct region *to, boolean 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));
} 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;
@ -203,17 +217,21 @@ wall_move(const connection * b, struct unit * u, struct region * from, struct re
return to;
}
static const char *
b_namefirewall(const connection * b, const region * r, const faction * f, int gflags)
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_ARTICLE)
bname = "a_firewall";
else
bname = "firewall";
if (gflags & GF_PURE) return bname;
if (gflags & GF_PURE)
return bname;
return LOC(f->locale, mkname("border", bname));
}
@ -239,15 +257,17 @@ 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;
}
}
}
static const char *
wisps_name(const connection * b, const region * r, const faction * f, int gflags)
static const char *wisps_name(const connection * b, const region * r,
const faction * f, int gflags)
{
const char *bname;
unused(f);
unused(r);
unused(b);
@ -256,7 +276,8 @@ wisps_name(const connection * b, const region * r, const faction * f, int gflags
} else {
bname = "wisps";
}
if (gflags & GF_PURE) return bname;
if (gflags & GF_PURE)
return bname;
return LOC(f->locale, mkname("border", bname));
}
@ -265,29 +286,37 @@ typedef struct wisps_data {
int rnd;
} wisps_data;
static region *
wisps_move(const connection * b, struct unit * u, struct region * from, struct region * next, boolean routing)
static region *wisps_move(const connection * b, struct unit *u,
struct region *from, struct region *next, boolean routing)
{
direction_t reldir = reldirection(from, next);
wisps_data *wd = (wisps_data *) b->data.v;
assert(reldir != D_SPECIAL);
if (routing && wd->wall.active) {
region * rl = rconnect(from, (direction_t)((reldir+MAXDIRECTIONS-1)%MAXDIRECTIONS));
region *rl =
rconnect(from,
(direction_t) ((reldir + MAXDIRECTIONS - 1) % MAXDIRECTIONS));
region *rr = rconnect(from, (direction_t) ((reldir + 1) % MAXDIRECTIONS));
/* pick left and right region: */
if (wd->rnd < 0) {
wd->rnd = rng_int() % 3;
}
if (wd->rnd == 1 && rl && fval(rl->terrain, LAND_REGION)==fval(next, LAND_REGION)) return rl;
if (wd->rnd == 2 && rr && fval(rr->terrain, LAND_REGION)==fval(next, LAND_REGION)) return rr;
if (wd->rnd == 1 && rl
&& fval(rl->terrain, LAND_REGION) == fval(next, LAND_REGION))
return rl;
if (wd->rnd == 2 && rr
&& fval(rr->terrain, LAND_REGION) == fval(next, LAND_REGION))
return rr;
}
return next;
}
static void
wisps_init(connection * b)
static void wisps_init(connection * b)
{
wisps_data *wd = (wisps_data *) calloc(sizeof(wisps_data), 1);
@ -311,8 +340,7 @@ border_type bt_wisps = {
wisps_move
};
void
register_curses(void)
void register_curses(void)
{
border_convert_cb = &convert_firewall_timeouts;
at_register(&at_cursewall);

83
src/main.c
View file

@ -15,13 +15,17 @@
#include <tests.h>
static const char *luafile = "setup.lua";
static const char *entry_point = NULL;
static const char *inifile = "eressea.ini";
static int memdebug = 0;
static void parse_config(const char *filename)
{
dictionary *d = iniparser_new(filename);
if (d) {
load_inifile(d);
@ -38,8 +42,7 @@ static void parse_config(const char * filename)
global.inifile = d;
}
static int
usage(const char * prog, const char * arg)
static int usage(const char *prog, const char *arg)
{
if (arg) {
fprintf(stderr, "unknown argument: %s\n\n", arg);
@ -50,15 +53,14 @@ usage(const char * prog, const char * arg)
"-v <level> : verbosity level\n"
"-C : run in interactive mode\n"
"--color : force curses to use colors even when not detected\n"
"--tests : run testsuite\n"
"--help : help\n", prog);
"--tests : run testsuite\n" "--help : help\n", prog);
return -1;
}
static int
parse_args(int argc, char **argv, int *exitcode)
static int parse_args(int argc, char **argv, int *exitcode)
{
int i;
int run_tests = 0;
for (i = 1; i != argc; ++i) {
@ -68,23 +70,21 @@ parse_args(int argc, char **argv, int *exitcode)
if (strcmp(argv[i] + 2, "version") == 0) {
printf("\n%s PBEM host\n"
"Copyright (C) 1996-2005 C. Schlittchen, K. Zedel, E. Rehling, H. Peters.\n\n"
"Compilation: " __DATE__ " at " __TIME__ "\nVersion: %f\n\n", global.gamename, version());
}
else if (strcmp(argv[i]+2, "color")==0) {
"Compilation: " __DATE__ " at " __TIME__ "\nVersion: %f\n\n",
global.gamename, version());
} else if (strcmp(argv[i] + 2, "color") == 0) {
/* force the editor to have colors */
force_color = 1;
}
else if (strcmp(argv[i]+2, "tests")==0) {
} else if (strcmp(argv[i] + 2, "tests") == 0) {
/* force the editor to have colors */
run_tests = 1;
}
else if (strcmp(argv[i]+2, "help")==0) {
} else if (strcmp(argv[i] + 2, "help") == 0) {
return usage(argv[0], NULL);
}
else {
} else {
return usage(argv[0], argv[i]);
}
} else switch(argv[i][1]) {
} else
switch (argv[i][1]) {
case 'C':
entry_point = NULL;
break;
@ -122,11 +122,12 @@ parse_args(int argc, char **argv, int *exitcode)
#include <execinfo.h>
#include <signal.h>
static void
report_segfault(int signo, siginfo_t * sinf, void * arg)
static void report_segfault(int signo, siginfo_t * sinf, void *arg)
{
void *btrace[50];
size_t size;
int fd = fileno(stderr);
fflush(stdout);
@ -136,8 +137,7 @@ report_segfault(int signo, siginfo_t * sinf, void * arg)
abort();
}
static int
setup_signal_handler(void)
static int setup_signal_handler(void)
{
struct sigaction act;
@ -147,8 +147,7 @@ setup_signal_handler(void)
return sigaction(SIGSEGV, &act, NULL);
}
#else
static int
setup_signal_handler(void)
static int setup_signal_handler(void)
{
return 0;
}
@ -157,11 +156,11 @@ setup_signal_handler(void)
#undef CRTDBG
#ifdef CRTDBG
#include <crtdbg.h>
void
init_crtdbg(void)
void init_crtdbg(void)
{
#if (defined(_MSC_VER))
int flags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
if (memdebug == 1) {
flags |= _CRTDBG_CHECK_ALWAYS_DF; /* expensive */
} else if (memdebug == 2) {
@ -177,35 +176,44 @@ init_crtdbg(void)
#endif
static void
dump_spells(void)
static void dump_spells(void)
{
struct locale *loc = find_locale("de");
FILE *F = fopen("spells.csv", "w");
quicklist *ql;
int qi;
for (ql = spells, qi = 0; ql; ql_advance(&ql, &qi, 1)) {
spell *sp = (spell *) ql_get(ql, qi);
spell_component *spc = sp->components;
char components[128];
components[0] = 0;
for (; spc->type; ++spc) {
strcat(components, LOC(loc, spc->type->_name[0]));
strcat(components, ",");
}
fprintf(F, "%s;%d;%s;%s\n", LOC(loc, mkname("spell", sp->sname)), sp->level, LOC(loc, mkname("school", magic_school[sp->magietyp])), components);
fprintf(F, "%s;%d;%s;%s\n", LOC(loc, mkname("spell", sp->sname)), sp->level,
LOC(loc, mkname("school", magic_school[sp->magietyp])), components);
}
fclose(F);
}
static void
dump_skills(void)
static void dump_skills(void)
{
struct locale *loc = find_locale("de");
FILE *F = fopen("skills.csv", "w");
race *rc;
skill_t sk;
fputs("\"Rasse\",", F);
for (rc = races; rc; rc = rc->next) {
if (playerrace(rc)) {
@ -216,12 +224,15 @@ dump_skills(void)
for (sk = 0; sk != MAXSKILLS; ++sk) {
const char *str = skillname(sk, loc);
if (str) {
fprintf(F, "\"%s\",", str);
for (rc = races; rc; rc = rc->next) {
if (playerrace(rc)) {
if (rc->bonus[sk]) fprintf(F, "%d,", rc->bonus[sk]);
else fputc(',', F);
if (rc->bonus[sk])
fprintf(F, "%d,", rc->bonus[sk]);
else
fputc(',', F);
}
}
fputc('\n', F);
@ -235,7 +246,9 @@ void locale_init(void)
setlocale(LC_CTYPE, "");
setlocale(LC_NUMERIC, "C");
if (towlower(0xC4) != 0xE4) { /* &Auml; => &auml; */
log_error(("Umlaut conversion is not working properly. Wrong locale? LANG=%s\n", getenv("LANG")));
log_error(
("Umlaut conversion is not working properly. Wrong locale? LANG=%s\n",
getenv("LANG")));
}
}
@ -244,6 +257,7 @@ extern void bind_eressea(struct lua_State * L);
int main(int argc, char **argv)
{
static int write_csv = 0;
int err, result = 0;
setup_signal_handler();
@ -282,13 +296,14 @@ int main(int argc, char ** argv)
log_error(("server execution failed with code %d\n", err));
return err;
}
#ifdef MSPACES
malloc_stats();
#endif
eressea_done();
log_close();
if (global.inifile) iniparser_free(global.inifile);
if (global.inifile)
iniparser_free(global.inifile);
return 0;
}

319
src/monsters.c
View file

@ -72,11 +72,12 @@
#define DRAGON_RANGE 20 /* Max. Distanz zum nächsten Drachenziel */
#define MAXILLUSION_TEXTS 3
static void
reduce_weight(unit * u)
static void reduce_weight(unit * u)
{
int capacity, weight = 0;
item **itmp = &u->items;
int horses = get_resource(u, oldresourcetype[R_HORSE]);
if (horses > 0) {
@ -87,12 +88,15 @@ reduce_weight(unit * u)
/* 0. ditch any vehicles */
while (*itmp != NULL) {
item *itm = *itmp;
const item_type *itype = itm->type;
weight += itm->number * itype->weight;
if (itype->flags & ITF_VEHICLE) {
give_item(itm->number, itm->type, u, NULL, NULL);
}
if (*itmp==itm) itmp=&itm->next;
if (*itmp == itm)
itmp = &itm->next;
}
capacity = walkingcapacity(u);
@ -100,56 +104,70 @@ reduce_weight(unit * u)
/* 1. get rid of anything that isn't silver or really lightweight or helpful in combat */
for (itmp = &u->items; *itmp && capacity > 0;) {
item *itm = *itmp;
const item_type *itype = itm->type;
weight += itm->number * itype->weight;
if (weight > capacity) {
if (itype->weight>=10 && itype->rtype->wtype==0 && itype->rtype->atype==0) {
if (itype->weight >= 10 && itype->rtype->wtype == 0
&& itype->rtype->atype == 0) {
if (itype->capacity < itype->weight) {
int reduce = MIN(itm->number, -((capacity - weight) / itype->weight));
give_item(reduce, itm->type, u, NULL, NULL);
weight -= reduce * itype->weight;
}
}
}
if (*itmp==itm) itmp=&itm->next;
if (*itmp == itm)
itmp = &itm->next;
}
for (itmp = &u->items; *itmp && weight > capacity;) {
item *itm = *itmp;
const item_type *itype = itm->type;
weight += itm->number * itype->weight;
if (itype->capacity < itype->weight) {
int reduce = MIN(itm->number, -((capacity - weight) / itype->weight));
give_item(reduce, itm->type, u, NULL, NULL);
weight -= reduce * itype->weight;
}
if (*itmp==itm) itmp=&itm->next;
if (*itmp == itm)
itmp = &itm->next;
}
}
static order *
monster_attack(unit * u, const unit * target)
static order *monster_attack(unit * u, const unit * target)
{
if (u->region!=target->region) return NULL;
if (u->faction==target->faction) return NULL;
if (!cansee(u->faction, u->region, target, 0)) return NULL;
if (monster_is_waiting(u)) return NULL;
if (u->region != target->region)
return NULL;
if (u->faction == target->faction)
return NULL;
if (!cansee(u->faction, u->region, target, 0))
return NULL;
if (monster_is_waiting(u))
return NULL;
return create_order(K_ATTACK, u->faction->locale, "%i", target->no);
}
static order *
get_money_for_dragon(region * r, unit * u, int wanted)
static order *get_money_for_dragon(region * r, unit * u, int wanted)
{
unit *u2;
int n;
/* attackiere bewachende einheiten */
for (u2 = r->units; u2; u2 = u2->next) {
if (u2 != u && is_guard(u2, GUARD_TAX)) {
order *ord = monster_attack(u, u2);
if (ord) addlist(&u->orders, ord);
if (ord)
addlist(&u->orders, ord);
}
}
@ -166,9 +184,12 @@ get_money_for_dragon(region * r, unit * u, int wanted)
for (u2 = r->units; u2; u2 = u2->next) {
if (u2->faction != u->faction && cansee(u->faction, r, u2, 0)) {
int m = get_money(u2);
if (m==0 || is_guard(u2, GUARD_TAX)) continue;
if (m == 0 || is_guard(u2, GUARD_TAX))
continue;
else {
order *ord = monster_attack(u, u2);
if (ord) {
addlist(&u->orders, ord);
n += m;
@ -187,10 +208,10 @@ get_money_for_dragon(region * r, unit * u, int wanted)
return NULL;
}
static int
all_money(region * r, faction * f)
static int all_money(region * r, faction * f)
{
unit *u;
int m;
m = rmoney(r);
@ -202,14 +223,15 @@ all_money(region * r, faction * f)
return m;
}
static direction_t
richest_neighbour(region * r, faction * f, int absolut)
static direction_t richest_neighbour(region * r, faction * f, int absolut)
{
/* m - maximum an Geld, d - Richtung, i - index, t = Geld hier */
double m;
double t;
direction_t d = NODIRECTION, i;
if (absolut == 1 || rpeasants(r) == 0) {
@ -222,6 +244,7 @@ richest_neighbour(region * r, faction * f, int absolut)
for (i = 0; i != MAXDIRECTIONS; i++) {
region *rn = rconnect(r, i);
if (rn != NULL && fval(rn->terrain, LAND_REGION)) {
if (absolut == 1 || rpeasants(rn) == 0) {
t = (double)all_money(rn, f);
@ -238,14 +261,15 @@ richest_neighbour(region * r, faction * f, int absolut)
return d;
}
static boolean
room_for_race_in_region(region *r, const race * rc)
static boolean room_for_race_in_region(region * r, const race * rc)
{
unit *u;
int c = 0;
for (u = r->units; u; u = u->next) {
if(u->race == rc) c += u->number;
if (u->race == rc)
c += u->number;
}
if (c > (rc->splitsize * 2))
@ -254,11 +278,12 @@ room_for_race_in_region(region *r, const race * rc)
return true;
}
static direction_t
random_neighbour(region * r, unit *u)
static direction_t random_neighbour(region * r, unit * u)
{
direction_t i;
region *rc;
int rr, c = 0, c2 = 0;
/* Nachsehen, wieviele Regionen in Frage kommen */
@ -297,7 +322,8 @@ random_neighbour(region * r, unit *u)
} else if (room_for_race_in_region(rc, u->race)) {
c++;
}
if (c == rr) return i;
if (c == rr)
return i;
}
}
@ -305,11 +331,12 @@ random_neighbour(region * r, unit *u)
return NODIRECTION;
}
static direction_t
treeman_neighbour(region * r)
static direction_t treeman_neighbour(region * r)
{
direction_t i;
int rr;
int c = 0;
/* Nachsehen, wieviele Regionen in Frage kommen */
@ -349,12 +376,12 @@ treeman_neighbour(region * r)
return NODIRECTION;
}
static order *
monster_move(region * r, unit * u)
static order *monster_move(region * r, unit * u)
{
direction_t d = NODIRECTION;
if (monster_is_waiting(u)) return NULL;
if (monster_is_waiting(u))
return NULL;
switch (old_race(u->race)) {
case RC_FIREDRAGON:
case RC_DRAGON:
@ -376,11 +403,11 @@ monster_move(region * r, unit * u)
return NULL;
reduce_weight(u);
return create_order(K_MOVE, u->faction->locale, "%s", LOC(u->faction->locale, directions[d]));
return create_order(K_MOVE, u->faction->locale, "%s", LOC(u->faction->locale,
directions[d]));
}
static int
dragon_affinity_value(region *r, unit *u)
static int dragon_affinity_value(region * r, unit * u)
{
int m = all_money(r, u->faction);
@ -391,17 +418,20 @@ dragon_affinity_value(region *r, unit *u)
}
}
static attrib *
set_new_dragon_target(unit * u, region * r, int range)
static attrib *set_new_dragon_target(unit * u, region * r, int range)
{
int max_affinity = 0;
region *max_region = NULL;
#if 1
region_list *rptr, *rlist = regions_in_range(r, range, allowed_dragon);
for (rptr = rlist; rptr; rptr = rptr->next) {
region *r2 = rptr->data;
int affinity = dragon_affinity_value(r2, u);
if (affinity > max_affinity) {
max_affinity = affinity;
max_region = r2;
@ -411,17 +441,21 @@ set_new_dragon_target(unit * u, region * r, int range)
free_regionlist(rlist);
#else
int tx, ty;
for (tx = r->x - range; tx < r->x + range; tx++) {
for (ty = r->y - range; ty < r->y + range; ty++) {
region *r2;
int x = tx, y = ty;
pnormalize(&x, &y, r->planep);
r2 = findregion(x, y);
if (r2 != NULL) {
int affinity = dragon_affinity_value(r2, u);
if (affinity > max_affinity) {
if (koor_distance (r->x, r->y, x, y) <= range && path_exists(r, r2, range, allowed_dragon))
{
if (koor_distance(r->x, r->y, x, y) <= range
&& path_exists(r, r2, range, allowed_dragon)) {
max_affinity = affinity;
max_region = r2;
}
@ -432,6 +466,7 @@ set_new_dragon_target(unit * u, region * r, int range)
#endif
if (max_region && max_region != r) {
attrib *a = a_find(u->attribs, &at_targetregion);
if (!a) {
a = a_add(&u->attribs, make_targetregion(max_region));
} else {
@ -442,34 +477,49 @@ set_new_dragon_target(unit * u, region * r, int range)
return NULL;
}
static order *
make_movement_order(unit * u, const region * target, int moves, boolean (*allowed)(const region *, const region *))
static order *make_movement_order(unit * u, const region * target, int moves,
boolean(*allowed) (const region *, const region *))
{
region *r = u->region;
region **plan;
int bytes, position = 0;
char zOrder[128], *bufp = zOrder;
size_t size = sizeof(zOrder) - 1;
if (monster_is_waiting(u)) return NULL;
if (monster_is_waiting(u))
return NULL;
plan = path_find(r, target, DRAGON_RANGE * 5, allowed);
if (plan==NULL) return NULL;
if (plan == NULL)
return NULL;
bytes = (int)strlcpy(bufp, (const char *)LOC(u->faction->locale, keywords[K_MOVE]), size);
if (wrptr(&bufp, &size, bytes)!=0) WARN_STATIC_BUFFER();
bytes =
(int)strlcpy(bufp, (const char *)LOC(u->faction->locale, keywords[K_MOVE]),
size);
if (wrptr(&bufp, &size, bytes) != 0)
WARN_STATIC_BUFFER();
while (position != moves && plan[position + 1]) {
region *prev = plan[position];
region *next = plan[++position];
direction_t dir = reldirection(prev, next);
assert(dir != NODIRECTION && dir != D_SPECIAL);
if (size > 1) {
*bufp++ = ' ';
--size;
}
bytes = (int)strlcpy(bufp, (const char *)LOC(u->faction->locale, directions[dir]), size);
if (wrptr(&bufp, &size, bytes)!=0) WARN_STATIC_BUFFER();
bytes =
(int)strlcpy(bufp, (const char *)LOC(u->faction->locale, directions[dir]),
size);
if (wrptr(&bufp, &size, bytes) != 0)
WARN_STATIC_BUFFER();
}
*bufp = 0;
@ -477,13 +527,16 @@ make_movement_order(unit * u, const region * target, int moves, boolean (*allowe
}
#ifdef TODO_ALP
static order *
monster_seeks_target(region *r, unit *u)
static order *monster_seeks_target(region * r, unit * u)
{
direction_t d;
unit *target = NULL;
int dist, dist2;
direction_t i;
region *nr;
/* Das Monster sucht ein bestimmtes Opfer. Welches, steht
@ -508,8 +561,7 @@ monster_seeks_target(region *r, unit *u)
if (r == target->region) { /* Wir haben ihn! */
if (u->race == new_race[RC_ALP]) {
alp_findet_opfer(u, r);
}
else {
} else {
assert(!"Seeker-Monster hat keine Aktion fuer Ziel");
}
return NULL;
@ -532,26 +584,29 @@ monster_seeks_target(region *r, unit *u)
}
assert(d != NODIRECTION);
return create_order(K_MOVE, u->faction->locale, "%s", LOC(u->faction->locale, directions[d]));
return create_order(K_MOVE, u->faction->locale, "%s", LOC(u->faction->locale,
directions[d]));
}
#endif
static void
monster_attacks(unit * u)
static void monster_attacks(unit * u)
{
region *r = u->region;
unit *u2;
for (u2 = r->units; u2; u2 = u2->next) {
if (cansee(u->faction, r, u2, 0) && u2->faction!=u->faction && chance(0.75)) {
if (cansee(u->faction, r, u2, 0) && u2->faction != u->faction
&& chance(0.75)) {
order *ord = monster_attack(u, u2);
if (ord) addlist(&u->orders, ord);
if (ord)
addlist(&u->orders, ord);
}
}
}
static const char *
random_growl(void)
static const char *random_growl(void)
{
switch (rng_int() % 5) {
case 0:
@ -570,22 +625,26 @@ random_growl(void)
extern struct attrib_type at_direction;
static order *
monster_learn(unit *u)
static order *monster_learn(unit * u)
{
int c = 0;
int n;
skill *sv;
const struct locale *lang = u->faction->locale;
/* Monster lernt ein zufälliges Talent aus allen, in denen es schon
* Lerntage hat. */
for (sv = u->skills; sv != u->skills + u->skill_size; ++sv) {
if (sv->level>0) ++c;
if (sv->level > 0)
++c;
}
if(c == 0) return NULL;
if (c == 0)
return NULL;
n = rng_int() % c + 1;
c = 0;
@ -600,28 +659,33 @@ monster_learn(unit *u)
return NULL;
}
static boolean
check_overpopulated(unit *u)
static boolean check_overpopulated(unit * u)
{
unit *u2;
int c = 0;
for (u2 = u->region->units; u2; u2 = u2->next) {
if(u2->race == u->race && u != u2) c += u2->number;
if (u2->race == u->race && u != u2)
c += u2->number;
}
if(c > u->race->splitsize * 2) return true;
if (c > u->race->splitsize * 2)
return true;
return false;
}
static void
recruit_dracoids(unit * dragon, int size)
static void recruit_dracoids(unit * dragon, int size)
{
faction *f = dragon->faction;
region *r = dragon->region;
const struct item *weapon = NULL;
order *new_order = NULL;
unit *un = createunit(r, f, size, new_race[RC_DRACOID]);
fset(un, UFL_ISNEW | UFL_MOVED);
@ -633,6 +697,7 @@ recruit_dracoids(unit * dragon, int size)
setstatus(un, ST_FIGHT);
for (weapon = un->items; weapon; weapon = weapon->next) {
const weapon_type *wtype = weapon->type->rtype->wtype;
if (wtype && (wtype->flags & WTF_MISSILE)) {
setstatus(un, ST_BEHIND);
}
@ -645,13 +710,16 @@ recruit_dracoids(unit * dragon, int size)
}
}
static order *
plan_dragon(unit * u)
static order *plan_dragon(unit * u)
{
attrib *ta = a_find(u->attribs, &at_targetregion);
region *r = u->region;
region *tr = NULL;
boolean move = false;
order *long_order = NULL;
reduce_weight(u);
@ -664,6 +732,7 @@ plan_dragon(unit * u)
if (u->race == new_race[RC_WYRM] && !move) {
unit *u2;
for (u2 = r->units; u2; u2 = u2->next) {
/* wyrme sind einzelgänger */
if (u2 == u) {
@ -680,13 +749,14 @@ plan_dragon(unit * u)
if (move) {
/* dragon gets bored and looks for a different place to go */
ta = set_new_dragon_target(u, u->region, DRAGON_RANGE);
}
else ta = a_find(u->attribs, &at_targetregion);
} else
ta = a_find(u->attribs, &at_targetregion);
if (ta != NULL) {
tr = (region *) ta->data.v;
if (tr == NULL || !path_exists(u->region, tr, DRAGON_RANGE, allowed_dragon)) {
ta = set_new_dragon_target(u, u->region, DRAGON_RANGE);
if (ta) tr = findregion(ta->data.sa[0], ta->data.sa[1]);
if (ta)
tr = findregion(ta->data.sa[0], ta->data.sa[1]);
}
}
if (tr != NULL) {
@ -704,6 +774,7 @@ plan_dragon(unit * u)
}
if (rng_int() % 100 < 15) {
const struct locale *lang = u->faction->locale;
/* do a growl */
if (rname(tr, lang)) {
addlist(&u->orders, create_order(K_MAIL, lang, "%s '%s... %s %s %s'",
@ -718,11 +789,11 @@ plan_dragon(unit * u)
if (long_order == NULL) {
/* money is gone, need a new target */
set_new_dragon_target(u, u->region, DRAGON_RANGE);
}
else if (u->race != new_race[RC_FIREDRAGON]) {
} else if (u->race != new_race[RC_FIREDRAGON]) {
/* neue dracoiden! */
if (r->land && !fval(r->terrain, FORBIDDEN_REGION)) {
int ra = 20 + rng_int() % 100;
if (get_money(u) > ra * 50 + 100 && rng_int() % 100 < 50) {
recruit_dracoids(u, ra);
}
@ -731,6 +802,7 @@ plan_dragon(unit * u)
}
if (long_order == NULL) {
skill_t sk = SK_PERCEPTION;
/* study perception (or a random useful skill) */
while (!skill_enabled[sk] || u->race->bonus[sk] < -5) {
sk = (skill_t) (rng_int() % MAXSKILLS);
@ -741,8 +813,7 @@ plan_dragon(unit * u)
return long_order;
}
void
plan_monsters(faction * f)
void plan_monsters(faction * f)
{
region *r;
@ -751,18 +822,23 @@ plan_monsters(faction * f)
for (r = regions; r; r = r->next) {
unit *u;
double attack_chance = MONSTERATTACK;
boolean attacking = false;
for (u = r->units; u; u = u->next) {
attrib *ta;
order *long_order = NULL;
/* Ab hier nur noch Befehle für NPC-Einheiten. */
if (!is_monsters(u->faction)) continue;
if (!is_monsters(u->faction))
continue;
if (attack_chance > 0.0) {
if (chance(attack_chance)) attacking = true;
if (chance(attack_chance))
attacking = true;
attack_chance = 0.0;
}
@ -786,15 +862,17 @@ plan_monsters(faction * f)
ta = a_find(u->attribs, &at_hate);
if (ta && !monster_is_waiting(u)) {
unit *tu = (unit *) ta->data.v;
if (tu && tu->region == r) {
addlist(&u->orders, create_order(K_ATTACK, u->faction->locale, "%i", tu->no));
addlist(&u->orders, create_order(K_ATTACK, u->faction->locale, "%i",
tu->no));
} else if (tu) {
tu = findunitg(ta->data.i, NULL);
if (tu != NULL) {
long_order = make_movement_order(u, tu->region, 2, allowed_walk);
}
}
else a_remove(&u->attribs, ta);
} else
a_remove(&u->attribs, ta);
}
/* All monsters guard the region: */
@ -805,6 +883,7 @@ plan_monsters(faction * f)
/* Einheiten mit Bewegungsplan kriegen ein NACH: */
if (long_order == NULL) {
attrib *ta = a_find(u->attribs, &at_targetregion);
if (ta) {
if (u->region == (region *) ta->data.v) {
a_remove(&u->attribs, ta);
@ -821,7 +900,9 @@ plan_monsters(faction * f)
* zu bewachen: */
if (u->race->bonus[SK_WEAPONLESS] != -99) {
if (eff_skill(u, SK_WEAPONLESS, u->region) < 1) {
long_order = create_order(K_STUDY, f->locale, "'%s'", skillname(SK_WEAPONLESS, f->locale));
long_order =
create_order(K_STUDY, f->locale, "'%s'", skillname(SK_WEAPONLESS,
f->locale));
}
}
}
@ -862,16 +943,16 @@ plan_monsters(faction * f)
pathfinder_cleanup();
}
static double
chaosfactor(region * r)
static double chaosfactor(region * r)
{
attrib *a = a_find(r->attribs, &at_chaoscount);
if (!a) return 0;
if (!a)
return 0;
return ((double)a->data.i / 1000.0);
}
static int
nrand(int start, int sub)
static int nrand(int start, int sub)
{
int res = 0;
@ -885,10 +966,10 @@ nrand(int start, int sub)
}
/** Drachen und Seeschlangen können entstehen */
void
spawn_dragons(void)
void spawn_dragons(void)
{
region *r;
faction *monsters = get_monsters();
for (r = regions; r; r = r->next) {
@ -900,8 +981,10 @@ spawn_dragons(void)
equip_unit(u, get_equipment("monster_seaserpent"));
}
if ((r->terrain == newterrain(T_GLACIER) || r->terrain == newterrain(T_SWAMP) || r->terrain == newterrain(T_DESERT)) && rng_int() % 10000 < (5 + 100 * chaosfactor(r)))
{
if ((r->terrain == newterrain(T_GLACIER)
|| r->terrain == newterrain(T_SWAMP)
|| r->terrain == newterrain(T_DESERT))
&& rng_int() % 10000 < (5 + 100 * chaosfactor(r))) {
if (chance(0.80)) {
u = createunit(r, monsters, nrand(60, 20) + 1, new_race[RC_FIREDRAGON]);
} else {
@ -912,7 +995,8 @@ spawn_dragons(void)
if (verbosity >= 2) {
log_printf("%d %s in %s.\n", u->number,
LOC(default_locale, rc_name(u->race, u->number!=1)), regionname(r, NULL));
LOC(default_locale, rc_name(u->race, u->number != 1)), regionname(r,
NULL));
}
name_unit(u);
@ -925,44 +1009,58 @@ spawn_dragons(void)
}
/** Untote können entstehen */
void
spawn_undead(void)
void spawn_undead(void)
{
region *r;
faction *monsters = get_monsters();
for (r = regions; r; r = r->next) {
int unburied = deathcount(r);
static const curse_type *ctype = NULL;
if (!ctype) ctype = ct_find("holyground");
if (ctype && curse_active(get_curse(r->attribs, ctype))) continue;
if (!ctype)
ctype = ct_find("holyground");
if (ctype && curse_active(get_curse(r->attribs, ctype)))
continue;
/* Chance 0.1% * chaosfactor */
if (r->land && unburied > r->land->peasants / 20 && rng_int() % 10000 < (100 + 100 * chaosfactor(r))) {
if (r->land && unburied > r->land->peasants / 20
&& rng_int() % 10000 < (100 + 100 * chaosfactor(r))) {
unit *u;
/* es ist sinnfrei, wenn irgendwo im Wald 3er-Einheiten Untote entstehen.
* Lieber sammeln lassen, bis sie mindestens 5% der Bevölkerung sind, und
* dann erst auferstehen. */
int undead = unburied / (rng_int() % 2 + 1);
const race * rc = NULL;
int i;
if (r->age<100) undead = undead * r->age / 100; /* newbie-regionen kriegen weniger ab */
if (!undead || r->age < 20) continue;
const race *rc = NULL;
int i;
if (r->age < 100)
undead = undead * r->age / 100; /* newbie-regionen kriegen weniger ab */
if (!undead || r->age < 20)
continue;
switch (rng_int() % 3) {
case 0:
rc = new_race[RC_SKELETON]; break;
rc = new_race[RC_SKELETON];
break;
case 1:
rc = new_race[RC_ZOMBIE]; break;
rc = new_race[RC_ZOMBIE];
break;
default:
rc = new_race[RC_GHOUL]; break;
rc = new_race[RC_GHOUL];
break;
}
u = createunit(r, monsters, undead, rc);
fset(u, UFL_ISNEW | UFL_MOVED);
if ((rc == new_race[RC_SKELETON] || rc == new_race[RC_ZOMBIE]) && rng_int()%10 < 4) {
if ((rc == new_race[RC_SKELETON] || rc == new_race[RC_ZOMBIE])
&& rng_int() % 10 < 4) {
equip_unit(u, get_equipment("rising_undead"));
}
@ -978,15 +1076,19 @@ spawn_undead(void)
if (verbosity >= 2) {
log_printf("%d %s in %s.\n", u->number,
LOC(default_locale, rc_name(u->race, u->number!=1)), regionname(r, NULL));
LOC(default_locale, rc_name(u->race, u->number != 1)), regionname(r,
NULL));
}
{
message *msg = msg_message("undeadrise", "region", r);
add_message(&r->msgs, msg);
for (u=r->units;u;u=u->next) freset(u->faction, FFL_SELECT);
for (u = r->units; u; u = u->next)
freset(u->faction, FFL_SELECT);
for (u = r->units; u; u = u->next) {
if (fval(u->faction, FFL_SELECT)) continue;
if (fval(u->faction, FFL_SELECT))
continue;
fset(u->faction, FFL_SELECT);
add_message(&u->faction->msgs, msg);
}
@ -994,6 +1096,7 @@ spawn_undead(void)
}
} else {
int i = deathcount(r);
if (i) {
/* Gräber verwittern, 3% der Untoten finden die ewige Ruhe */
deathcounts(r, (int)(-i * 0.03));

9
src/races/dragons.c
View file

@ -27,11 +27,11 @@
#define DRAGONAGE 27
#define WYRMAGE 68
void
age_firedragon(unit *u)
void age_firedragon(unit * u)
{
if (u->number > 0 && rng_int() % 100 < age_chance(u->age, DRAGONAGE, 1)) {
double q = (double)u->hp / (double)(unit_max_hp(u) * u->number);
u->race = new_race[RC_DRAGON];
u->irace = NULL;
scale_number(u, 1);
@ -39,14 +39,13 @@ age_firedragon(unit *u)
}
}
void
age_dragon(unit *u)
void age_dragon(unit * u)
{
if (u->number > 0 && rng_int() % 100 < age_chance(u->age, WYRMAGE, 1)) {
double q = (double)u->hp / (double)(unit_max_hp(u) * u->number);
u->race = new_race[RC_WYRM];
u->irace = NULL;
u->hp = (int)(unit_max_hp(u) * u->number * q);
}
}

6
src/races/illusion.c
View file

@ -26,13 +26,11 @@
#define ILLUSIONMAX 6
void
age_illusion(unit *u)
void age_illusion(unit * u)
{
if (u->faction->race != new_race[RC_ILLUSION]) {
if (u->age == ILLUSIONMAX) {
ADDMSG(&u->faction->msgs, msg_message("warnillusiondissolve",
"unit", u));
ADDMSG(&u->faction->msgs, msg_message("warnillusiondissolve", "unit", u));
} else if (u->age > ILLUSIONMAX) {
set_number(u, 0);
ADDMSG(&u->faction->msgs, msg_message("illusiondissolve", "unit", u));

23
src/races/races.c
View file

@ -28,17 +28,23 @@
#include <util/rng.h>
void age_firedragon(struct unit *u);
void age_dragon(struct unit *u);
void age_illusion(struct unit *u);
void age_undead(struct unit *u);
void age_skeleton(struct unit *u);
void age_zombie(struct unit *u);
void age_ghoul(struct unit *u);
static void
oldfamiliars(unit * u)
static void oldfamiliars(unit * u)
{
char fname[64];
/* these familiars have no special skills.
*/
snprintf(fname, sizeof(fname), "%s_familiar", u->race->_name[0]);
@ -46,15 +52,14 @@ oldfamiliars(unit * u)
equip_unit(u, get_equipment(fname));
}
static void
set_show_item(faction *f, item_t i)
static void set_show_item(faction * f, item_t i)
{
attrib *a = a_add(&f->attribs, a_new(&at_showitem));
a->data.v = (void *)olditemtype[i];
}
static void
equip_newunits(const struct equipment * eq, struct unit *u)
static void equip_newunits(const struct equipment *eq, struct unit *u)
{
struct region *r = u->region;
@ -69,8 +74,10 @@ equip_newunits(const struct equipment * eq, struct unit *u)
case RC_HUMAN:
if (u->building == NULL) {
const building_type *btype = bt_find("castle");
if (btype != NULL) {
building *b = new_building(btype, r, u->faction->locale);
b->size = 10;
u->building = b;
fset(u, UFL_OWNER);
@ -83,6 +90,7 @@ equip_newunits(const struct equipment * eq, struct unit *u)
case RC_AQUARIAN:
{
ship *sh = new_ship(st_find("boat"), u->faction->locale, r);
sh->size = sh->type->construction->maxsize;
u->ship = sh;
fset(u, UFL_OWNER);
@ -96,8 +104,7 @@ equip_newunits(const struct equipment * eq, struct unit *u)
/* Die Funktionen werden über den hier registrierten Namen in races.xml
* in die jeweilige Rassendefiniton eingebunden */
void
register_races(void)
void register_races(void)
{
/* function initfamiliar */
register_function((pf_generic) oldfamiliars, "oldfamiliars");

2
src/races/races.h
View file

@ -20,6 +20,4 @@ extern "C" {
#ifdef __cplusplus
}
#endif
#endif

27
src/races/zombies.c
View file

@ -32,23 +32,26 @@
#define age_chance(a,b,p) (MAX(0,a-b)*p)
void
age_undead(unit *u)
void age_undead(unit * u)
{
region *r = u->region;
int n = 0;
/* untote, die einer partei angehoeren, koennen sich
* absplitten, anstatt sich zu vermehren. monster
* untote vermehren sich nur noch */
if (u->number > UNDEAD_MIN && !is_monsters(u->faction) && rng_int() % 100 < UNDEAD_BREAKUP) {
if (u->number > UNDEAD_MIN && !is_monsters(u->faction)
&& rng_int() % 100 < UNDEAD_BREAKUP) {
int m;
unit *u2;
n = 0;
for (m = u->number; m; m--) {
if (rng_int() % 100 < UNDEAD_BREAKUP_FRACTION) ++n;
if (rng_int() % 100 < UNDEAD_BREAKUP_FRACTION)
++n;
}
u2 = create_unit(r, get_monsters(), 0, new_race[RC_UNDEAD], 0, NULL, u);
make_undead_unit(u2);
@ -56,12 +59,13 @@ age_undead(unit *u)
}
}
void
age_skeleton(unit *u)
void age_skeleton(unit * u)
{
if (is_monsters(u->faction) && rng_int() % 100 < age_chance(u->age, 27, 1)) {
int n = MAX(1, u->number / 2);
double q = (double)u->hp / (double)(unit_max_hp(u) * u->number);
u->race = new_race[RC_SKELETON_LORD];
u->irace = NULL;
scale_number(u, n);
@ -69,12 +73,13 @@ age_skeleton(unit *u)
}
}
void
age_zombie(unit *u)
void age_zombie(unit * u)
{
if (is_monsters(u->faction) && rng_int() % 100 < age_chance(u->age, 27, 1)) {
int n = MAX(1, u->number / 2);
double q = (double)u->hp / (double)(unit_max_hp(u) * u->number);
u->race = new_race[RC_ZOMBIE_LORD];
u->irace = NULL;
scale_number(u, n);
@ -82,16 +87,16 @@ age_zombie(unit *u)
}
}
void
age_ghoul(unit *u)
void age_ghoul(unit * u)
{
if (is_monsters(u->faction) && rng_int() % 100 < age_chance(u->age, 27, 1)) {
int n = MAX(1, u->number / 2);
double q = (double)u->hp / (double)(unit_max_hp(u) * u->number);
u->race = new_race[RC_GHOUL_LORD];
u->irace = NULL;
scale_number(u, n);
u->hp = (int)(unit_max_hp(u) * u->number * q);
}
}

54
src/spells/alp.c
View file

@ -48,23 +48,22 @@ typedef struct alp_data {
unit *target;
} alp_data;
static void
alp_init(attrib * a)
static void alp_init(attrib * a)
{
a->data.v = calloc(sizeof(alp_data), 1);
}
static void
alp_done(attrib * a)
static void alp_done(attrib * a)
{
free(a->data.v);
}
static int
alp_verify(attrib * a)
static int alp_verify(attrib * a)
{
alp_data *ad = (alp_data *) a->data.v;
if (ad->mage && ad->target) return 1;
if (ad->mage && ad->target)
return 1;
return 0; /* remove the attribute */
}
@ -72,16 +71,19 @@ static void
alp_write(const attrib * a, const void *owner, struct storage *store)
{
alp_data *ad = (alp_data *) a->data.v;
write_unit_reference(ad->mage, store);
write_unit_reference(ad->target, store);
}
static int
alp_read(attrib * a, void * owner, struct storage * store)
static int alp_read(attrib * a, void *owner, struct storage *store)
{
alp_data *ad = (alp_data *) a->data.v;
int rm = read_reference(&ad->mage, store, read_unit_reference, resolve_unit);
int rt = read_reference(&ad->target, store, read_unit_reference, resolve_unit);
int rt =
read_reference(&ad->target, store, read_unit_reference, resolve_unit);
if (rt == 0 && rm == 0 && (!ad->target || !ad->mage)) {
/* the target or mage disappeared. */
return AT_READ_FAIL;
@ -99,16 +101,22 @@ static attrib_type at_alp = {
ATF_UNIQUE
};
int
sp_summon_alp(struct castorder *co)
int sp_summon_alp(struct castorder *co)
{
unit *alp, *opfer;
region *r = co->rt;
unit *mage = co->magician.u;
int cast_level = co->level;
spellparameter *pa = co->par;
const struct race *rc = new_race[RC_ALP];
struct faction *f = get_monsters();
struct message *msg;
opfer = pa->param[0]->data.u;
@ -123,7 +131,9 @@ sp_summon_alp(struct castorder *co)
{
attrib *a = a_add(&alp->attribs, a_new(&at_alp));
alp_data *ad = (alp_data *) a->data.v;
ad->mage = mage;
ad->target = opfer;
}
@ -144,15 +154,20 @@ sp_summon_alp(struct castorder *co)
}
void
alp_findet_opfer(unit *alp, region *r)
void alp_findet_opfer(unit * alp, region * r)
{
curse *c;
attrib *a = a_find(alp->attribs, &at_alp);
alp_data *ad = (alp_data *) a->data.v;
unit *mage = ad->mage;
unit *opfer = ad->target;
double effect;
message *msg;
assert(opfer);
@ -173,7 +188,9 @@ alp_findet_opfer(unit *alp, region *r)
/* Alp umwandeln in Curse */
effect = -2;
c = create_curse(mage, &opfer->attribs, ct_find("worse"), 2, 2, effect, opfer->number);
c =
create_curse(mage, &opfer->attribs, ct_find("worse"), 2, 2, effect,
opfer->number);
/* solange es noch keine spezielle alp-Antimagie gibt, reagiert der
* auch auf normale */
set_number(alp, 0);
@ -182,16 +199,15 @@ alp_findet_opfer(unit *alp, region *r)
add_trigger(&mage->attribs, "destroy", trigger_removecurse(c, opfer));
}
void
register_alp(void)
void register_alp(void)
{
at_register(&at_alp);
}
unit *
alp_target(unit *alp)
unit *alp_target(unit * alp)
{
alp_data *ad;
unit *target = NULL;
attrib *a = a_find(alp->attribs, &at_alp);

18
src/spells/buildingcurse.c
View file

@ -34,8 +34,8 @@
#include <assert.h>
static message *
cinfo_building(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_building(const void *obj, typ_t typ, const curse * c,
int self)
{
unused(typ);
assert(typ == TYP_BUILDING);
@ -49,18 +49,22 @@ cinfo_building(const void * obj, typ_t typ, const curse *c, int self)
/* CurseInfo mit Spezialabfragen */
/* C_MAGICWALLS*/
static message *
cinfo_magicrunes(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_magicrunes(const void *obj, typ_t typ, const curse * c,
int self)
{
message *msg = NULL;
if (typ == TYP_BUILDING) {
building *b;
b = (building *) obj;
if (self != 0) {
msg = msg_message("curseinfo::magicrunes_building", "building id", b, c->no);
msg =
msg_message("curseinfo::magicrunes_building", "building id", b, c->no);
}
} else if (typ == TYP_SHIP) {
ship *sh;
sh = (ship *) obj;
if (self != 0) {
msg = msg_message("curseinfo::magicrunes_ship", "ship id", sh, c->no);
@ -69,6 +73,7 @@ cinfo_magicrunes(const void * obj, typ_t typ, const curse *c, int self)
return msg;
}
static struct curse_type ct_magicrunes = { "magicrunes",
CURSETYP_NORM, 0, M_SUMEFFECT, cinfo_magicrunes
};
@ -89,8 +94,7 @@ static struct curse_type ct_nocostbuilding = { "nocostbuilding",
};
void
register_buildingcurse(void)
void register_buildingcurse(void)
{
ct_register(&ct_magicwalls);
ct_register(&ct_strongwall);

501
src/spells/combatspells.c
View file

File diff suppressed because it is too large Load diff

90
src/spells/combatspells.h
View file

@ -20,36 +20,66 @@ extern "C" {
struct fighter;
/* Kampfzauber */
extern int sp_fumbleshield(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_shadowknights(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_combatrosthauch(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_kampfzauber(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_healing(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_keeploot(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_reanimate(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_chaosrow(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_flee(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_berserk(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_tiredsoldiers(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_reeling_arrows(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_denyattack(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_sleep(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_windshield(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_strong_wall(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_petrify(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_hero(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_frighten(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_mindblast(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_mindblast_temp(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_speed(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_wolfhowl(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_dragonodem(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_reduceshield(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_armorshield(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_stun(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_undeadhero(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_shadowcall(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_immolation(struct fighter * fi, int level, double power, struct spell * sp);
extern int sp_fumbleshield(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_shadowknights(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_combatrosthauch(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_kampfzauber(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_healing(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_keeploot(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_reanimate(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_chaosrow(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_flee(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_berserk(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_tiredsoldiers(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_reeling_arrows(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_denyattack(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_sleep(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_windshield(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_strong_wall(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_petrify(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_hero(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_frighten(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_mindblast(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_mindblast_temp(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_speed(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_wolfhowl(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_dragonodem(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_reduceshield(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_armorshield(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_stun(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_undeadhero(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_shadowcall(struct fighter *fi, int level, double power,
struct spell *sp);
extern int sp_immolation(struct fighter *fi, int level, double power,
struct spell *sp);
#ifdef __cplusplus
}

44
src/spells/regioncurse.c
View file

@ -41,8 +41,8 @@
/*
* godcursezone
*/
static message *
cinfo_cursed_by_the_gods(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_cursed_by_the_gods(const void *obj, typ_t typ,
const curse * c, int self)
{
region *r = (region *) obj;
@ -58,7 +58,8 @@ cinfo_cursed_by_the_gods(const void * obj, typ_t typ, const curse *c, int self)
static struct curse_type ct_godcursezone = {
"godcursezone",
CURSETYP_NORM, CURSE_IMMUNE|CURSE_ISNEW, (NO_MERGE), cinfo_cursed_by_the_gods,
CURSETYP_NORM, CURSE_IMMUNE | CURSE_ISNEW, (NO_MERGE),
cinfo_cursed_by_the_gods,
};
@ -66,8 +67,8 @@ static struct curse_type ct_godcursezone = {
/*
* C_GBDREAM
*/
static message *
cinfo_dreamcurse(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_dreamcurse(const void *obj, typ_t typ, const curse * c,
int self)
{
unused(self);
unused(typ);
@ -90,8 +91,8 @@ static struct curse_type ct_gbdream = {
* C_MAGICSTREET
* erzeugt Straßennetz
*/
static message *
cinfo_magicstreet(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_magicstreet(const void *obj, typ_t typ, const curse * c,
int self)
{
unused(typ);
unused(self);
@ -113,8 +114,8 @@ static struct curse_type ct_magicstreet = {
/* --------------------------------------------------------------------- */
static message *
cinfo_antimagiczone(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_antimagiczone(const void *obj, typ_t typ, const curse * c,
int self)
{
unused(typ);
unused(self);
@ -131,10 +132,13 @@ cinfo_antimagiczone(const void * obj, typ_t typ, const curse *c, int self)
/* alle Magier können eine Antimagiezone wahrnehmen */
static int
cansee_antimagiczone(const struct faction *viewer, const void * obj, typ_t typ, const curse *c, int self)
cansee_antimagiczone(const struct faction *viewer, const void *obj, typ_t typ,
const curse * c, int self)
{
region *r;
unit *u = NULL;
unit *mage = c->magician;
unused(typ);
@ -154,6 +158,7 @@ cansee_antimagiczone(const struct faction *viewer, const void * obj, typ_t typ,
}
return self;
}
static struct curse_type ct_antimagiczone = {
"antimagiczone",
CURSETYP_NORM, 0, (M_DURATION | M_VIGOUR),
@ -161,8 +166,8 @@ static struct curse_type ct_antimagiczone = {
};
/* --------------------------------------------------------------------- */
static message *
cinfo_farvision(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_farvision(const void *obj, typ_t typ, const curse * c,
int self)
{
unused(typ);
unused(obj);
@ -191,6 +196,7 @@ static struct curse_type ct_fogtrap = {
CURSETYP_NORM, 0, (M_DURATION | M_VIGOUR),
cinfo_simple
};
static struct curse_type ct_maelstrom = {
"maelstrom",
CURSETYP_NORM, CURSE_ISNEW, (M_DURATION | M_VIGOUR),
@ -208,11 +214,13 @@ static struct curse_type ct_drought = {
CURSETYP_NORM, 0, (M_DURATION | M_VIGOUR),
cinfo_simple
};
static struct curse_type ct_badlearn = {
"badlearn",
CURSETYP_NORM, CURSE_ISNEW, (M_DURATION | M_VIGOUR),
cinfo_simple
};
/* Trübsal-Zauber */
static struct curse_type ct_depression = {
"depression",
@ -226,18 +234,21 @@ static struct curse_type ct_astralblock = {
CURSETYP_NORM, 0, NO_MERGE,
cinfo_simple
};
/* Unterhaltungsanteil vermehren */
static struct curse_type ct_generous = {
"generous",
CURSETYP_NORM, 0, (M_DURATION | M_VIGOUR | M_MAXEFFECT),
cinfo_simple
};
/* verhindert Attackiere regional */
static struct curse_type ct_peacezone = {
"peacezone",
CURSETYP_NORM, 0, NO_MERGE,
cinfo_simple
};
/* erniedigt Magieresistenz von nicht-aliierten Einheiten, wirkt nur 1x
* pro Einheit */
static struct curse_type ct_badmagicresistancezone = {
@ -245,6 +256,7 @@ static struct curse_type ct_badmagicresistancezone = {
CURSETYP_NORM, 0, NO_MERGE,
cinfo_simple
};
/* erhöht Magieresistenz von aliierten Einheiten, wirkt nur 1x pro
* Einheit */
static struct curse_type ct_goodmagicresistancezone = {
@ -252,16 +264,19 @@ static struct curse_type ct_goodmagicresistancezone = {
CURSETYP_NORM, 0, NO_MERGE,
cinfo_simple
};
static struct curse_type ct_riotzone = {
"riotzone",
CURSETYP_NORM, 0, (M_DURATION),
cinfo_simple
};
static struct curse_type ct_holyground = {
"holyground",
CURSETYP_NORM, CURSE_NOAGE, (M_VIGOUR_ADD),
cinfo_simple
};
static struct curse_type ct_healing = {
"healingzone",
CURSETYP_NORM, 0, (M_VIGOUR | M_DURATION),
@ -269,8 +284,7 @@ static struct curse_type ct_healing = {
};
void
register_regioncurse(void)
void register_regioncurse(void)
{
ct_register(&ct_fogtrap);
ct_register(&ct_antimagiczone);
@ -292,5 +306,3 @@ register_regioncurse(void)
ct_register(&ct_holyground);
ct_register(&ct_healing);
}

43
src/spells/shipcurse.c
View file

@ -35,8 +35,7 @@
#include <assert.h>
message *
cinfo_ship(const void * obj, typ_t typ, const curse *c, int self)
message *cinfo_ship(const void *obj, typ_t typ, const curse * c, int self)
{
message *msg;
@ -58,8 +57,8 @@ cinfo_ship(const void * obj, typ_t typ, const curse *c, int self)
/* CurseInfo mit Spezialabfragen */
/* C_SHIP_NODRIFT */
static message *
cinfo_shipnodrift(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_shipnodrift(const void *obj, typ_t typ, const curse * c,
int self)
{
ship *sh = (ship *) obj;
@ -67,7 +66,8 @@ cinfo_shipnodrift(const void * obj, typ_t typ, const curse *c, int self)
assert(typ == TYP_SHIP);
if (self != 0) {
return msg_message("curseinfo::shipnodrift_1", "ship duration id", sh, c->duration, c->no);
return msg_message("curseinfo::shipnodrift_1", "ship duration id", sh,
c->duration, c->no);
}
return msg_message("curseinfo::shipnodrift_0", "ship id", sh, c->no);
}
@ -76,8 +76,10 @@ static struct curse_type ct_stormwind = { "stormwind",
CURSETYP_NORM, 0, NO_MERGE, cinfo_ship
};
static int flyingship_read(storage * store, curse * c, void * target) {
static int flyingship_read(storage * store, curse * c, void *target)
{
ship *sh = (ship *) target;
c->data.v = sh;
if (store->version < FOSS_VERSION) {
sh->flags |= SF_FLYING;
@ -87,14 +89,19 @@ static int flyingship_read(storage * store, curse * c, void * target) {
return 0;
}
static int flyingship_write(storage * store, const curse * c, const void * target) {
static int flyingship_write(storage * store, const curse * c,
const void *target)
{
const ship *sh = (const ship *)target;
assert(sh->flags & SF_FLYING);
return 0;
}
static int flyingship_age(curse * c) {
static int flyingship_age(curse * c)
{
ship *sh = (ship *) c->data.v;
if (sh && c->duration == 1) {
freset(sh, SF_FLYING);
return 1;
@ -103,19 +110,22 @@ static int flyingship_age(curse * c) {
}
static struct curse_type ct_flyingship = { "flyingship",
CURSETYP_NORM, 0, NO_MERGE, cinfo_ship, NULL, flyingship_read, flyingship_write, NULL, flyingship_age
CURSETYP_NORM, 0, NO_MERGE, cinfo_ship, NULL, flyingship_read,
flyingship_write, NULL, flyingship_age
};
static struct curse_type ct_nodrift = { "nodrift",
CURSETYP_NORM, 0, (M_DURATION | M_VIGOUR), cinfo_shipnodrift
};
static struct curse_type ct_shipspeedup = { "shipspeedup",
CURSETYP_NORM, 0, 0, cinfo_ship
};
curse *
shipcurse_flyingship(ship* sh, unit * mage, double power, int duration)
curse *shipcurse_flyingship(ship * sh, unit * mage, double power, int duration)
{
static const curse_type *ct_flyingship = NULL;
if (!ct_flyingship) {
ct_flyingship = ct_find("flyingship");
assert(ct_flyingship);
@ -126,7 +136,8 @@ shipcurse_flyingship(ship* sh, unit * mage, double power, int duration)
return NULL;
} else {
/* mit C_SHIP_NODRIFT haben wir kein Problem */
curse * c = create_curse(mage, &sh->attribs, ct_flyingship, power, duration, 0.0, 0);
curse *c =
create_curse(mage, &sh->attribs, ct_flyingship, power, duration, 0.0, 0);
c->data.v = sh;
if (c && c->duration > 0) {
sh->flags |= SF_FLYING;
@ -135,22 +146,20 @@ shipcurse_flyingship(ship* sh, unit * mage, double power, int duration)
}
}
int
levitate_ship(ship * sh, unit * mage, double power, int duration)
int levitate_ship(ship * sh, unit * mage, double power, int duration)
{
curse *c = shipcurse_flyingship(sh, mage, power, duration);
if (c) {
return c->no;
}
return 0;
}
void
register_shipcurse(void)
void register_shipcurse(void)
{
ct_register(&ct_stormwind);
ct_register(&ct_flyingship);
ct_register(&ct_nodrift);
ct_register(&ct_shipspeedup);
}

9
src/spells/shipcurse.h
View file

@ -19,10 +19,13 @@ extern "C" {
struct locale;
struct message;
extern struct message * cinfo_ship(const void * obj, typ_t typ, const struct curse *c, int self);
extern struct message *cinfo_ship(const void *obj, typ_t typ,
const struct curse *c, int self);
extern void register_shipcurse(void);
extern struct curse * shipcurse_flyingship(struct ship* sh, struct unit * mage, double power, int duration);
int levitate_ship(struct ship * sh, struct unit * mage, double power, int duration);
extern struct curse *shipcurse_flyingship(struct ship *sh, struct unit *mage,
double power, int duration);
int levitate_ship(struct ship *sh, struct unit *mage, double power,
int duration);
#ifdef __cplusplus
}

2608
src/spells/spells.c
View file

File diff suppressed because it is too large Load diff

88
src/spells/unitcurse.c
View file

@ -43,10 +43,11 @@
* C_AURA
*/
/* erhöht/senkt regeneration und maxaura um effect% */
static message *
cinfo_auraboost(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_auraboost(const void *obj, typ_t typ, const curse * c,
int self)
{
struct unit *u = (struct unit *)obj;
unused(typ);
assert(typ == TYP_UNIT);
@ -59,6 +60,7 @@ cinfo_auraboost(const void * obj, typ_t typ, const curse *c, int self)
}
return NULL;
}
static struct curse_type ct_auraboost = {
"auraboost",
CURSETYP_NORM, CURSE_SPREADMODULO, (NO_MERGE),
@ -75,20 +77,23 @@ static struct curse_type ct_magicboost = {
/*
* C_SLAVE
*/
static message *
cinfo_slave(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_slave(const void *obj, typ_t typ, const curse * c,
int self)
{
unit *u;
unused(typ);
assert(typ == TYP_UNIT);
u = (unit *) obj;
if (self != 0) {
return msg_message("curseinfo::slave_1", "unit duration id", u, c->duration, c->no);
return msg_message("curseinfo::slave_1", "unit duration id", u, c->duration,
c->no);
}
return NULL;
}
static struct curse_type ct_slavery = { "slavery",
CURSETYP_NORM, 0, NO_MERGE,
cinfo_slave
@ -98,18 +103,20 @@ static struct curse_type ct_slavery = { "slavery",
/*
* C_CALM
*/
static message *
cinfo_calm(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_calm(const void *obj, typ_t typ, const curse * c,
int self)
{
unused(typ);
assert(typ == TYP_UNIT);
if (c->magician && c->magician->faction) {
faction *f = c->magician->faction;
unit *u = (unit *) obj;
if (f == NULL || self == 0) {
const struct race *rc = u_irace(c->magician);
return msg_message("curseinfo::calm_0", "unit race id", u, rc, c->no);
}
return msg_message("curseinfo::calm_1", "unit faction id", u, f, c->no);
@ -127,18 +134,21 @@ static struct curse_type ct_calmmonster = {
/*
* C_SPEED
*/
static message *
cinfo_speed(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_speed(const void *obj, typ_t typ, const curse * c,
int self)
{
unused(typ);
assert(typ == TYP_UNIT);
if (self != 0) {
unit *u = (unit *) obj;
return msg_message("curseinfo::speed_1", "unit number duration id", u, c->data.i, c->duration, c->no);
return msg_message("curseinfo::speed_1", "unit number duration id", u,
c->data.i, c->duration, c->no);
}
return NULL;
}
static struct curse_type ct_speed = {
"speed",
CURSETYP_UNIT, CURSE_SPREADNEVER, M_MEN,
@ -149,15 +159,16 @@ static struct curse_type ct_speed = {
/*
* C_ORC
*/
message *
cinfo_unit(const void * obj, typ_t typ, const curse *c, int self)
message *cinfo_unit(const void *obj, typ_t typ, const curse * c, int self)
{
unused(typ);
assert(typ == TYP_UNIT);
if (self != 0) {
unit *u = (unit *) obj;
return msg_message(mkname("curseinfo", c->type->cname), "unit id", u, c->no);
return msg_message(mkname("curseinfo", c->type->cname), "unit id", u,
c->no);
}
return NULL;
}
@ -172,18 +183,21 @@ static struct curse_type ct_orcish = {
/*
* C_KAELTESCHUTZ
*/
static message *
cinfo_kaelteschutz(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_kaelteschutz(const void *obj, typ_t typ, const curse * c,
int self)
{
unused(typ);
assert(typ == TYP_UNIT);
if (self != 0) {
unit *u = (unit *) obj;
return msg_message("curseinfo::warmth_1", "unit number id", u, get_cursedmen(u, c), c->no);
return msg_message("curseinfo::warmth_1", "unit number id", u,
get_cursedmen(u, c), c->no);
}
return NULL;
}
static struct curse_type ct_insectfur = {
"insectfur",
CURSETYP_UNIT, CURSE_SPREADMODULO, (M_MEN | M_DURATION),
@ -194,8 +208,8 @@ static struct curse_type ct_insectfur = {
/*
* C_SPARKLE
*/
static message *
cinfo_sparkle(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_sparkle(const void *obj, typ_t typ, const curse * c,
int self)
{
const char *effects[] = {
NULL, /* end grau */
@ -224,25 +238,33 @@ cinfo_sparkle(const void * obj, typ_t typ, const curse *c, int self)
NULL, /* end draig */
};
int m, begin = 0, end = 0;
unit *u;
unused(typ);
assert(typ == TYP_UNIT);
u = (unit *) obj;
if (!c->magician || !c->magician->faction) return NULL;
if (!c->magician || !c->magician->faction)
return NULL;
for (m = 0; m != c->magician->faction->magiegebiet; ++m) {
while (effects[end]!=NULL) ++end;
while (effects[end] != NULL)
++end;
begin = end + 1;
end = begin;
}
while (effects[end]!=NULL) ++end;
if (end==begin) return NULL;
while (effects[end] != NULL)
++end;
if (end == begin)
return NULL;
else {
int index = begin + curse_geteffect_int(c) % (end - begin);
return msg_message(mkname("curseinfo", effects[index]), "unit id", u, c->no);
return msg_message(mkname("curseinfo", effects[index]), "unit id", u,
c->no);
}
}
@ -274,11 +296,14 @@ static struct curse_type ct_worse = {
static struct curse_type ct_itemcloak = {
"itemcloak", CURSETYP_UNIT, CURSE_SPREADNEVER, M_DURATION, cinfo_unit
};
/* ------------------------------------------------------------- */
static struct curse_type ct_fumble = {
"fumble", CURSETYP_NORM, CURSE_SPREADNEVER|CURSE_ONLYONE, NO_MERGE, cinfo_unit
"fumble", CURSETYP_NORM, CURSE_SPREADNEVER | CURSE_ONLYONE, NO_MERGE,
cinfo_unit
};
/* ------------------------------------------------------------- */
@ -296,12 +321,13 @@ static struct curse_type ct_magicresistance = {
* C_SKILL
*/
static int
read_skill(struct storage * store, curse * c, void * target)
static int read_skill(struct storage *store, curse * c, void *target)
{
int skill;
if (store->version < CURSETYPE_VERSION) {
int men;
skill = store->r_int(store);
men = store->r_int(store);
} else {
@ -318,14 +344,16 @@ write_skill(struct storage * store, const curse * c, const void * target)
return 0;
}
static message *
cinfo_skillmod(const void * obj, typ_t typ, const curse *c, int self)
static message *cinfo_skillmod(const void *obj, typ_t typ, const curse * c,
int self)
{
unused(typ);
if (self != 0) {
unit *u = (unit *) obj;
int sk = c->data.i;
if (c->effect > 0) {
return msg_message("curseinfo::skill_1", "unit skill id", u, sk, c->no);
} else if (c->effect < 0) {
@ -341,8 +369,7 @@ static struct curse_type ct_skillmod = {
};
/* ------------------------------------------------------------- */
void
register_unitcurse(void)
void register_unitcurse(void)
{
ct_register(&ct_auraboost);
ct_register(&ct_magicboost);
@ -360,4 +387,3 @@ register_unitcurse(void)
ct_register(&ct_oldrace);
ct_register(&ct_magicresistance);
}

3
src/spells/unitcurse.h
View file

@ -19,7 +19,8 @@ extern "C" {
struct curse;
struct message;
extern struct message * cinfo_unit(const void * obj, typ_t typ, const struct curse *c, int self);
extern struct message *cinfo_unit(const void *obj, typ_t typ,
const struct curse *c, int self);
extern void register_unitcurse(void);