forked from github/server
610 lines
17 KiB
C
610 lines
17 KiB
C
/* vi: set ts=2:
|
|
*
|
|
*
|
|
* Eressea PB(E)M host Copyright (C) 1998-2003
|
|
* Christian Schlittchen (corwin@amber.kn-bremen.de)
|
|
* Katja Zedel (katze@felidae.kn-bremen.de)
|
|
* Henning Peters (faroul@beyond.kn-bremen.de)
|
|
* Enno Rehling (enno@eressea.de)
|
|
* Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de)
|
|
*
|
|
* based on:
|
|
*
|
|
* Atlantis v1.0 13 September 1993 Copyright 1993 by Russell Wallace
|
|
* Atlantis v1.7 Copyright 1996 by Alex Schröder
|
|
*
|
|
* This program may not be used, modified or distributed without
|
|
* prior permission by the authors of Eressea.
|
|
* This program may not be sold or used commercially without prior written
|
|
* permission from the authors.
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include "eressea.h"
|
|
#include "spy.h"
|
|
|
|
/* kernel includes */
|
|
#include <kernel/build.h>
|
|
#include <kernel/reports.h>
|
|
#include <kernel/item.h>
|
|
#include <kernel/karma.h>
|
|
#include <kernel/faction.h>
|
|
#include <kernel/magic.h>
|
|
#include <kernel/message.h>
|
|
#include <kernel/move.h>
|
|
#include <kernel/race.h>
|
|
#include <kernel/region.h>
|
|
#include <kernel/ship.h>
|
|
#include <kernel/skill.h>
|
|
#include <kernel/terrain.h>
|
|
#include <kernel/unit.h>
|
|
|
|
/* attributes includes */
|
|
#include <attributes/racename.h>
|
|
|
|
/* util includes */
|
|
#include <util/attrib.h>
|
|
#include <util/base36.h>
|
|
#include <util/parser.h>
|
|
#include <util/rand.h>
|
|
#include <util/rng.h>
|
|
#include <util/vset.h>
|
|
|
|
/* libc includes */
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <attributes/otherfaction.h>
|
|
|
|
/* in spy steht der Unterschied zwischen Wahrnehmung des Opfers und
|
|
* Spionage des Spions */
|
|
void
|
|
spy_message(int spy, const unit *u, const unit *target)
|
|
{
|
|
const char * str = report_kampfstatus(target, u->faction->locale);
|
|
|
|
ADDMSG(&u->faction->msgs, msg_message("spyreport", "spy target status", u, target, str));
|
|
if (spy > 20) {
|
|
sc_mage * m = get_mage(target);
|
|
/* bei Magiern Zaubersprüche und Magiegebiet */
|
|
if (m) {
|
|
ADDMSG(&u->faction->msgs, msg_message("spyreport_mage", "target type", target, magietypen[find_magetype(target)]));
|
|
}
|
|
}
|
|
if (spy > 6) {
|
|
faction * fv = visible_faction(u->faction,target);
|
|
if (fv && fv!=target->faction) {
|
|
/* wahre Partei */
|
|
ADDMSG(&u->faction->msgs, msg_message("spyreport_faction", "target faction", target, 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));
|
|
}
|
|
strncat(buf, (const char *)skillname(sv->id, u->faction->locale), sizeof(buf));
|
|
strncat(buf, " ", sizeof(buf));
|
|
strncat(buf, itoa10(eff_skill(target, sv->id, target->region)), sizeof(buf));
|
|
}
|
|
}
|
|
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)
|
|
{
|
|
unit *target;
|
|
int spy, observe;
|
|
double spychance, observechance;
|
|
region * r = u->region;
|
|
|
|
init_tokens(ord);
|
|
skip_token();
|
|
target = getunit(r, u->faction);
|
|
|
|
if (!target) {
|
|
ADDMSG(&u->faction->msgs, 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 für einen erfolgreichen Spionage-Versuch ist 10%.
|
|
* Für jeden Talentpunkt, den das Spionagetalent das Tarnungstalent
|
|
* des Opfers übersteigt, erhöht 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_OBSERVATION, r)
|
|
- (effskill(u, SK_STEALTH) + eff_skill(u, SK_SPY, r)/2);
|
|
|
|
if (invisible(u, target) >= u->number) {
|
|
observe = min(observe, 0);
|
|
}
|
|
|
|
/* Anschließend wird - unabhängig vom Erfolg - gewürfelt, ob der
|
|
* Spionageversuch bemerkt wurde. Die Wahrscheinlich dafür ist (100 -
|
|
* SpionageSpion*5 + WahrnehmungOpfer*2)%. */
|
|
observechance = 1.0 - (eff_skill(u, SK_SPY, r) * 0.05)
|
|
+ (eff_skill(target, SK_OBSERVATION, r) * 0.02);
|
|
|
|
if (chance(observechance)) {
|
|
ADDMSG(&target->faction->msgs, msg_message("spydetect",
|
|
"spy target", observe>0?u:NULL, target));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
setwere_cmd(unit *u, struct order * ord)
|
|
{
|
|
#ifdef KARMA_MODULE
|
|
int level = fspecial(u->faction, FS_LYCANTROPE);
|
|
const char *s;
|
|
|
|
if (!level) {
|
|
cmistake(u, ord, 311, MSG_EVENT);
|
|
return 0;
|
|
}
|
|
|
|
init_tokens(ord);
|
|
skip_token();
|
|
s = getstrtoken();
|
|
|
|
if (s == NULL || *s == '\0') {
|
|
if(fval(u, UFL_WERE)) {
|
|
cmistake(u, ord, 309, MSG_EVENT);
|
|
} else if(rng_int()%100 < 35+(level-1)*20) { /* 35, 55, 75, 95% */
|
|
fset(u, UFL_WERE);
|
|
} else {
|
|
cmistake(u, ord, 311, MSG_EVENT);
|
|
}
|
|
} else if (findparam(s, u->faction->locale) == P_NOT) {
|
|
if(fval(u, UFL_WERE)) {
|
|
cmistake(u, ord, 310, MSG_EVENT);
|
|
} else if(rng_int()%100 < 90-level*20) { /* 70, 50, 30, 10% */
|
|
freset(u, UFL_WERE);
|
|
} else {
|
|
cmistake(u, ord, 311, MSG_EVENT);
|
|
}
|
|
|
|
}
|
|
#endif /* KARMA_MODULE */
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
setstealth_cmd(unit * u, struct order * ord)
|
|
{
|
|
const char *s;
|
|
int level;
|
|
const race * trace;
|
|
|
|
init_tokens(ord);
|
|
skip_token();
|
|
s = getstrtoken();
|
|
|
|
/* Tarne ohne Parameter: Setzt maximale Tarnung */
|
|
|
|
if (s == NULL || *s == 0) {
|
|
u_seteffstealth(u, -1);
|
|
return 0;
|
|
}
|
|
|
|
trace = findrace(s, u->faction->locale);
|
|
if (trace) {
|
|
/* Dämonen können sich nur als andere Spielerrassen tarnen */
|
|
if (u->race == new_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,
|
|
RC_URUK, NORACE };
|
|
int i;
|
|
for (i=0;allowed[i]!=NORACE;++i) if (new_race[allowed[i]]==trace) break;
|
|
if (new_race[allowed[i]]==trace) {
|
|
u->irace = trace;
|
|
if (u->race->flags & RCF_SHAPESHIFTANY && get_racename(u->attribs))
|
|
set_racename(&u->attribs, NULL);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Singdrachen können sich nur als Drachen tarnen */
|
|
if (u->race == new_race[RC_SONGDRAGON] || u->race == new_race[RC_BIRTHDAYDRAGON]) {
|
|
if (trace==new_race[RC_SONGDRAGON]||trace==new_race[RC_FIREDRAGON]||trace==new_race[RC_DRAGON]||trace==new_race[RC_WYRM]) {
|
|
u->irace = trace;
|
|
if (u->race->flags & RCF_SHAPESHIFTANY && get_racename(u->attribs))
|
|
set_racename(&u->attribs, NULL);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Dämomen und Illusionsparteien können sich als andere race tarnen */
|
|
if (u->race->flags & RCF_SHAPESHIFT) {
|
|
if (playerrace(trace)) {
|
|
u->irace = trace;
|
|
if ((u->race->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] */
|
|
s = getstrtoken();
|
|
if(!s || *s == 0) {
|
|
fset(u, UFL_PARTEITARNUNG);
|
|
} else if (findparam(s, u->faction->locale) == P_NOT) {
|
|
freset(u, UFL_PARTEITARNUNG);
|
|
} else if (findkeyword(s, u->faction->locale) == K_NUMBER) {
|
|
const char *s2 = (const char *)getstrtoken();
|
|
int nr = -1;
|
|
|
|
if (s2) nr = atoi36(s2);
|
|
if (!s2 || *s2 == 0 || nr == u->faction->no) {
|
|
a_removeall(&u->attribs, &at_otherfaction);
|
|
} else {
|
|
struct faction * f = findfaction(nr);
|
|
if(f==NULL) {
|
|
cmistake(u, ord, 66, MSG_EVENT);
|
|
} else {
|
|
region * lastr = NULL;
|
|
/* 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
|
|
* avoid testing the same region twice in a row. */
|
|
unit * mu = u->faction->units;
|
|
while (mu!=NULL) {
|
|
unit * ru = mu->region->units;
|
|
if (mu->region!=lastr) {
|
|
lastr = mu->region;
|
|
while (ru!=NULL) {
|
|
faction * fv = visible_faction(f, ru);
|
|
if (fv==f) {
|
|
if (cansee(f, lastr, ru, 0)) break;
|
|
}
|
|
ru = ru->next;
|
|
}
|
|
if (ru!=NULL) break;
|
|
}
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
cmistake(u, ord, 289, MSG_EVENT);
|
|
}
|
|
break;
|
|
case P_ANY:
|
|
/* TARNE ALLES (was nicht so alles geht?) */
|
|
u_seteffstealth(u, -1);
|
|
break;
|
|
#ifdef KARMA_MODULE
|
|
case P_NUMBER:
|
|
/* TARNE ANZAHL [NICHT] */
|
|
if (!fspecial(u->faction, FS_HIDDEN)) {
|
|
cmistake(u, ord, 277, MSG_EVENT);
|
|
return 0;
|
|
}
|
|
s = getstrtoken();
|
|
if (findparam(s, u->faction->locale) == P_NOT) {
|
|
attrib * a = a_find(u->attribs, &at_fshidden);
|
|
if (a==NULL) a->data.ca[0] = 0;
|
|
if (a->data.i == 0) a_remove(&u->attribs, a);
|
|
} else {
|
|
attrib * a = a_find(u->attribs, &at_fshidden);
|
|
if (a!=NULL) a = a_add(&u->attribs, a_new(&at_fshidden));
|
|
a->data.ca[0] = 1;
|
|
}
|
|
break;
|
|
#endif /* KARMA_MODULE */
|
|
#ifdef KARMA_MODULE
|
|
case P_ITEMS:
|
|
/* TARNE GEGENSTÄNDE [NICHT] */
|
|
if(!fspecial(u->faction, FS_HIDDEN)) {
|
|
cmistake(u, ord, 277, MSG_EVENT);
|
|
return 0;
|
|
}
|
|
if (findparam(s, u->faction->locale) == P_NOT) {
|
|
attrib * a = a_find(u->attribs, &at_fshidden);
|
|
if (a!=NULL) a->data.ca[1] = 0;
|
|
if (a->data.i == 0) a_remove(&u->attribs, a);
|
|
} else {
|
|
attrib * a = a_find(u->attribs, &at_fshidden);
|
|
if (a==NULL) a = a_add(&u->attribs, a_new(&at_fshidden));
|
|
a->data.ca[1] = 1;
|
|
}
|
|
break;
|
|
#endif /* KARMA_MODULE */
|
|
case P_NOT:
|
|
u_seteffstealth(u, -1);
|
|
break;
|
|
default:
|
|
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);
|
|
} else if (u->race->flags & RCF_SHAPESHIFTANY) {
|
|
set_racename(&u->attribs, s);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
faction_skill(region * r, faction * f, skill_t sk)
|
|
{
|
|
int value = 0;
|
|
unit *u;
|
|
|
|
for (u=r->units; u; u=u->next) {
|
|
if (u->faction == f) {
|
|
int s = eff_skill(u, sk, r);
|
|
value = max(value, s);
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
static int
|
|
crew_skill(region * r, faction * f, ship * sh, skill_t sk)
|
|
{
|
|
int value = 0;
|
|
unit *u;
|
|
|
|
for (u=r->units;u;u=u->next) {
|
|
if (u->ship == sh && u->faction == f) {
|
|
int s = eff_skill(u, sk, r);
|
|
value = max(s, value);
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
static int
|
|
try_destruction(unit * u, unit * u2, const ship *sh, int skilldiff)
|
|
{
|
|
const char *destruction_success_msg = "destroy_ship_0";
|
|
const char *destruction_failed_msg = "destroy_ship_1";
|
|
const char *destruction_detected_msg = "destroy_ship_2";
|
|
const char *detect_failure_msg = "destroy_ship_3";
|
|
const char *object_destroyed_msg = "destroy_ship_4";
|
|
|
|
if (skilldiff == 0) {
|
|
/* tell the unit that the attempt failed: */
|
|
ADDMSG(&u->faction->msgs, msg_message(destruction_failed_msg, "ship unit", sh, u));
|
|
/* tell the enemy about the attempt: */
|
|
if (u2) {
|
|
ADDMSG(&u2->faction->msgs, msg_message(detect_failure_msg, "ship", sh));
|
|
}
|
|
return 0;
|
|
} else if (skilldiff < 0) {
|
|
/* tell the unit that the attempt was detected: */
|
|
ADDMSG(&u2->faction->msgs, msg_message(destruction_detected_msg, "ship unit", sh, u));
|
|
/* tell the enemy whodunit: */
|
|
if (u2) {
|
|
ADDMSG(&u2->faction->msgs, msg_message(detect_failure_msg, "ship", sh));
|
|
}
|
|
return 0;
|
|
} else {
|
|
/* tell the unit that the attempt succeeded */
|
|
ADDMSG(&u->faction->msgs, msg_message(destruction_success_msg, "ship unit", sh, u));
|
|
if (u2) {
|
|
ADDMSG(&u2->faction->msgs, msg_message(object_destroyed_msg, "ship", sh));
|
|
}
|
|
}
|
|
return 1; /* success */
|
|
}
|
|
|
|
static void
|
|
sink_ship(region * r, ship * sh, const char *name, char spy, unit * saboteur)
|
|
{
|
|
unit **ui;
|
|
region *safety = r;
|
|
int i;
|
|
direction_t d;
|
|
unsigned int index;
|
|
double probability = 0.0;
|
|
vset informed;
|
|
vset survivors;
|
|
message * sink_msg = NULL;
|
|
message * enemy_discovers_spy_msg = NULL;
|
|
|
|
vset_init(&informed);
|
|
vset_init(&survivors);
|
|
|
|
/* 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: */
|
|
vset_add(&informed, u->faction);
|
|
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 */
|
|
{
|
|
vset_add(&survivors, u);
|
|
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);
|
|
}
|
|
set_leftship(u, u->ship);
|
|
u->ship = 0;
|
|
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 */
|
|
*ui = u->next;
|
|
destroy_unit(u);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* inform everyone, and reduce money to the absolutely necessary
|
|
* amount: */
|
|
while (informed.size != 0) {
|
|
unit *lastunit = 0;
|
|
int money = 0, maintain = 0;
|
|
faction * f = (faction *) informed.data[0];
|
|
|
|
/* find out how much money this faction still has: */
|
|
for (index = 0; index != survivors.size; ++index) {
|
|
unit *u = (unit *) survivors.data[index];
|
|
|
|
if (u->faction == f) {
|
|
maintain += maintenance_cost(u);
|
|
money += get_money(u);
|
|
lastunit = u;
|
|
}
|
|
}
|
|
/* 'money' shall be the maintenance-surplus of the survivng
|
|
* units: */
|
|
money = money - maintain;
|
|
for (index = 0; money > 0; ++index) {
|
|
int remove;
|
|
unit *u = (unit *) survivors.data[index];
|
|
|
|
assert(index < survivors.size);
|
|
if (u->faction == f && playerrace(u->race)) {
|
|
remove = min(get_money(u), money);
|
|
money -= remove;
|
|
change_money(u, -remove);
|
|
}
|
|
}
|
|
/* finally, report to this faction that the ship sank: */
|
|
if (sink_msg==NULL) {
|
|
sink_msg = msg_message("sink_msg", "ship region", sh, r);
|
|
}
|
|
add_message(&f->msgs, sink_msg);
|
|
vset_erase(&informed, f);
|
|
if (spy == 1 && f != saboteur->faction && faction_skill(r, f, SK_OBSERVATION) - eff_skill(saboteur, SK_STEALTH, r) > 0) {
|
|
/* the unit is discovered */
|
|
ADDMSG(&f->msgs, msg_message("spy_discovered_msg", "unit saboteur ship", lastunit, saboteur, sh));
|
|
if (enemy_discovers_spy_msg==NULL) {
|
|
enemy_discovers_spy_msg = msg_message("enemy_discovers_spy_msg", "unit ship", saboteur, sh);
|
|
}
|
|
add_message(&saboteur->faction->msgs, sink_msg);
|
|
}
|
|
}
|
|
if (enemy_discovers_spy_msg) msg_release(enemy_discovers_spy_msg);
|
|
if (sink_msg) msg_release(sink_msg);
|
|
/* finally, get rid of the ship */
|
|
destroy_ship(sh);
|
|
vset_destroy(&informed);
|
|
vset_destroy(&survivors);
|
|
}
|
|
|
|
int
|
|
sabotage_cmd(unit * u, struct order * ord)
|
|
{
|
|
const char *s;
|
|
int i;
|
|
ship *sh;
|
|
unit *u2;
|
|
char buffer[DISPLAYSIZE];
|
|
region * r = u->region;
|
|
int skdiff;
|
|
|
|
init_tokens(ord);
|
|
skip_token();
|
|
s = getstrtoken();
|
|
|
|
i = findparam(s, u->faction->locale);
|
|
|
|
switch (i) {
|
|
case P_SHIP:
|
|
sh = u->ship;
|
|
if (!sh) {
|
|
cmistake(u, u->thisorder, 144, MSG_EVENT);
|
|
return 0;
|
|
}
|
|
u2 = shipowner(sh);
|
|
skdiff = eff_skill(u, SK_SPY, r)-crew_skill(r, u2->faction, sh, SK_OBSERVATION);
|
|
if (try_destruction(u, u2, sh, skdiff)) {
|
|
sink_ship(r, sh, buffer, 1, u);
|
|
}
|
|
break;
|
|
default:
|
|
cmistake(u, u->thisorder, 9, MSG_EVENT);
|
|
return 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|