forked from github/server
added a test: region owners can set PAY NOT <id> for empty buildings if they are in region_owner_pay_building.
This commit is contained in:
Enno Rehling
parent
d7899a392a
commit
484e52d491
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
Copyright (c) 1998-2010, Enno Rehling <enno@eressea.de>
|
||||
Katja Zedel <katze@felidae.kn-bremen.de
|
||||
Christian Schlittchen <corwin@amber.kn-bremen.de>
|
||||
Katja Zedel <katze@felidae.kn-bremen.de
|
||||
Christian Schlittchen <corwin@amber.kn-bremen.de>
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted, provided that the above
|
||||
|
|
@ -57,8 +57,8 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|||
#include <attributes/matmod.h>
|
||||
|
||||
typedef struct building_typelist {
|
||||
struct building_typelist *next;
|
||||
building_type *type;
|
||||
struct building_typelist *next;
|
||||
building_type *type;
|
||||
} building_typelist;
|
||||
|
||||
quicklist *buildingtypes = NULL;
|
||||
|
|
@ -66,17 +66,17 @@ quicklist *buildingtypes = NULL;
|
|||
/* Returns a building type for the (internal) name */
|
||||
static building_type *bt_find_i(const char *name)
|
||||
{
|
||||
quicklist *ql;
|
||||
int qi;
|
||||
quicklist *ql;
|
||||
int qi;
|
||||
|
||||
assert(name);
|
||||
assert(name);
|
||||
|
||||
for (qi = 0, ql = buildingtypes; ql; ql_advance(&ql, &qi, 1)) {
|
||||
building_type *btype = (building_type *) ql_get(ql, qi);
|
||||
if (strcmp(btype->_name, name) == 0)
|
||||
return btype;
|
||||
}
|
||||
return NULL;
|
||||
for (qi = 0, ql = buildingtypes; ql; ql_advance(&ql, &qi, 1)) {
|
||||
building_type *btype = (building_type *)ql_get(ql, qi);
|
||||
if (strcmp(btype->_name, name) == 0)
|
||||
return btype;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const building_type *bt_find(const char *name)
|
||||
|
|
@ -86,10 +86,10 @@ const building_type *bt_find(const char *name)
|
|||
|
||||
void bt_register(building_type * type)
|
||||
{
|
||||
if (type->init) {
|
||||
type->init(type);
|
||||
}
|
||||
ql_push(&buildingtypes, (void *)type);
|
||||
if (type->init) {
|
||||
type->init(type);
|
||||
}
|
||||
ql_push(&buildingtypes, (void *)type);
|
||||
}
|
||||
|
||||
void free_buildingtypes(void) {
|
||||
|
|
@ -100,36 +100,36 @@ void free_buildingtypes(void) {
|
|||
|
||||
building_type *bt_get_or_create(const char *name)
|
||||
{
|
||||
if (name != NULL) {
|
||||
building_type *btype = bt_find_i(name);
|
||||
if (btype == NULL) {
|
||||
btype = calloc(sizeof(building_type), 1);
|
||||
btype->_name = _strdup(name);
|
||||
bt_register(btype);
|
||||
if (name != NULL) {
|
||||
building_type *btype = bt_find_i(name);
|
||||
if (btype == NULL) {
|
||||
btype = calloc(sizeof(building_type), 1);
|
||||
btype->_name = _strdup(name);
|
||||
bt_register(btype);
|
||||
}
|
||||
return btype;
|
||||
}
|
||||
return btype;
|
||||
}
|
||||
return NULL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int buildingcapacity(const building * b)
|
||||
{
|
||||
if (b->type->capacity >= 0) {
|
||||
if (b->type->maxcapacity >= 0) {
|
||||
return _min(b->type->maxcapacity, b->size * b->type->capacity);
|
||||
if (b->type->capacity >= 0) {
|
||||
if (b->type->maxcapacity >= 0) {
|
||||
return _min(b->type->maxcapacity, b->size * b->type->capacity);
|
||||
}
|
||||
return b->size * b->type->capacity;
|
||||
}
|
||||
return b->size * b->type->capacity;
|
||||
}
|
||||
if (b->size >= b->type->maxsize) {
|
||||
if (b->type->maxcapacity >= 0) {
|
||||
return b->type->maxcapacity;
|
||||
if (b->size >= b->type->maxsize) {
|
||||
if (b->type->maxcapacity >= 0) {
|
||||
return b->type->maxcapacity;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
attrib_type at_building_generic_type = {
|
||||
"building_generic_type", NULL, NULL, NULL, a_writestring, a_readstring,
|
||||
"building_generic_type", NULL, NULL, NULL, a_writestring, a_readstring,
|
||||
ATF_UNIQUE
|
||||
};
|
||||
|
||||
|
|
@ -162,113 +162,113 @@ const char *buildingtype(const building_type * btype, const building * b, int bs
|
|||
static building *buildhash[BMAXHASH];
|
||||
void bhash(building * b)
|
||||
{
|
||||
building *old = buildhash[b->no % BMAXHASH];
|
||||
building *old = buildhash[b->no % BMAXHASH];
|
||||
|
||||
buildhash[b->no % BMAXHASH] = b;
|
||||
b->nexthash = old;
|
||||
buildhash[b->no % BMAXHASH] = b;
|
||||
b->nexthash = old;
|
||||
}
|
||||
|
||||
void bunhash(building * b)
|
||||
{
|
||||
building **show;
|
||||
building **show;
|
||||
|
||||
for (show = &buildhash[b->no % BMAXHASH]; *show; show = &(*show)->nexthash) {
|
||||
if ((*show)->no == b->no)
|
||||
break;
|
||||
}
|
||||
if (*show) {
|
||||
assert(*show == b);
|
||||
*show = (*show)->nexthash;
|
||||
b->nexthash = 0;
|
||||
}
|
||||
for (show = &buildhash[b->no % BMAXHASH]; *show; show = &(*show)->nexthash) {
|
||||
if ((*show)->no == b->no)
|
||||
break;
|
||||
}
|
||||
if (*show) {
|
||||
assert(*show == b);
|
||||
*show = (*show)->nexthash;
|
||||
b->nexthash = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static building *bfindhash(int i)
|
||||
{
|
||||
building *old;
|
||||
building *old;
|
||||
|
||||
for (old = buildhash[i % BMAXHASH]; old; old = old->nexthash)
|
||||
if (old->no == i)
|
||||
return old;
|
||||
return 0;
|
||||
for (old = buildhash[i % BMAXHASH]; old; old = old->nexthash)
|
||||
if (old->no == i)
|
||||
return old;
|
||||
return 0;
|
||||
}
|
||||
|
||||
building *findbuilding(int i)
|
||||
{
|
||||
return bfindhash(i);
|
||||
return bfindhash(i);
|
||||
}
|
||||
|
||||
/* ** old building types ** */
|
||||
|
||||
static int sm_smithy(const unit * u, const region * r, skill_t sk, int value)
|
||||
{ /* skillmod */
|
||||
if (sk == SK_WEAPONSMITH || sk == SK_ARMORER) {
|
||||
if (u->region == r)
|
||||
return value + 1;
|
||||
}
|
||||
return value;
|
||||
if (sk == SK_WEAPONSMITH || sk == SK_ARMORER) {
|
||||
if (u->region == r)
|
||||
return value + 1;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
static int mm_smithy(const unit * u, const resource_type * rtype, int value)
|
||||
{ /* material-mod */
|
||||
if (rtype == get_resourcetype(R_IRON))
|
||||
return value * 2;
|
||||
return value;
|
||||
if (rtype == get_resourcetype(R_IRON))
|
||||
return value * 2;
|
||||
return value;
|
||||
}
|
||||
|
||||
static void init_smithy(struct building_type *bt)
|
||||
{
|
||||
a_add(&bt->attribs, make_skillmod(NOSKILL, SMF_PRODUCTION, sm_smithy, 1.0,
|
||||
0));
|
||||
a_add(&bt->attribs, make_matmod(mm_smithy));
|
||||
a_add(&bt->attribs, make_skillmod(NOSKILL, SMF_PRODUCTION, sm_smithy, 1.0,
|
||||
0));
|
||||
a_add(&bt->attribs, make_matmod(mm_smithy));
|
||||
}
|
||||
|
||||
static const char *castle_name_i(const struct building_type *btype,
|
||||
const struct building *b, int bsize, const char *fname[])
|
||||
const struct building *b, int bsize, const char *fname[])
|
||||
{
|
||||
int i = bt_effsize(btype, b, bsize);
|
||||
int i = bt_effsize(btype, b, bsize);
|
||||
|
||||
return fname[i];
|
||||
return fname[i];
|
||||
}
|
||||
|
||||
static const char *castle_name_2(const struct building_type *btype,
|
||||
const struct building *b, int bsize)
|
||||
const struct building *b, int bsize)
|
||||
{
|
||||
const char *fname[] = {
|
||||
"site",
|
||||
"fortification",
|
||||
"tower",
|
||||
"castle",
|
||||
"fortress",
|
||||
"citadel"
|
||||
};
|
||||
return castle_name_i(btype, b, bsize, fname);
|
||||
const char *fname[] = {
|
||||
"site",
|
||||
"fortification",
|
||||
"tower",
|
||||
"castle",
|
||||
"fortress",
|
||||
"citadel"
|
||||
};
|
||||
return castle_name_i(btype, b, bsize, fname);
|
||||
}
|
||||
|
||||
static const char *castle_name(const struct building_type *btype,
|
||||
const struct building *b, int bsize)
|
||||
const struct building *b, int bsize)
|
||||
{
|
||||
const char *fname[] = {
|
||||
"site",
|
||||
"tradepost",
|
||||
"fortification",
|
||||
"tower",
|
||||
"castle",
|
||||
"fortress",
|
||||
"citadel"
|
||||
};
|
||||
return castle_name_i(btype, b, bsize, fname);
|
||||
const char *fname[] = {
|
||||
"site",
|
||||
"tradepost",
|
||||
"fortification",
|
||||
"tower",
|
||||
"castle",
|
||||
"fortress",
|
||||
"citadel"
|
||||
};
|
||||
return castle_name_i(btype, b, bsize, fname);
|
||||
}
|
||||
|
||||
static const char *fort_name(const struct building_type *btype,
|
||||
const struct building *b, int bsize)
|
||||
const struct building *b, int bsize)
|
||||
{
|
||||
const char *fname[] = {
|
||||
"scaffolding",
|
||||
"guardhouse",
|
||||
"guardtower",
|
||||
};
|
||||
return castle_name_i(btype, b, bsize, fname);
|
||||
const char *fname[] = {
|
||||
"scaffolding",
|
||||
"guardhouse",
|
||||
"guardtower",
|
||||
};
|
||||
return castle_name_i(btype, b, bsize, fname);
|
||||
}
|
||||
|
||||
/* for finding out what was meant by a particular building string */
|
||||
|
|
@ -278,132 +278,132 @@ static local_names *bnames;
|
|||
/* Find the building type for a given localized name (as seen by the user). Useful for parsing
|
||||
* orders. The inverse of locale_string(lang, btype->_name), sort of. */
|
||||
const building_type *findbuildingtype(const char *name,
|
||||
const struct locale *lang)
|
||||
const struct locale *lang)
|
||||
{
|
||||
variant type;
|
||||
local_names *bn = bnames;
|
||||
variant type;
|
||||
local_names *bn = bnames;
|
||||
|
||||
while (bn) {
|
||||
if (bn->lang == lang)
|
||||
break;
|
||||
bn = bn->next;
|
||||
}
|
||||
if (!bn) {
|
||||
quicklist *ql = buildingtypes;
|
||||
int qi;
|
||||
|
||||
bn = (local_names *)calloc(sizeof(local_names), 1);
|
||||
bn->next = bnames;
|
||||
bn->lang = lang;
|
||||
|
||||
for (qi = 0, ql = buildingtypes; ql; ql_advance(&ql, &qi, 1)) {
|
||||
building_type *btype = (building_type *) ql_get(ql, qi);
|
||||
|
||||
const char *n = locale_string(lang, btype->_name);
|
||||
type.v = (void *)btype;
|
||||
addtoken(&bn->names, n, type);
|
||||
while (bn) {
|
||||
if (bn->lang == lang)
|
||||
break;
|
||||
bn = bn->next;
|
||||
}
|
||||
bnames = bn;
|
||||
}
|
||||
if (findtoken(bn->names, name, &type) == E_TOK_NOMATCH)
|
||||
return NULL;
|
||||
return (const building_type *)type.v;
|
||||
if (!bn) {
|
||||
quicklist *ql = buildingtypes;
|
||||
int qi;
|
||||
|
||||
bn = (local_names *)calloc(sizeof(local_names), 1);
|
||||
bn->next = bnames;
|
||||
bn->lang = lang;
|
||||
|
||||
for (qi = 0, ql = buildingtypes; ql; ql_advance(&ql, &qi, 1)) {
|
||||
building_type *btype = (building_type *)ql_get(ql, qi);
|
||||
|
||||
const char *n = locale_string(lang, btype->_name);
|
||||
type.v = (void *)btype;
|
||||
addtoken(&bn->names, n, type);
|
||||
}
|
||||
bnames = bn;
|
||||
}
|
||||
if (findtoken(bn->names, name, &type) == E_TOK_NOMATCH)
|
||||
return NULL;
|
||||
return (const building_type *)type.v;
|
||||
}
|
||||
|
||||
static int eressea_building_protection(building * b, unit * u)
|
||||
{
|
||||
int beff = buildingeffsize(b, false) - 1;
|
||||
/* -1 because the tradepost has no protection value */
|
||||
int beff = buildingeffsize(b, false) - 1;
|
||||
/* -1 because the tradepost has no protection value */
|
||||
|
||||
return beff;
|
||||
return beff;
|
||||
}
|
||||
|
||||
static int meropis_building_protection(building * b, unit * u)
|
||||
{
|
||||
return 2;
|
||||
return 2;
|
||||
}
|
||||
|
||||
void register_buildings(void)
|
||||
{
|
||||
register_function((pf_generic) & eressea_building_protection,
|
||||
"eressea_building_protection");
|
||||
register_function((pf_generic) & meropis_building_protection,
|
||||
"meropis_building_protection");
|
||||
register_function((pf_generic) & init_smithy, "init_smithy");
|
||||
register_function((pf_generic) & castle_name, "castle_name");
|
||||
register_function((pf_generic) & castle_name_2, "castle_name_2");
|
||||
register_function((pf_generic) & fort_name, "fort_name");
|
||||
register_function((pf_generic)& eressea_building_protection,
|
||||
"eressea_building_protection");
|
||||
register_function((pf_generic)& meropis_building_protection,
|
||||
"meropis_building_protection");
|
||||
register_function((pf_generic)& init_smithy, "init_smithy");
|
||||
register_function((pf_generic)& castle_name, "castle_name");
|
||||
register_function((pf_generic)& castle_name_2, "castle_name_2");
|
||||
register_function((pf_generic)& fort_name, "fort_name");
|
||||
}
|
||||
|
||||
void write_building_reference(const struct building *b, struct storage *store)
|
||||
{
|
||||
WRITE_INT(store, (b && b->region) ? b->no : 0);
|
||||
WRITE_INT(store, (b && b->region) ? b->no : 0);
|
||||
}
|
||||
|
||||
int resolve_building(variant id, void *address)
|
||||
{
|
||||
int result = 0;
|
||||
building *b = NULL;
|
||||
if (id.i != 0) {
|
||||
b = findbuilding(id.i);
|
||||
if (b == NULL) {
|
||||
result = -1;
|
||||
int result = 0;
|
||||
building *b = NULL;
|
||||
if (id.i != 0) {
|
||||
b = findbuilding(id.i);
|
||||
if (b == NULL) {
|
||||
result = -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
*(building **) address = b;
|
||||
return result;
|
||||
*(building **)address = b;
|
||||
return result;
|
||||
}
|
||||
|
||||
variant read_building_reference(struct storage * store)
|
||||
{
|
||||
variant result;
|
||||
READ_INT(store, &result.i);
|
||||
return result;
|
||||
variant result;
|
||||
READ_INT(store, &result.i);
|
||||
return result;
|
||||
}
|
||||
|
||||
building *new_building(const struct building_type * btype, region * r,
|
||||
const struct locale * lang)
|
||||
const struct locale * lang)
|
||||
{
|
||||
building **bptr = &r->buildings;
|
||||
building *b = (building *) calloc(1, sizeof(building));
|
||||
static bool init_lighthouse = false;
|
||||
static const struct building_type *bt_lighthouse = 0;
|
||||
const char *bname = 0;
|
||||
char buffer[32];
|
||||
building **bptr = &r->buildings;
|
||||
building *b = (building *)calloc(1, sizeof(building));
|
||||
static bool init_lighthouse = false;
|
||||
static const struct building_type *bt_lighthouse = 0;
|
||||
const char *bname = 0;
|
||||
char buffer[32];
|
||||
|
||||
if (!init_lighthouse) {
|
||||
bt_lighthouse = bt_find("lighthouse");
|
||||
init_lighthouse = true;
|
||||
}
|
||||
if (!init_lighthouse) {
|
||||
bt_lighthouse = bt_find("lighthouse");
|
||||
init_lighthouse = true;
|
||||
}
|
||||
|
||||
b->no = newcontainerid();
|
||||
bhash(b);
|
||||
b->no = newcontainerid();
|
||||
bhash(b);
|
||||
|
||||
b->type = btype;
|
||||
b->region = r;
|
||||
while (*bptr)
|
||||
bptr = &(*bptr)->next;
|
||||
*bptr = b;
|
||||
b->type = btype;
|
||||
b->region = r;
|
||||
while (*bptr)
|
||||
bptr = &(*bptr)->next;
|
||||
*bptr = b;
|
||||
|
||||
if (b->type == bt_lighthouse) {
|
||||
r->flags |= RF_LIGHTHOUSE;
|
||||
}
|
||||
if (b->type->name) {
|
||||
bname = LOC(lang, buildingtype(btype, b, 0));
|
||||
}
|
||||
if (!bname) {
|
||||
bname = LOC(lang, btype->_name);
|
||||
}
|
||||
if (!bname) {
|
||||
bname = LOC(lang, parameters[P_GEBAEUDE]);
|
||||
}
|
||||
if (!bname) {
|
||||
bname = parameters[P_GEBAEUDE];
|
||||
}
|
||||
assert(bname);
|
||||
slprintf(buffer, sizeof(buffer), "%s %s", bname, buildingid(b));
|
||||
b->name = _strdup(bname);
|
||||
return b;
|
||||
if (b->type == bt_lighthouse) {
|
||||
r->flags |= RF_LIGHTHOUSE;
|
||||
}
|
||||
if (b->type->name) {
|
||||
bname = LOC(lang, buildingtype(btype, b, 0));
|
||||
}
|
||||
if (!bname) {
|
||||
bname = LOC(lang, btype->_name);
|
||||
}
|
||||
if (!bname) {
|
||||
bname = LOC(lang, parameters[P_GEBAEUDE]);
|
||||
}
|
||||
if (!bname) {
|
||||
bname = parameters[P_GEBAEUDE];
|
||||
}
|
||||
assert(bname);
|
||||
slprintf(buffer, sizeof(buffer), "%s %s", bname, buildingid(b));
|
||||
b->name = _strdup(bname);
|
||||
return b;
|
||||
}
|
||||
|
||||
static building *deleted_buildings;
|
||||
|
|
@ -431,8 +431,8 @@ void remove_building(building ** blist, building * b)
|
|||
update_lighthouse(b);
|
||||
bunhash(b);
|
||||
|
||||
/* Falls Karawanserei, Damm oder Tunnel einstürzen, wird die schon
|
||||
* gebaute Straße zur Hälfte vernichtet */
|
||||
/* Falls Karawanserei, Damm oder Tunnel einstürzen, wird die schon
|
||||
* gebaute Straße zur Hälfte vernichtet */
|
||||
if (b->type == bt_caravan || b->type == bt_dam || b->type == bt_tunnel) {
|
||||
region *r = b->region;
|
||||
int d;
|
||||
|
|
@ -443,7 +443,7 @@ void remove_building(building ** blist, building * b)
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Stattdessen nur aus Liste entfernen, aber im Speicher halten. */
|
||||
while (*blist && *blist != b) {
|
||||
blist = &(*blist)->next;
|
||||
|
|
@ -456,19 +456,19 @@ void remove_building(building ** blist, building * b)
|
|||
|
||||
void free_building(building * b)
|
||||
{
|
||||
while (b->attribs)
|
||||
a_remove(&b->attribs, b->attribs);
|
||||
free(b->name);
|
||||
free(b->display);
|
||||
free(b);
|
||||
while (b->attribs)
|
||||
a_remove(&b->attribs, b->attribs);
|
||||
free(b->name);
|
||||
free(b->display);
|
||||
free(b);
|
||||
}
|
||||
|
||||
void free_buildings(void)
|
||||
{
|
||||
while (deleted_buildings) {
|
||||
building *b = deleted_buildings;
|
||||
deleted_buildings = b->next;
|
||||
}
|
||||
while (deleted_buildings) {
|
||||
building *b = deleted_buildings;
|
||||
deleted_buildings = b->next;
|
||||
}
|
||||
}
|
||||
|
||||
extern struct attrib_type at_icastle;
|
||||
|
|
@ -478,87 +478,87 @@ extern struct attrib_type at_icastle;
|
|||
* stages */
|
||||
int buildingeffsize(const building * b, int img)
|
||||
{
|
||||
const struct building_type *btype = NULL;
|
||||
const struct building_type *btype = NULL;
|
||||
|
||||
if (b == NULL)
|
||||
return 0;
|
||||
if (b == NULL)
|
||||
return 0;
|
||||
|
||||
btype = b->type;
|
||||
if (img) {
|
||||
const attrib *a = a_find(b->attribs, &at_icastle);
|
||||
if (a) {
|
||||
btype = (const struct building_type *)a->data.v;
|
||||
btype = b->type;
|
||||
if (img) {
|
||||
const attrib *a = a_find(b->attribs, &at_icastle);
|
||||
if (a) {
|
||||
btype = (const struct building_type *)a->data.v;
|
||||
}
|
||||
}
|
||||
}
|
||||
return bt_effsize(btype, b, b->size);
|
||||
return bt_effsize(btype, b, b->size);
|
||||
}
|
||||
|
||||
int bt_effsize(const building_type * btype, const building * b, int bsize)
|
||||
{
|
||||
int i = bsize, n = 0;
|
||||
const construction *cons = btype->construction;
|
||||
int i = bsize, n = 0;
|
||||
const construction *cons = btype->construction;
|
||||
|
||||
/* TECH DEBT: simplest thing that works for E3 dwarf/halfling faction rules */
|
||||
if (b && get_param_int(global.parameters, "rules.dwarf_castles", 0)
|
||||
&& strcmp(btype->_name, "castle") == 0) {
|
||||
unit *u = building_owner(b);
|
||||
if (u && u->faction->race == get_race(RC_HALFLING)) {
|
||||
i = bsize * 10 / 8;
|
||||
/* TECH DEBT: simplest thing that works for E3 dwarf/halfling faction rules */
|
||||
if (b && get_param_int(global.parameters, "rules.dwarf_castles", 0)
|
||||
&& strcmp(btype->_name, "castle") == 0) {
|
||||
unit *u = building_owner(b);
|
||||
if (u && u->faction->race == get_race(RC_HALFLING)) {
|
||||
i = bsize * 10 / 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!cons || !cons->improvement) {
|
||||
return 0;
|
||||
}
|
||||
if (!cons || !cons->improvement) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
while (cons && cons->maxsize != -1 && i >= cons->maxsize) {
|
||||
i -= cons->maxsize;
|
||||
cons = cons->improvement;
|
||||
++n;
|
||||
}
|
||||
while (cons && cons->maxsize != -1 && i >= cons->maxsize) {
|
||||
i -= cons->maxsize;
|
||||
cons = cons->improvement;
|
||||
++n;
|
||||
}
|
||||
|
||||
return n;
|
||||
return n;
|
||||
}
|
||||
|
||||
const char *write_buildingname(const building * b, char *ibuf, size_t size)
|
||||
{
|
||||
slprintf(ibuf, size, "%s (%s)", b->name, itoa36(b->no));
|
||||
return ibuf;
|
||||
slprintf(ibuf, size, "%s (%s)", b->name, itoa36(b->no));
|
||||
return ibuf;
|
||||
}
|
||||
|
||||
const char *buildingname(const building * b)
|
||||
{
|
||||
typedef char name[OBJECTIDSIZE + 1];
|
||||
static name idbuf[8];
|
||||
static int nextbuf = 0;
|
||||
char *ibuf = idbuf[(++nextbuf) % 8];
|
||||
return write_buildingname(b, ibuf, sizeof(name));
|
||||
typedef char name[OBJECTIDSIZE + 1];
|
||||
static name idbuf[8];
|
||||
static int nextbuf = 0;
|
||||
char *ibuf = idbuf[(++nextbuf) % 8];
|
||||
return write_buildingname(b, ibuf, sizeof(name));
|
||||
}
|
||||
|
||||
void building_set_owner(struct unit * owner)
|
||||
{
|
||||
assert(owner && owner->building);
|
||||
owner->building->_owner = owner;
|
||||
assert(owner && owner->building);
|
||||
owner->building->_owner = owner;
|
||||
}
|
||||
|
||||
static unit *building_owner_ex(const building * bld, const struct faction * last_owner)
|
||||
{
|
||||
unit *u, *heir = 0;
|
||||
/* Eigentümer tot oder kein Eigentümer vorhanden. Erste lebende Einheit
|
||||
* nehmen. */
|
||||
for (u = bld->region->units; u; u = u->next) {
|
||||
if (u->building == bld) {
|
||||
if (u->number > 0) {
|
||||
if (heir && last_owner && heir->faction!=last_owner && u->faction==last_owner) {
|
||||
heir = u;
|
||||
break; /* we found someone from the same faction who is not dead. let's take this guy */
|
||||
unit *u, *heir = 0;
|
||||
/* Eigentümer tot oder kein Eigentümer vorhanden. Erste lebende Einheit
|
||||
* nehmen. */
|
||||
for (u = bld->region->units; u; u = u->next) {
|
||||
if (u->building == bld) {
|
||||
if (u->number > 0) {
|
||||
if (heir && last_owner && heir->faction != last_owner && u->faction == last_owner) {
|
||||
heir = u;
|
||||
break; /* we found someone from the same faction who is not dead. let's take this guy */
|
||||
}
|
||||
else if (!heir) {
|
||||
heir = u; /* you'll do in an emergency */
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (!heir) {
|
||||
heir = u; /* you'll do in an emergency */
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!heir && check_param(global.parameters, "rules.region_owner_pay_building", bld->type->_name)) {
|
||||
if (rule_region_owners()) {
|
||||
u = building_owner(largestbuilding(bld->region, &cmp_taxes, false));
|
||||
|
|
@ -575,54 +575,54 @@ static unit *building_owner_ex(const building * bld, const struct faction * last
|
|||
|
||||
unit *building_owner(const building * bld)
|
||||
{
|
||||
if (!bld) {
|
||||
return NULL;
|
||||
}
|
||||
unit *owner = bld->_owner;
|
||||
if (!owner || (owner->building!=bld || owner->number<=0)) {
|
||||
unit * heir = building_owner_ex(bld, owner?owner->faction:0);
|
||||
return (heir && heir->number>0) ? heir : 0;
|
||||
}
|
||||
return owner;
|
||||
if (!bld) {
|
||||
return NULL;
|
||||
}
|
||||
unit *owner = bld->_owner;
|
||||
if (!owner || (owner->building != bld || owner->number <= 0)) {
|
||||
unit * heir = building_owner_ex(bld, owner ? owner->faction : 0);
|
||||
return (heir && heir->number > 0) ? heir : 0;
|
||||
}
|
||||
return owner;
|
||||
}
|
||||
|
||||
void building_update_owner(building * bld) {
|
||||
unit * owner = bld->_owner;
|
||||
bld->_owner = building_owner_ex(bld, owner?owner->faction:0);
|
||||
unit * owner = bld->_owner;
|
||||
bld->_owner = building_owner_ex(bld, owner ? owner->faction : 0);
|
||||
}
|
||||
|
||||
const char *building_getname(const building * self)
|
||||
{
|
||||
return self->name;
|
||||
return self->name;
|
||||
}
|
||||
|
||||
void building_setname(building * self, const char *name)
|
||||
{
|
||||
free(self->name);
|
||||
if (name)
|
||||
self->name = _strdup(name);
|
||||
else
|
||||
self->name = NULL;
|
||||
free(self->name);
|
||||
if (name)
|
||||
self->name = _strdup(name);
|
||||
else
|
||||
self->name = NULL;
|
||||
}
|
||||
|
||||
region *building_getregion(const building * b)
|
||||
{
|
||||
return b->region;
|
||||
return b->region;
|
||||
}
|
||||
|
||||
void building_setregion(building * b, region * r)
|
||||
{
|
||||
building **blist = &b->region->buildings;
|
||||
while (*blist && *blist != b) {
|
||||
blist = &(*blist)->next;
|
||||
}
|
||||
*blist = b->next;
|
||||
b->next = NULL;
|
||||
building **blist = &b->region->buildings;
|
||||
while (*blist && *blist != b) {
|
||||
blist = &(*blist)->next;
|
||||
}
|
||||
*blist = b->next;
|
||||
b->next = NULL;
|
||||
|
||||
blist = &r->buildings;
|
||||
while (*blist && *blist != b)
|
||||
blist = &(*blist)->next;
|
||||
*blist = b;
|
||||
blist = &r->buildings;
|
||||
while (*blist && *blist != b)
|
||||
blist = &(*blist)->next;
|
||||
*blist = b;
|
||||
|
||||
b->region = r;
|
||||
b->region = r;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,12 +13,14 @@
|
|||
#include <kernel/terrain.h>
|
||||
#include <kernel/unit.h>
|
||||
|
||||
#include <util/base36.h>
|
||||
#include <util/language.h>
|
||||
|
||||
#include <CuTest.h>
|
||||
#include <tests.h>
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
|
||||
static void test_new_building_can_be_renamed(CuTest * tc)
|
||||
{
|
||||
|
|
@ -356,16 +358,23 @@ struct pay_fixture {
|
|||
unit *u2;
|
||||
};
|
||||
|
||||
static double level_taxes(const building * b, int level) {
|
||||
return b->size*level*2.0;
|
||||
}
|
||||
|
||||
static void setup_pay_cmd(struct pay_fixture *fix) {
|
||||
faction *f;
|
||||
region *r;
|
||||
building *b;
|
||||
building_type *btcastle;
|
||||
|
||||
test_create_world();
|
||||
f = test_create_faction(NULL);
|
||||
r = findregion(0, 0);
|
||||
assert(r && f);
|
||||
b = test_create_building(r, bt_get_or_create("lighthouse"));
|
||||
btcastle = bt_get_or_create("castle");
|
||||
btcastle->taxes = level_taxes;
|
||||
b = test_create_building(r, btcastle);
|
||||
assert(b);
|
||||
fix->u1 = test_create_unit(f, r);
|
||||
fix->u2 = test_create_unit(f, r);
|
||||
|
|
@ -394,6 +403,30 @@ static void test_pay_cmd(CuTest *tc) {
|
|||
test_cleanup();
|
||||
}
|
||||
|
||||
static void test_pay_cmd_other_building(CuTest *tc) {
|
||||
struct pay_fixture fix;
|
||||
order *ord;
|
||||
faction *f;
|
||||
building *b;
|
||||
char cmd[32];
|
||||
|
||||
test_cleanup();
|
||||
setup_pay_cmd(&fix);
|
||||
f = fix.u1->faction;
|
||||
b = test_create_building(fix.u1->region, bt_get_or_create("lighthouse"));
|
||||
set_param(&global.parameters, "rules.region_owners", "1");
|
||||
set_param(&global.parameters, "rules.region_owner_pay_building", "lighthouse");
|
||||
update_owners(b->region);
|
||||
|
||||
_snprintf(cmd, sizeof(cmd), "NOT %s", itoa36(b->no));
|
||||
ord = create_order(K_PAY, f->locale, cmd);
|
||||
assert(ord);
|
||||
CuAssertPtrEquals(tc, fix.u1, building_owner(b));
|
||||
CuAssertIntEquals(tc, 0, pay_cmd(fix.u1, ord));
|
||||
CuAssertIntEquals(tc, BLD_DONTPAY, b->flags&BLD_DONTPAY);
|
||||
test_cleanup();
|
||||
}
|
||||
|
||||
static void test_pay_cmd_must_be_owner(CuTest *tc) {
|
||||
struct pay_fixture fix;
|
||||
order *ord;
|
||||
|
|
@ -412,7 +445,6 @@ static void test_pay_cmd_must_be_owner(CuTest *tc) {
|
|||
test_cleanup();
|
||||
}
|
||||
|
||||
|
||||
static void test_new_units(CuTest *tc) {
|
||||
unit *u;
|
||||
faction *f;
|
||||
|
|
@ -581,6 +613,7 @@ CuSuite *get_laws_suite(void)
|
|||
SUITE_ADD_TEST(suite, test_reserve_self);
|
||||
SUITE_ADD_TEST(suite, test_reserve_cmd);
|
||||
SUITE_ADD_TEST(suite, test_pay_cmd);
|
||||
SUITE_ADD_TEST(suite, test_pay_cmd_other_building);
|
||||
SUITE_ADD_TEST(suite, test_pay_cmd_must_be_owner);
|
||||
SUITE_ADD_TEST(suite, test_new_units);
|
||||
SUITE_ADD_TEST(suite, test_cannot_create_unit_above_limit);
|
||||
|
|
|
|||
Loading…
Reference in New Issue