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

remove the deprecated getunit function.

Browse source 
fix the build, missing return value from give_control_cmd.
This commit is contained in:
Enno Rehling 2014-12-12 21:06:47 +01:00
parent 481275aef1
commit 98994f233d
7 changed files with 429 additions and 428 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/economy.c
View file

@ -640,7 +640,7 @@ int give_control_cmd(unit * u, order * ord)
if (!can_give_to(u, u2)) { if (!can_give_to(u, u2)) {
ADDMSG(&u->faction->msgs, ADDMSG(&u->faction->msgs,
msg_feedback(u, ord, "feedback_unit_not_found", "")); msg_feedback(u, ord, "feedback_unit_not_found", ""));
return; return 0;
} }
else if (!u->building && !u->ship) { else if (!u->building && !u->ship) {
msg = cmistake(u, ord, 140, MSG_EVENT); msg = cmistake(u, ord, 140, MSG_EVENT);

34
src/kernel/config.c
View file

@ -1021,13 +1021,18 @@ int getunit(const region * r, const faction * f, unit **uresult)
unit *u2; unit *u2;
if (n == 0) { if (n == 0) {
*uresult = 0; if (uresult) {
*uresult = 0;
}
return GET_PEASANTS; return GET_PEASANTS;
} }
if (n < 0) if (n < 0)
return 0; return GET_NOTFOUND;
*uresult = u2 = findunit(n); u2 = findunit(n);
if (uresult) {
*uresult = u2;
}
if (u2 != NULL && u2->region == r) { if (u2 != NULL && u2->region == r) {
/* there used to be a 'u2->flags & UFL_ISNEW || u2->number>0' condition /* there used to be a 'u2->flags & UFL_ISNEW || u2->number>0' condition
* here, but it got removed because of a bug that made units disappear: * here, but it got removed because of a bug that made units disappear:
@ -1039,29 +1044,6 @@ int getunit(const region * r, const faction * f, unit **uresult)
return GET_NOTFOUND; return GET_NOTFOUND;
} }
unit *getunit_deprecated(const region * r, const faction * f)
{
int n = read_unitid(f, r);
unit *u2;
if (n == 0) {
return NULL;
}
if (n < 0)
return 0;
u2 = findunit(n);
if (u2 != NULL && u2->region == r) {
/* there used to be a 'u2->flags & UFL_ISNEW || u2->number>0' condition
* here, but it got removed because of a bug that made units disappear:
* http://eressea.upb.de/mantis/bug_view_page.php?bug_id=0000172
*/
return u2;
}
return NULL;
}
/* - String Listen --------------------------------------------- */ /* - String Listen --------------------------------------------- */
void addstrlist(strlist ** SP, const char *s) void addstrlist(strlist ** SP, const char *s)
{ {

1
src/kernel/config.h
View file

@ -168,7 +168,6 @@ extern "C" {
struct unit *createunit(struct region *r, struct faction *f, struct unit *createunit(struct region *r, struct faction *f,
int number, const struct race *rc); int number, const struct race *rc);
void create_unitid(struct unit *u, int id); void create_unitid(struct unit *u, int id);
struct unit *getunit_deprecated(const struct region *r, const struct faction *f);
int getunit(const struct region * r, const struct faction * f, struct unit **uresult); int getunit(const struct region * r, const struct faction * f, struct unit **uresult);
int read_unitid(const struct faction *f, const struct region *r); int read_unitid(const struct faction *f, const struct region *r);

3
src/laws.c
View file

@ -1830,8 +1830,9 @@ int name_cmd(struct unit *u, struct order *ord)
case P_UNIT: case P_UNIT:
if (foreign) { if (foreign) {
unit *u2 = getunit_deprecated(r, u->faction); unit *u2 = 0;
getunit(r, u->faction, &u2);
if (!u2 || !cansee(u->faction, r, u2, 0)) { if (!u2 || !cansee(u->faction, r, u2, 0)) {
ADDMSG(&u->faction->msgs, msg_feedback(u, ord, ADDMSG(&u->faction->msgs, msg_feedback(u, ord,
"feedback_unit_not_found", "")); "feedback_unit_not_found", ""));

32
src/move.c
View file

@ -1247,8 +1247,10 @@ static bool transport(unit * ut, unit * u)
for (ord = ut->orders; ord; ord = ord->next) { for (ord = ut->orders; ord; ord = ord->next) {
if (getkeyword(ord) == K_TRANSPORT) { if (getkeyword(ord) == K_TRANSPORT) {
unit *u2;
init_order(ord); init_order(ord);
if (getunit_deprecated(ut->region, ut->faction) == u) { getunit(ut->region, ut->faction, &u2);
if (u2 == u) {
return true; return true;
} }
} }
@ -1278,11 +1280,10 @@ static void init_transportation(void)
for (u = r->units; u; u = u->next) { for (u = r->units; u; u = u->next) {
if (getkeyword(u->thisorder) == K_DRIVE && can_move(u) if (getkeyword(u->thisorder) == K_DRIVE && can_move(u)
&& !fval(u, UFL_NOTMOVING) && !LongHunger(u)) { && !fval(u, UFL_NOTMOVING) && !LongHunger(u)) {
unit *ut; unit *ut = 0;
init_order(u->thisorder); init_order(u->thisorder);
ut = getunit_deprecated(r, u->faction); if (getunit(r, u->faction, &ut) != GET_UNIT) {
if (ut == NULL) {
ADDMSG(&u->faction->msgs, msg_feedback(u, u->thisorder, ADDMSG(&u->faction->msgs, msg_feedback(u, u->thisorder,
"feedback_unit_not_found", "")); "feedback_unit_not_found", ""));
continue; continue;
@ -1312,14 +1313,18 @@ static void init_transportation(void)
if (getkeyword(ord) == K_TRANSPORT) { if (getkeyword(ord) == K_TRANSPORT) {
init_order(ord); init_order(ord);
for (;;) { for (;;) {
unit *ut = getunit_deprecated(r, u->faction); unit *ut = 0;
if (ut == NULL) if (getunit(r, u->faction, &ut) != GET_UNIT) {
break; break;
if (getkeyword(ut->thisorder) == K_DRIVE && can_move(ut) }
&& !fval(ut, UFL_NOTMOVING) && !LongHunger(ut)) { if (getkeyword(ut->thisorder) == K_DRIVE &&
can_move(ut) && !fval(ut, UFL_NOTMOVING) &&
!LongHunger(ut)) {
unit *u2;
init_order(ut->thisorder); init_order(ut->thisorder);
if (getunit_deprecated(r, ut->faction) == u) { getunit(r, ut->faction, &u2);
if (u2 == u) {
w += weight(ut); w += weight(ut);
} }
} }
@ -2198,14 +2203,13 @@ static const region_list *travel_i(unit * u, const region_list * route_begin,
/* transportation */ /* transportation */
for (ord = u->orders; ord; ord = ord->next) { for (ord = u->orders; ord; ord = ord->next) {
unit *ut; unit *ut = 0;
if (getkeyword(ord) != K_TRANSPORT) if (getkeyword(ord) != K_TRANSPORT)
continue; continue;
init_order(ord); init_order(ord);
ut = getunit_deprecated(r, u->faction); if (getunit(r, u->faction, &ut) == GET_UNIT) {
if (ut != NULL) {
if (getkeyword(ut->thisorder) == K_DRIVE) { if (getkeyword(ut->thisorder) == K_DRIVE) {
if (ut->building && !can_leave(ut)) { if (ut->building && !can_leave(ut)) {
cmistake(ut, ut->thisorder, 150, MSG_MOVE); cmistake(ut, ut->thisorder, 150, MSG_MOVE);
@ -2218,8 +2222,10 @@ static const region_list *travel_i(unit * u, const region_list * route_begin,
bool found = false; bool found = false;
if (!fval(ut, UFL_NOTMOVING) && !LongHunger(ut)) { if (!fval(ut, UFL_NOTMOVING) && !LongHunger(ut)) {
unit *u2;
init_order(ut->thisorder); init_order(ut->thisorder);
if (getunit_deprecated(u->region, ut->faction) == u) { getunit(u->region, ut->faction, &u2);
if (u2 == u) {
const region_list *route_to = const region_list *route_to =
travel_route(ut, route_begin, route_end, ord, travel_route(ut, route_begin, route_end, ord,
TRAVEL_TRANSPORTED); TRAVEL_TRANSPORTED);

779
src/spy.c
View file

@ -1,7 +1,7 @@
/* /*
Copyright (c) 1998-2010, Enno Rehling <enno@eressea.de> Copyright (c) 1998-2010, Enno Rehling <enno@eressea.de>
Katja Zedel <katze@felidae.kn-bremen.de Katja Zedel <katze@felidae.kn-bremen.de
Christian Schlittchen <corwin@amber.kn-bremen.de> Christian Schlittchen <corwin@amber.kn-bremen.de>
Permission to use, copy, modify, and/or distribute this software for any Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above purpose with or without fee is hereby granted, provided that the above
@ -58,453 +58,464 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
* Spionage des Spions */ * Spionage des Spions */
void spy_message(int spy, const unit * u, const unit * target) void spy_message(int spy, const unit * u, const unit * target)
{ {
const char *str = report_kampfstatus(target, u->faction->locale); const char *str = report_kampfstatus(target, u->faction->locale);
ADDMSG(&u->faction->msgs, msg_message("spyreport", "spy target status", u, ADDMSG(&u->faction->msgs, msg_message("spyreport", "spy target status", u,
target, str)); target, str));
if (spy > 20) { if (spy > 20) {
sc_mage *mage = get_mage(target); sc_mage *mage = get_mage(target);
/* for mages, spells and magic school */ /* for mages, spells and magic school */
if (mage) { if (mage) {
ADDMSG(&u->faction->msgs, msg_message("spyreport_mage", "target type", ADDMSG(&u->faction->msgs, msg_message("spyreport_mage", "target type",
target, magic_school[mage->magietyp])); target, magic_school[mage->magietyp]));
}
}
if (spy > 6) {
faction *fv = visible_faction(u->faction, target);
if (fv && fv != target->faction) {
/* true faction */
ADDMSG(&u->faction->msgs, msg_message("spyreport_faction",
"target faction", target, target->faction));
add_seen_faction(u->faction, target->faction);
}
}
if (spy > 0) {
int first = 1;
int found = 0;
skill *sv;
char buf[4096];
buf[0] = 0;
for (sv = target->skills; sv != target->skills + target->skill_size; ++sv) {
if (sv->level > 0) {
found++;
if (first == 1) {
first = 0;
} else {
strncat(buf, ", ", sizeof(buf)-1);
} }
strncat(buf, (const char *)skillname((skill_t)sv->id, u->faction->locale),
sizeof(buf)-1);
strncat(buf, " ", sizeof(buf)-1);
strncat(buf, itoa10(eff_skill(target, (skill_t)sv->id, target->region)),
sizeof(buf)-1);
}
} }
if (found) { if (spy > 6) {
ADDMSG(&u->faction->msgs, msg_message("spyreport_skills", "target skills", faction *fv = visible_faction(u->faction, target);
target, buf)); if (fv && fv != target->faction) {
/* true faction */
ADDMSG(&u->faction->msgs, msg_message("spyreport_faction",
"target faction", target, target->faction));
add_seen_faction(u->faction, target->faction);
}
} }
if (spy > 0) {
int first = 1;
int found = 0;
skill *sv;
char buf[4096];
if (target->items) { buf[0] = 0;
ADDMSG(&u->faction->msgs, msg_message("spyreport_items", "target items", for (sv = target->skills; sv != target->skills + target->skill_size; ++sv) {
target, target->items)); if (sv->level > 0) {
found++;
if (first == 1) {
first = 0;
}
else {
strncat(buf, ", ", sizeof(buf) - 1);
}
strncat(buf, (const char *)skillname((skill_t)sv->id, u->faction->locale),
sizeof(buf) - 1);
strncat(buf, " ", sizeof(buf) - 1);
strncat(buf, itoa10(eff_skill(target, (skill_t)sv->id, target->region)),
sizeof(buf) - 1);
}
}
if (found) {
ADDMSG(&u->faction->msgs, msg_message("spyreport_skills", "target skills",
target, buf));
}
if (target->items) {
ADDMSG(&u->faction->msgs, msg_message("spyreport_items", "target items",
target, target->items));
}
} }
}
} }
int spy_cmd(unit * u, struct order *ord) int spy_cmd(unit * u, struct order *ord)
{ {
unit *target; unit *target;
int spy, observe; int spy, observe;
double spychance, observechance; double spychance, observechance;
region *r = u->region; region *r = u->region;
init_order(ord); init_order(ord);
target = getunit_deprecated(r, u->faction); getunit(r, u->faction, &target);
if (!target) { if (!target) {
ADDMSG(&u->faction->msgs, msg_feedback(u, u->thisorder, ADDMSG(&u->faction->msgs,
"feedback_unit_not_found", "")); msg_feedback(u, u->thisorder, "feedback_unit_not_found", ""));
return 0;
}
if (!can_contact(r, u, target)) {
cmistake(u, u->thisorder, 24, MSG_EVENT);
return 0;
}
if (eff_skill(u, SK_SPY, r) < 1) {
cmistake(u, u->thisorder, 39, MSG_EVENT);
return 0;
}
/* Die Grundchance fuer einen erfolgreichen Spionage-Versuch ist 10%.
* Fuer jeden Talentpunkt, den das Spionagetalent das Tarnungstalent
* des Opfers uebersteigt, erhoeht sich dieses um 5%*/
spy = eff_skill(u, SK_SPY, r) - eff_skill(target, SK_STEALTH, r);
spychance = 0.1 + _max(spy * 0.05, 0.0);
if (chance(spychance)) {
produceexp(u, SK_SPY, u->number);
spy_message(spy, u, target);
}
else {
ADDMSG(&u->faction->msgs, msg_message("spyfail", "spy target", u, target));
}
/* der Spion kann identifiziert werden, wenn das Opfer bessere
* Wahrnehmung als das Ziel Tarnung + Spionage/2 hat */
observe = eff_skill(target, SK_PERCEPTION, r)
- (effskill(u, SK_STEALTH) + eff_skill(u, SK_SPY, r) / 2);
if (invisible(u, target) >= u->number) {
observe = _min(observe, 0);
}
/* Anschliessend wird - unabhaengig vom Erfolg - gewuerfelt, ob der
* Spionageversuch bemerkt wurde. Die Wahrscheinlich dafuer ist (100 -
* SpionageSpion*5 + WahrnehmungOpfer*2)%. */
observechance = 1.0 - (eff_skill(u, SK_SPY, r) * 0.05)
+ (eff_skill(target, SK_PERCEPTION, r) * 0.02);
if (chance(observechance)) {
ADDMSG(&target->faction->msgs, msg_message("spydetect",
"spy target", observe > 0 ? u : NULL, target));
}
return 0; return 0;
}
if (!can_contact(r, u, target)) {
cmistake(u, u->thisorder, 24, MSG_EVENT);
return 0;
}
if (eff_skill(u, SK_SPY, r) < 1) {
cmistake(u, u->thisorder, 39, MSG_EVENT);
return 0;
}
/* Die Grundchance fuer einen erfolgreichen Spionage-Versuch ist 10%.
* Fuer jeden Talentpunkt, den das Spionagetalent das Tarnungstalent
* des Opfers uebersteigt, erhoeht sich dieses um 5%*/
spy = eff_skill(u, SK_SPY, r) - eff_skill(target, SK_STEALTH, r);
spychance = 0.1 + _max(spy * 0.05, 0.0);
if (chance(spychance)) {
produceexp(u, SK_SPY, u->number);
spy_message(spy, u, target);
} else {
ADDMSG(&u->faction->msgs, msg_message("spyfail", "spy target", u, target));
}
/* der Spion kann identifiziert werden, wenn das Opfer bessere
* Wahrnehmung als das Ziel Tarnung + Spionage/2 hat */
observe = eff_skill(target, SK_PERCEPTION, r)
- (effskill(u, SK_STEALTH) + eff_skill(u, SK_SPY, r) / 2);
if (invisible(u, target) >= u->number) {
observe = _min(observe, 0);
}
/* Anschliessend wird - unabhaengig vom Erfolg - gewuerfelt, ob der
* Spionageversuch bemerkt wurde. Die Wahrscheinlich dafuer ist (100 -
* SpionageSpion*5 + WahrnehmungOpfer*2)%. */
observechance = 1.0 - (eff_skill(u, SK_SPY, r) * 0.05)
+ (eff_skill(target, SK_PERCEPTION, r) * 0.02);
if (chance(observechance)) {
ADDMSG(&target->faction->msgs, msg_message("spydetect",
"spy target", observe > 0 ? u : NULL, target));
}
return 0;
} }
void set_factionstealth(unit * u, faction * f) void set_factionstealth(unit * u, faction * f)
{ {
region *lastr = NULL; region *lastr = NULL;
/* for all units mu of our faction, check all the units in the region /* for all units mu of our faction, check all the units in the region
* they are in, if their visible faction is f, it's ok. use lastr to * they are in, if their visible faction is f, it's ok. use lastr to
* avoid testing the same region twice in a row. */ * avoid testing the same region twice in a row. */
unit *mu = u->faction->units; unit *mu = u->faction->units;
while (mu != NULL) { while (mu != NULL) {
if (mu->number && mu->region != lastr) { if (mu->number && mu->region != lastr) {
unit *ru = mu->region->units; unit *ru = mu->region->units;
lastr = mu->region; lastr = mu->region;
while (ru != NULL) { while (ru != NULL) {
if (ru->number) { if (ru->number) {
faction *fv = visible_faction(f, ru); faction *fv = visible_faction(f, ru);
if (fv == f) { if (fv == f) {
if (cansee(f, lastr, ru, 0)) if (cansee(f, lastr, ru, 0))
break; break;
} }
}
ru = ru->next;
}
if (ru != NULL)
break;
} }
ru = ru->next; mu = mu->nextF;
} }
if (ru != NULL) if (mu != NULL) {
break; attrib *a = a_find(u->attribs, &at_otherfaction);
if (!a)
a = a_add(&u->attribs, make_otherfaction(f));
else
a->data.v = f;
} }
mu = mu->nextF;
}
if (mu != NULL) {
attrib *a = a_find(u->attribs, &at_otherfaction);
if (!a)
a = a_add(&u->attribs, make_otherfaction(f));
else
a->data.v = f;
}
} }
int setstealth_cmd(unit * u, struct order *ord) int setstealth_cmd(unit * u, struct order *ord)
{ {
const char *s; const char *s;
int level, rule; int level, rule;
const race *trace; const race *trace;
init_order(ord); init_order(ord);
s = getstrtoken(); s = getstrtoken();
/* Tarne ohne Parameter: Setzt maximale Tarnung */ /* Tarne ohne Parameter: Setzt maximale Tarnung */
if (s == NULL || *s == 0) { if (s == NULL || *s == 0) {
u_seteffstealth(u, -1); u_seteffstealth(u, -1);
return 0; return 0;
}
if (isdigit(s[0])) {
/* Tarnungslevel setzen */
level = atoi((const char *)s);
if (level > effskill(u, SK_STEALTH)) {
ADDMSG(&u->faction->msgs, msg_feedback(u, ord, "error_lowstealth", ""));
return 0;
}
u_seteffstealth(u, level);
return 0;
}
trace = findrace(s, u->faction->locale);
if (trace) {
/* demons can cloak as other player-races */
if (u_race(u) == get_race(RC_DAEMON)) {
race_t allowed[] = { RC_DWARF, RC_ELF, RC_ORC, RC_GOBLIN, RC_HUMAN,
RC_TROLL, RC_DAEMON, RC_INSECT, RC_HALFLING, RC_CAT, RC_AQUARIAN,
NORACE
};
int i;
for (i = 0; allowed[i] != NORACE; ++i)
if (get_race(allowed[i]) == trace)
break;
if (get_race(allowed[i]) == trace) {
u->irace = trace;
if (u_race(u)->flags & RCF_SHAPESHIFTANY && get_racename(u->attribs))
set_racename(&u->attribs, NULL);
}
return 0;
} }
/* Singdrachen koennen sich nur als Drachen tarnen */ if (isdigit(s[0])) {
if (u_race(u) == get_race(RC_SONGDRAGON) /* Tarnungslevel setzen */
|| u_race(u) == get_race(RC_BIRTHDAYDRAGON)) { level = atoi((const char *)s);
if (trace == get_race(RC_SONGDRAGON) || trace == get_race(RC_FIREDRAGON) if (level > effskill(u, SK_STEALTH)) {
|| trace == get_race(RC_DRAGON) || trace == get_race(RC_WYRM)) { ADDMSG(&u->faction->msgs, msg_feedback(u, ord, "error_lowstealth", ""));
u->irace = trace; return 0;
if (u_race(u)->flags & RCF_SHAPESHIFTANY && get_racename(u->attribs))
set_racename(&u->attribs, NULL);
}
return 0;
}
/* Daemomen und Illusionsparteien koennen sich als andere race tarnen */
if (u_race(u)->flags & RCF_SHAPESHIFT) {
if (playerrace(trace)) {
u->irace = trace;
if ((u_race(u)->flags & RCF_SHAPESHIFTANY) && get_racename(u->attribs))
set_racename(&u->attribs, NULL);
}
}
return 0;
}
switch (findparam(s, u->faction->locale)) {
case P_FACTION:
/* TARNE PARTEI [NICHT|NUMMER abcd] */
rule = rule_stealth_faction();
if (!rule) {
/* TARNE PARTEI is disabled */
break;
}
s = getstrtoken();
if (rule&1) {
if (!s || *s == 0) {
fset(u, UFL_ANON_FACTION);
break;
} else if (findparam(s, u->faction->locale) == P_NOT) {
freset(u, UFL_ANON_FACTION);
break;
} }
} u_seteffstealth(u, level);
if (rule&2) { return 0;
if (get_keyword(s, u->faction->locale) == K_NUMBER) { }
const char *s2 = getstrtoken();
int nr = -1;
if (s2) { trace = findrace(s, u->faction->locale);
nr = atoi36(s2); if (trace) {
} /* demons can cloak as other player-races */
if (!s2 || *s2 == 0 || nr == u->faction->no) { if (u_race(u) == get_race(RC_DAEMON)) {
a_removeall(&u->attribs, &at_otherfaction); race_t allowed[] = { RC_DWARF, RC_ELF, RC_ORC, RC_GOBLIN, RC_HUMAN,
break; RC_TROLL, RC_DAEMON, RC_INSECT, RC_HALFLING, RC_CAT, RC_AQUARIAN,
} else { NORACE
struct faction *f = findfaction(nr); };
if (f == NULL) { int i;
cmistake(u, ord, 66, MSG_EVENT); for (i = 0; allowed[i] != NORACE; ++i)
break; if (get_race(allowed[i]) == trace)
} else { break;
set_factionstealth(u, f); if (get_race(allowed[i]) == trace) {
break; u->irace = trace;
if (u_race(u)->flags & RCF_SHAPESHIFTANY && get_racename(u->attribs))
set_racename(&u->attribs, NULL);
} }
} return 0;
} }
}
cmistake(u, ord, 289, MSG_EVENT); /* Singdrachen koennen sich nur als Drachen tarnen */
break; if (u_race(u) == get_race(RC_SONGDRAGON)
|| u_race(u) == get_race(RC_BIRTHDAYDRAGON)) {
if (trace == get_race(RC_SONGDRAGON) || trace == get_race(RC_FIREDRAGON)
|| trace == get_race(RC_DRAGON) || trace == get_race(RC_WYRM)) {
u->irace = trace;
if (u_race(u)->flags & RCF_SHAPESHIFTANY && get_racename(u->attribs))
set_racename(&u->attribs, NULL);
}
return 0;
}
/* Daemomen und Illusionsparteien koennen sich als andere race tarnen */
if (u_race(u)->flags & RCF_SHAPESHIFT) {
if (playerrace(trace)) {
u->irace = trace;
if ((u_race(u)->flags & RCF_SHAPESHIFTANY) && get_racename(u->attribs))
set_racename(&u->attribs, NULL);
}
}
return 0;
}
switch (findparam(s, u->faction->locale)) {
case P_FACTION:
/* TARNE PARTEI [NICHT|NUMMER abcd] */
rule = rule_stealth_faction();
if (!rule) {
/* TARNE PARTEI is disabled */
break;
}
s = getstrtoken();
if (rule & 1) {
if (!s || *s == 0) {
fset(u, UFL_ANON_FACTION);
break;
}
else if (findparam(s, u->faction->locale) == P_NOT) {
freset(u, UFL_ANON_FACTION);
break;
}
}
if (rule & 2) {
if (get_keyword(s, u->faction->locale) == K_NUMBER) {
const char *s2 = getstrtoken();
int nr = -1;
if (s2) {
nr = atoi36(s2);
}
if (!s2 || *s2 == 0 || nr == u->faction->no) {
a_removeall(&u->attribs, &at_otherfaction);
break;
}
else {
struct faction *f = findfaction(nr);
if (f == NULL) {
cmistake(u, ord, 66, MSG_EVENT);
break;
}
else {
set_factionstealth(u, f);
break;
}
}
}
}
cmistake(u, ord, 289, MSG_EVENT);
break;
case P_ANY: case P_ANY:
case P_NOT: case P_NOT:
/* TARNE ALLES (was nicht so alles geht?) */ /* TARNE ALLES (was nicht so alles geht?) */
u_seteffstealth(u, -1); u_seteffstealth(u, -1);
break; break;
default: default:
if (u_race(u)->flags & RCF_SHAPESHIFTANY) { if (u_race(u)->flags & RCF_SHAPESHIFTANY) {
set_racename(&u->attribs, s); set_racename(&u->attribs, s);
} else { }
cmistake(u, ord, 289, MSG_EVENT); else {
} cmistake(u, ord, 289, MSG_EVENT);
} }
return 0; }
return 0;
} }
static int crew_skill(region * r, faction * f, ship * sh, skill_t sk) static int crew_skill(region * r, faction * f, ship * sh, skill_t sk)
{ {
int value = 0; int value = 0;
unit *u; unit *u;
for (u = r->units; u; u = u->next) { for (u = r->units; u; u = u->next) {
if (u->ship == sh && u->faction == f) { if (u->ship == sh && u->faction == f) {
int s = eff_skill(u, sk, r); int s = eff_skill(u, sk, r);
value = _max(s, value); value = _max(s, value);
}
} }
} return value;
return value;
} }
static int try_destruction(unit * u, unit * u2, const ship * sh, int skilldiff) static int try_destruction(unit * u, unit * u2, const ship * sh, int skilldiff)
{ {
const char *destruction_success_msg = "destroy_ship_0"; const char *destruction_success_msg = "destroy_ship_0";
const char *destruction_failed_msg = "destroy_ship_1"; const char *destruction_failed_msg = "destroy_ship_1";
const char *destruction_detected_msg = "destroy_ship_2"; const char *destruction_detected_msg = "destroy_ship_2";
const char *detect_failure_msg = "destroy_ship_3"; const char *detect_failure_msg = "destroy_ship_3";
const char *object_destroyed_msg = "destroy_ship_4"; const char *object_destroyed_msg = "destroy_ship_4";
if (skilldiff == 0) { if (skilldiff == 0) {
/* tell the unit that the attempt failed: */ /* tell the unit that the attempt failed: */
ADDMSG(&u->faction->msgs, msg_message(destruction_failed_msg, "ship unit", ADDMSG(&u->faction->msgs, msg_message(destruction_failed_msg, "ship unit",
sh, u)); sh, u));
/* tell the enemy about the attempt: */ /* tell the enemy about the attempt: */
if (u2) { if (u2) {
ADDMSG(&u2->faction->msgs, msg_message(detect_failure_msg, "ship", sh)); ADDMSG(&u2->faction->msgs, msg_message(detect_failure_msg, "ship", sh));
}
return 0;
} }
return 0; else if (skilldiff < 0) {
} else if (skilldiff < 0) { /* tell the unit that the attempt was detected: */
/* tell the unit that the attempt was detected: */ ADDMSG(&u2->faction->msgs, msg_message(destruction_detected_msg,
ADDMSG(&u2->faction->msgs, msg_message(destruction_detected_msg, "ship unit", sh, u));
"ship unit", sh, u)); /* tell the enemy whodunit: */
/* tell the enemy whodunit: */ if (u2) {
if (u2) { ADDMSG(&u2->faction->msgs, msg_message(detect_failure_msg, "ship", sh));
ADDMSG(&u2->faction->msgs, msg_message(detect_failure_msg, "ship", sh)); }
return 0;
} }
return 0; else {
} else { /* tell the unit that the attempt succeeded */
/* tell the unit that the attempt succeeded */ ADDMSG(&u->faction->msgs, msg_message(destruction_success_msg, "ship unit",
ADDMSG(&u->faction->msgs, msg_message(destruction_success_msg, "ship unit", sh, u));
sh, u)); if (u2) {
if (u2) { ADDMSG(&u2->faction->msgs, msg_message(object_destroyed_msg, "ship", sh));
ADDMSG(&u2->faction->msgs, msg_message(object_destroyed_msg, "ship", sh)); }
} }
} return 1; /* success */
return 1; /* success */
} }
static void sink_ship(region * r, ship * sh, const char *name, unit * saboteur) static void sink_ship(region * r, ship * sh, const char *name, unit * saboteur)
{ {
unit **ui, *u; unit **ui, *u;
region *safety = r; region *safety = r;
int i; int i;
direction_t d; direction_t d;
double probability = 0.0; double probability = 0.0;
message *sink_msg = NULL; message *sink_msg = NULL;
faction *f; faction *f;
for (f = NULL, u = r->units; u; u = u->next) { for (f = NULL, u = r->units; u; u = u->next) {
/* slight optimization to avoid dereferencing u->faction each time */ /* slight optimization to avoid dereferencing u->faction each time */
if (f != u->faction) { if (f != u->faction) {
f = u->faction; f = u->faction;
freset(f, FFL_SELECT); freset(f, FFL_SELECT);
} }
}
/* figure out what a unit's chances of survival are: */
if (!fval(r->terrain, SEA_REGION)) {
probability = CANAL_SWIMMER_CHANCE;
} else {
for (d = 0; d != MAXDIRECTIONS; ++d) {
region *rn = rconnect(r, d);
if (!fval(rn->terrain, SEA_REGION) && !move_blocked(NULL, r, rn)) {
safety = rn;
probability = OCEAN_SWIMMER_CHANCE;
break;
}
}
}
for (ui = &r->units; *ui; ui = &(*ui)->next) {
unit *u = *ui;
/* inform this faction about the sinking ship: */
if (!fval(u->faction, FFL_SELECT)) {
fset(u->faction, FFL_SELECT);
if (sink_msg == NULL) {
sink_msg = msg_message("sink_msg", "ship region", sh, r);
}
add_message(&f->msgs, sink_msg);
} }
if (u->ship == sh) { /* figure out what a unit's chances of survival are: */
int dead = 0; if (!fval(r->terrain, SEA_REGION)) {
message *msg; probability = CANAL_SWIMMER_CHANCE;
/* if this fails, I misunderstood something: */
for (i = 0; i != u->number; ++i)
if (chance(probability))
++dead;
if (dead != u->number) {
/* she will live. but her items get stripped */
if (dead > 0) {
msg =
msg_message("sink_lost_msg", "dead region unit", dead, safety, u);
} else {
msg = msg_message("sink_saved_msg", "region unit", safety, u);
}
leave_ship(u);
if (r != safety) {
setguard(u, GUARD_NONE);
}
while (u->items) {
i_remove(&u->items, u->items);
}
move_unit(u, safety, NULL);
} else {
msg = msg_message("sink_lost_msg", "dead region unit", dead, NULL, u);
}
add_message(&u->faction->msgs, msg);
msg_release(msg);
if (dead == u->number) {
/* the poor creature, she dies */
if (remove_unit(ui, u) != 0) {
ui = &u->next;
}
}
} }
} else {
if (sink_msg) for (d = 0; d != MAXDIRECTIONS; ++d) {
msg_release(sink_msg); region *rn = rconnect(r, d);
/* finally, get rid of the ship */ if (!fval(rn->terrain, SEA_REGION) && !move_blocked(NULL, r, rn)) {
remove_ship(&sh->region->ships, sh); safety = rn;
probability = OCEAN_SWIMMER_CHANCE;
break;
}
}
}
for (ui = &r->units; *ui; ui = &(*ui)->next) {
unit *u = *ui;
/* inform this faction about the sinking ship: */
if (!fval(u->faction, FFL_SELECT)) {
fset(u->faction, FFL_SELECT);
if (sink_msg == NULL) {
sink_msg = msg_message("sink_msg", "ship region", sh, r);
}
add_message(&f->msgs, sink_msg);
}
if (u->ship == sh) {
int dead = 0;
message *msg;
/* if this fails, I misunderstood something: */
for (i = 0; i != u->number; ++i)
if (chance(probability))
++dead;
if (dead != u->number) {
/* she will live. but her items get stripped */
if (dead > 0) {
msg =
msg_message("sink_lost_msg", "dead region unit", dead, safety, u);
}
else {
msg = msg_message("sink_saved_msg", "region unit", safety, u);
}
leave_ship(u);
if (r != safety) {
setguard(u, GUARD_NONE);
}
while (u->items) {
i_remove(&u->items, u->items);
}
move_unit(u, safety, NULL);
}
else {
msg = msg_message("sink_lost_msg", "dead region unit", dead, NULL, u);
}
add_message(&u->faction->msgs, msg);
msg_release(msg);
if (dead == u->number) {
/* the poor creature, she dies */
if (remove_unit(ui, u) != 0) {
ui = &u->next;
}
}
}
}
if (sink_msg)
msg_release(sink_msg);
/* finally, get rid of the ship */
remove_ship(&sh->region->ships, sh);
} }
int sabotage_cmd(unit * u, struct order *ord) int sabotage_cmd(unit * u, struct order *ord)
{ {
const char *s; const char *s;
int i; int i;
ship *sh; ship *sh;
unit *u2; unit *u2;
char buffer[DISPLAYSIZE]; char buffer[DISPLAYSIZE];
region *r = u->region; region *r = u->region;
int skdiff; int skdiff;
init_order(ord); init_order(ord);
s = getstrtoken(); s = getstrtoken();
i = findparam(s, u->faction->locale); i = findparam(s, u->faction->locale);
switch (i) { switch (i) {
case P_SHIP: case P_SHIP:
sh = u->ship; sh = u->ship;
if (!sh) { if (!sh) {
cmistake(u, u->thisorder, 144, MSG_EVENT); cmistake(u, u->thisorder, 144, MSG_EVENT);
return 0; return 0;
} }
u2 = ship_owner(sh); u2 = ship_owner(sh);
skdiff = skdiff =
eff_skill(u, SK_SPY, r) - crew_skill(r, u2->faction, sh, SK_PERCEPTION); eff_skill(u, SK_SPY, r) - crew_skill(r, u2->faction, sh, SK_PERCEPTION);
if (try_destruction(u, u2, sh, skdiff)) { if (try_destruction(u, u2, sh, skdiff)) {
sink_ship(r, sh, buffer, u); sink_ship(r, sh, buffer, u);
} }
break; break;
default: default:
cmistake(u, u->thisorder, 9, MSG_EVENT); cmistake(u, u->thisorder, 9, MSG_EVENT);
return 0; return 0;
} }
return 0; return 0;
} }

6
src/study.c
View file

@ -390,8 +390,10 @@ int teach_cmd(unit * u, struct order *ord)
init_order(ord); init_order(ord);
while (!parser_end()) { while (!parser_end()) {
unit *u2 = getunit_deprecated(r, u->faction); unit *u2;
bool feedback; bool feedback;
getunit(r, u->faction, &u2);
++count; ++count;
/* Falls die Unit nicht gefunden wird, Fehler melden */ /* Falls die Unit nicht gefunden wird, Fehler melden */
@ -406,7 +408,7 @@ int teach_cmd(unit * u, struct order *ord)
for (j = 0; j != count - 1; ++j) { for (j = 0; j != count - 1; ++j) {
/* skip over the first 'count' units */ /* skip over the first 'count' units */
getunit_deprecated(r, u->faction); getunit(r, u->faction, NULL);
} }
token = getstrtoken(); token = getstrtoken();