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

noone needs this

This commit is contained in:
Enno Rehling 2003-06-14 17:07:42 +00:00
parent a45f59168b
commit 8bb8488e6a
14 changed files with 0 additions and 2081 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/eressea/old/Makefile
View File

@ -1,30 +0,0 @@
SUBDIRS =
LIBNAME = e-compat
EXENAME =
## cheating: we link all attributes/items/etc for all the games. TODO - don't.
SOURCES = $(wildcard *.c)
OBJECTS = $(SOURCES:%.c=$(BUILD_DIR)/%.o)
include $(ERESSEA_SRC)/Makefile.include
##
## more definitions
##
INCLUDES += \
-I../../common \
-I../../common/util \
-I../../common/kernel
LIBRARIES = $(LIBNAMES:%=$(PUBLISH_DIR)/lib%.a)
LIBS += $(LIBNAMES:%=-l%) -lm
# library:
$(BUILD_DIR)/$(LIBRARY):: $(BUILD_DIR) $(OBJECTS)
$(AR) $(ARFLAGS) $@ $(OBJECTS)
$(INSTALL) $@ $(PUBLISH_DIR)/
$(PUBLISH_DIR)/$(LIBRARY): $(BUILD_DIR)/$(LIBRARY)
$(INSTALL) $< $@

28
src/eressea/old/attrspread.h
View File

@ -1,28 +0,0 @@
/* vi: set ts=2:
*
*
* Eressea PB(E)M host Copyright (C) 1998-2000
* 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-pbem.de)
* Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de)
*
* This program may not be used, modified or distributed without
* prior permission by the authors of Eressea.
*/
#ifndef SPREAD_H
#define SPREAD_H
/* Verhalten von Attibuten auf Units bei GIB PERSONEN */
typedef enum {
SPREAD_NEVER, /* Wird nie mit übertragen */
SPREAD_ALWAYS, /* Wird immer mit übertragen */
SPREAD_MODULO, /* Personenweise Weitergabe */
SPREAD_CHANCE, /* Ansteckungschance je nach Mengenverhältnis */
SPREAD_TRANSFER /* Attribut wird nicht kopiert, sondern "wandert" */
} spread_t;
#endif /* SPREAD_H */

21
src/eressea/old/cr.h
View File

@ -1,21 +0,0 @@
/* vi: set ts=2:
*
*
* Eressea PB(E)M host Copyright (C) 1998-2000
* 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-pbem.de)
* Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de)
*
* This program may not be used, modified or distributed without
* prior permission by the authors of Eressea.
*/
#ifndef _CR_H
#define _CR_H
void cr_faction(FILE * out, struct faction * f);
void cr_region(FILE * out, struct region * r);
#endif

107
src/eressea/old/order.c
View File

@ -1,107 +0,0 @@
/* vi: set ts=2:
+-------------------+ Christian Schlittchen <corwin@amber.kn-bremen.de>
| | Enno Rehling <enno@eressea-pbem.de>
| Eressea PBEM host | Katja Zedel <katze@felidae.kn-bremen.de>
| (c) 1998 - 2001 | Henning Peters <faroul@beyond.kn-bremen.de>
| | Ingo Wilken <Ingo.Wilken@informatik.uni-oldenburg.de>
+-------------------+ Stefan Reich <reich@halbling.de>
This program may not be used, modified or distributed
without prior permission by the authors of Eressea.
*/
#include <config.h>
#include <eressea.h>
#include "order.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
void
append_order(orders * os, order * o)
{
assert(o->next==NULL);
if (os->end==NULL) os->list = o;
else *(os->end) = o;
os->end = &o->next;
}
order *
remove_order(orders * os, order * o)
{
order ** op = &os->list;
while (*op && o!=*op) op=&(*op)->next;
assert(*op);
if (o->next==NULL) os->end=op;
*op = o->next;
o->next = NULL;
return o;
}
void
free_order(order * o)
{
if (o->data.v) {
char ** ca = (char**)o->data.v;
while (*ca) free(*(ca++));
free(o->data.v);
}
free(o);
}
#define MAXPARAM 128
#include "eressea.h"
order *
new_order(const char * cmd)
{
const char * params[MAXPARAM+1];
char ** cp;
int i;
order * o = calloc(sizeof(order), 1);
o->type = igetkeyword(cmd);
for (i=0;i!=MAXPARAM;++i) {
const char * s = getstrtoken();
if (s==NULL || *s==0) break;
params[i] = strdup(s);
}
cp = malloc(sizeof(const char*)*(i+1));
memcpy(cp, params, sizeof(const char*)*i);
cp[i]=NULL;
o->data.v = (void*) cp;
return o;
}
const char *
order_string(const order * o, char * buf, size_t len)
{
char * c;
static char retval[4096];
size_t slen;
if (buf==NULL) {
buf = retval;
len=4096;
}
c = buf;
strncpy(c, locale_string(u->faction->locale, keywords[o->type]), len);
slen = strlen(c);
len -= slen;
c += slen;
if (o->data.v) {
char ** cp = o->data.v;
while (*cp) {
slen = strlen(*cp);
*c = ' ';
if (slen>len-2) {
strncpy(c+1, *cp, len-1);
break;
}
strncpy(c+1, *cp, len);
len -= slen+1;
c += slen+1;
}
}
buf[len-1] = '\0';
return buf;
}

44
src/eressea/old/order.h
View File

@ -1,44 +0,0 @@
/* vi: set ts=2:
*
*
* Eressea PB(E)M host Copyright (C) 1998-2000
* 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-pbem.de)
* Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de)
*
* This program may not be used, modified or distributed without
* prior permission by the authors of Eressea.
*/
#ifndef ORDER_H
#define ORDER_H
#define order_t int
typedef union {
void * v;
int i;
char c;
short s;
short sa[2];
char ca[4];
} variant;
typedef struct order {
struct order * next;
order_t type;
variant data;
} order;
typedef struct orders {
order * list;
order ** end;
} orders;
extern void append_order(orders * os, order * o);
extern order * new_order(const char * cmd);
extern void free_order(order * o);
extern const char * order_string(const order * o, char * buffer, size_t buffersize);
#endif

245
src/eressea/old/pointertags.c
View File

@ -1,245 +0,0 @@
/* vi: set ts=2:
*
*
* Eressea PB(E)M host Copyright (C) 1998-2000
* 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-pbem.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 "pointertags.h"
#include <stdlib.h>
typedef struct ptrlist {
struct ptrlist *next;
void *objPP;
typ_t typ;
} ptrlist;
typedef struct {
tag_t tag;
ptrlist *ptrs;
} ptrref;
static ptrlist *freelist;
/* at_pointer_tag */
static void
tag_init(attrib *a)
{
a->data.v = calloc(1, sizeof(ptrref));
}
static void
tag_done(attrib *a)
{
ptrref *ref;
ptrlist *p;
ref = (ptrref *)a->data.v;
while( (p = ref->ptrs) != NULL ) {
ref->ptrs = p->next;
p->next = freelist;
freelist = p;
}
free(ref);
}
attrib_type at_pointer_tag = {
"pointer tags",
tag_init,
tag_done,
NULL, /* age */
NO_WRITE, /* write */
NO_READ, /* read */
};
static ptrref *
find_ref(attrib **ap, tag_t tag)
{
attrib *a;
ptrref *ref;
a = a_find(*ap, &at_pointer_tag);
while( a ) {
ref = (ptrref *)a->data.v;
if( ref->tag == tag )
return ref;
a = a->nexttype;
}
return NULL;
}
static ptrref *
make_ref(attrib **ap, tag_t tag)
{
attrib *a;
ptrref *ref;
ref = find_ref(ap, tag);
if( !ref ) {
a = a_new(&at_pointer_tag);
a_add(ap, a);
ref = (ptrref *)a->data.v;
ref->ptrs = NULL;
ref->tag = tag;
}
return ref;
}
void
tag_pointer(void *objPP, typ_t typ, tag_t tag)
{
void *obj;
attrib **ap;
ptrref *ref;
ptrlist *p;
obj = typdata[typ].ppget(objPP);
if( !obj )
return;
ap = typdata[typ].getattribs(obj);
ref = make_ref(ap, tag);
if( (p = freelist) != NULL )
freelist = p->next;
else
p = calloc(1, sizeof(ptrlist));
p->objPP = objPP;
p->typ = typ;
p->next = ref->ptrs;
ref->ptrs = p;
}
void
untag_pointer(void *objPP, typ_t typ, tag_t tag)
{
void *obj;
attrib **ap;
ptrref *ref;
ptrlist *p, **prevP;
obj = typdata[typ].ppget(objPP);
if( !obj )
return;
ap = typdata[typ].getattribs(obj);
ref = find_ref(ap, tag);
if( !ref )
return;
prevP = &ref->ptrs;
for( p = ref->ptrs; p; p = p->next ) {
if( p->objPP == objPP ) {
*prevP = p->next; /* unlink */
p->next = freelist; /* p freigeben */
freelist = p;
return;
}
prevP = &p->next;
}
}
int
count_tagged_pointers(void *obj, typ_t typ, tag_t tag)
{
attrib **ap;
ptrref *ref;
ptrlist *p;
int count;
if( !obj )
return 0;
ap = typdata[typ].getattribs(obj);
ref = find_ref(ap, tag);
if( !ref )
return 0;
count = 0;
for( p = ref->ptrs; p; p = p->next )
++count;
return count;
}
int
count_all_pointers(void *obj, typ_t typ)
{
tag_t tag;
int count;
count = 0;
for( tag = 0; tag < MAXTAGS; tag++ )
count += count_tagged_pointers(obj, typ, tag);
return count;
}
static void
change_tagged_pointers(void *obj1, typ_t typ, tag_t tag, void *obj2)
{
attrib **ap;
ptrref *ref1, *ref2 = NULL;
ptrlist *p;
if( !obj1 )
return;
ap = typdata[typ].getattribs(obj1);
ref1 = find_ref(ap, tag);
if( !ref1 )
return;
if( obj2 ) {
ap = typdata[typ].getattribs(obj2);
ref2 = make_ref(ap, tag);
}
while( (p = ref1->ptrs) != NULL ) {
ref1->ptrs = p->next;
typdata[typ].ppset(p->objPP, obj2);
if( obj2 ) {
p->next = ref2->ptrs; /* Referenz jetzt bei obj2 */
ref2->ptrs = p;
} else {
p->next = freelist; /* p freigeben */
freelist = p;
}
}
/* Wir lassen das Attrib mit der leeren Pointer-Liste beim
* Objekt bestehen, das erspart eine De- und Neu-Allokation,
* wenn nochmal Pointer auf dieses Objekt so ge'tag't werden.
*/
}
void
change_all_pointers(void *obj1, typ_t typ, void *obj2)
{
tag_t tag;
for( tag = 0; tag < MAXTAGS; tag++ )
change_tagged_pointers(obj1, typ, tag, obj2);
}

59
src/eressea/old/pointertags.h
View File

@ -1,59 +0,0 @@
/* vi: set ts=2:
*
*
* Eressea PB(E)M host Copyright (C) 1998-2000
* 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-pbem.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.
*/
#if !(defined(OLD_TRIGGER) || defined(CONVERT_TRIGGER))
# error "Do not include unless for old code or to enable conversion"
#endif
#ifndef POINTERTAGS_H
#define POINTERTAGS_H
/* Tags */
typedef enum {
TAG_NORMAL, /* Std-Tag, Ptr wird NULL, wenn Objekt vernichtet wird */
TAG_RELATION, /*unit* in relation-Attribs */
/* Achtung: neue Tags nur über dieser Zeile anfügen, aber unter bereits
* bestehenden! Die Reihenfolge nicht verändern! */
MAXTAGS,
TAG_NOTAG = -1
} tag_t;
#ifndef OBJTYPES_H
#include <objtypes.h>
#endif
extern void tag_pointer(void *objPP, typ_t typ, tag_t tag);
extern void untag_pointer(void *objPP, typ_t typ, tag_t tag);
extern void change_all_pointers(void *obj1, typ_t typ, void *obj2);
extern int count_all_pointers(void *obj, typ_t typ);
extern int count_tagged_pointers(void *obj, typ_t typ, tag_t tag);
#include "attrib.h"
extern attrib_type at_pointer_tag;
#if defined(OLD_TRIGGER) || defined (CONVERT_TRIGGER)
extern void add_ID_resolve2(obj_ID id, void *objPP, typ_t typ, tag_t tag);
#endif
#endif /* POINTERTAGS_H */

261
src/eressea/old/relation.c
View File

@ -1,261 +0,0 @@
/* vi: set ts=2:
*
*
* Eressea PB(E)M host Copyright (C) 1998-2000
* 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-pbem.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 "relation.h"
#if defined(OLD_TRIGGER) || defined(CONVERT_TRIGGER)
/* util includes */
#include <attrib.h>
#include "pointertags.h"
#include <objtypes.h>
#include <stdlib.h>
typedef struct {
void *obj2;
typ_t typ2;
relation_t id;
spread_t spread;
} reldata;
static void
rel_init(attrib *a)
{
reldata *rel;
rel = calloc(1, sizeof(reldata));
rel->obj2 = NULL;
a->data.v = (void *)rel;
}
static void
rel_done(attrib *a)
{
#ifdef OLD_TRIGGER
reldata *rel = (reldata *)a->data.v;
if( rel->obj2 )
untag_pointer(&rel->obj2, rel->typ2, TAG_RELATION);
free(rel);
#else
unused(a);
#endif
}
#ifdef OLD_TRIGGER
static void
rel_save(const attrib *a, FILE *f)
{
reldata *rel = (reldata *)a->data.v;
obj_ID id;
ID_fun fun = typdata[rel->typ2].getID;
id = fun(rel->obj2);
write_ID(f, id);
fprintf(f, "%d %d %d ", rel->typ2, rel->id, rel->spread);
}
#endif
static int
rel_load(attrib *a, FILE *f)
{
reldata *rel = (reldata *)a->data.v;
obj_ID id;
id = read_ID(f);
fscanf(f, "%d %d %d ", (int *)&rel->typ2, (int *)&rel->id, (int *)&rel->spread);
add_ID_resolve2(id, &rel->obj2, rel->typ2, TAG_RELATION);
return 1;
}
#ifdef OLD_TRIGGER
/* garbage collection */
static int
rel_age(attrib *a)
{
reldata *rel = (reldata *)a->data.v;
return (rel->obj2 != NULL);
}
#endif
attrib_type at_relation = {
"unit_relations",
rel_init,
rel_done,
#ifdef CONVERT_TRIGGER
NULL, NULL,
#else
rel_age,
rel_save,
#endif
rel_load,
};
attrib_type at_relbackref = {
"unit_relations_back_reference",
rel_init,
rel_done,
#ifdef CONVERT_TRIGGER
NULL, NULL,
#else
rel_age,
rel_save,
#endif
rel_load,
};
static attrib *
find_rel(attrib **ap, relation_t id, attrib_type *atype)
{
attrib *a;
reldata *rel;
a = a_find(*ap, atype);
while( a ) {
rel = (reldata *)a->data.v;
if( rel->id == id )
return a;
a = a->nexttype;
}
return NULL;
}
static void
rel_create(void *obj1, typ_t typ1,
relation_t id,
void *obj2, typ_t typ2,
spread_t spread,
attrib_type *atype)
{
attrib *a;
attrib **ap;
reldata *rel;
ap = typdata[typ1].getattribs(obj1);
a = find_rel(ap, id, atype);
if( !a ) {
a = a_new(atype);
a_add(ap, a);
rel = (reldata *)a->data.v;
rel->id = id;
} else {
rel = (reldata *)a->data.v;
if( rel->obj2 )
untag_pointer(&rel->obj2, rel->typ2, TAG_RELATION);
}
rel->obj2 = obj2;
tag_pointer(&rel->obj2, typ2, TAG_RELATION);
rel->typ2 = typ2;
rel->spread = spread;
}
static reldata *
rel_get(const void *obj, typ_t typ,
relation_t id,
attrib_type *atype)
{
attrib *a;
attrib **ap;
ap = typdata[typ].getattribs((void *)obj);
a = find_rel(ap, id, atype);
if( a )
return (reldata *)(a->data.v);
return NULL;
}
/*********************************************************
PUBLIC FUNCTIONS
*********************************************************/
void *
get_relation2(const void *obj, typ_t typ, relation_t id, typ_t *typ2P)
{
reldata *rel;
rel = rel_get(obj, typ, id, &at_relation);
if( rel ) {
if( typ2P )
*typ2P = rel->typ2;
return rel->obj2;
}
return NULL;
}
void *
get_relation(const void *obj, typ_t typ, relation_t id)
{
typ_t dummy;
return get_relation2(obj, typ, id, &dummy);
}
void *
get_rev_relation2(void *obj, typ_t typ, relation_t id, typ_t *typ2P)
{
reldata *rel;
rel = rel_get(obj, typ, id, &at_relbackref);
if( rel ) {
if( typ2P )
*typ2P = rel->typ2;
return rel->obj2;
}
return NULL;
}
void *
get_rev_relation(void *obj, typ_t typ, relation_t id)
{
typ_t dummy;
return get_rev_relation2(obj, typ, id, &dummy);
}
void
create_relation(void *obj1, typ_t typ1,
relation_t id,
void *obj2, typ_t typ2,
spread_t spread)
{
rel_create(obj1, typ1, id, obj2, typ2, spread, &at_relation);
rel_create(obj2, typ2, id, obj1, typ1, SPREAD_TRANSFER, &at_relbackref);
}
void
remove_relation(void *obj, typ_t typ, relation_t id)
{
attrib **ap;
attrib *a;
ap = typdata[typ].getattribs(obj);
a = find_rel(ap, id, &at_relation);
if( a ) {
reldata *rel = (reldata *)a->data.v;
obj = rel->obj2; /* Objekt mit Backref-Attrib */
a_remove(ap, a); /* Relation entfernen */
if( obj ) {
ap = typdata[typ].getattribs(obj);
a = find_rel(ap, id, &at_relbackref);
if( a )
a_remove(ap, a); /* Backref entfernen */
}
}
}
#endif

59
src/eressea/old/relation.h
View File

@ -1,59 +0,0 @@
/* vi: set ts=2:
*
*
* Eressea PB(E)M host Copyright (C) 1998-2000
* 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-pbem.de)
* Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de)
*
* This program may not be used, modified or distributed without
* prior permission by the authors of Eressea.
*/
#if !(defined(OLD_TRIGGER) || defined(CONVERT_TRIGGER))
# error "Do not include unless for old code or to enable conversion"
#endif
#ifndef RELATION_H
#define RELATION_H
#if defined(OLD_TRIGGER) || defined(CONVERT_TRIGGER)
/* Einfache Beziehungen zwischen Objekten herstellen ("ich verfolge A",
* "B ist mein Vater", "X ist mein Heimatort"). Werden automatisch
* gespeichert und geladen. Jedes Objekt kann von jedem Relations-Typ
* (d.h. von jeder REL_XXX-Id) nur je eine besitzen. Will man einem
* Objekt zwei "gleiche" Relationen anhängen ("meine Väter sind C und D"),
* so nehme man zwei Ids:
* create_relation(u, TYP_UNIT, REL_DADDY1, uC, TYP_UNIT, SPREAD_ALWAYS);
* create_relation(u, TYP_UNIT, REL_DADDY2, uD, TYP_UNIT, SPREAD_ALWAYS);
*
* Relations werden automatisch gelöscht, wenn das referierte Objekt
* zerstört wird.
*/
#include "objtypes.h"
#include "attrspread.h"
typedef enum {
REL_TARGET, /* Objekt ist mein Ziel */
REL_CREATOR, /* Objekt hat mich erschaffen */
REL_FAMILIAR, /* Zauberer: Objekt ist Vertrauter */
MAXRELATIONS
} relation_t;
void create_relation(void *obj1, typ_t typ1, relation_t id,
void *obj2, typ_t typ2, spread_t spread);
void remove_relation(void *obj1, typ_t typ1, relation_t id);
void *get_relation(const void *obj, typ_t typ, relation_t id);
void *get_relation2(const void *obj, typ_t typ, relation_t id, typ_t *typ2P);
/* umgekehrte Richtung */
void *get_rev_relation(void *obj, typ_t typ, relation_t id);
void *get_rev_relation2(void *obj, typ_t typ, relation_t id, typ_t *typ2P);
#include "attrib.h"
extern attrib_type at_relation;
extern attrib_type at_relbackref;
#endif
#endif

118
src/eressea/old/teleportcrystal.c
View File

@ -1,118 +0,0 @@
/* vi: set ts=2:
+-------------------+ Christian Schlittchen <corwin@amber.kn-bremen.de>
| | Enno Rehling <enno@eressea-pbem.de>
| Eressea PBEM host | Katja Zedel <katze@felidae.kn-bremen.de>
| (c) 1998 - 2001 | Henning Peters <faroul@beyond.kn-bremen.de>
| | Ingo Wilken <Ingo.Wilken@informatik.uni-oldenburg.de>
+-------------------+ Stefan Reich <reich@halbling.de>
This program may not be used, modified or distributed
without prior permission by the authors of Eressea.
*/
#ifdef COMPATIBILITY
/* ------------------------------------------------------------- */
void
use_teleportcrystal(region * r, unit * mage, strlist * cmdstrings)
{
region *target_region = NULL;
unit *target_unit;
strlist *S;
target_unit = getunit(r, mage);
if (target_unit == NULL) {
cmistake(mage, cmdstrings->s, 64, MSG_EVENT);
return;
}
target_region = findunitregion(target_unit);
if (target_unit->faction != mage->faction) {
int kontaktiert = 0;
/* Nun kommt etwas reichlich krankes, um den KONTAKTIERE-Befehl
* des Ziels zu überprüfen. */
if(allied(target_unit, mage->faction, HELP_FIGHT)) {
kontaktiert = 1;
} else {
for (S = target_unit->orders; S; S = S->next) {
if (strncasecmp("KON", S->s, 3) == 0) {
char *c;
int kontakt = -1;
/* Soweit, sogut. S->s ist also ein
* KONTAKTIERE. Nun gilt es, herauszufinden,
* wer kontaktiert wird. Das ist nicht trivial. */
/* Zuerst muß der Parameter herausoperiert
* werden. */
/* Leerzeichen finden */
for (c = S->s; *c != 0; c++) {
if (isspace((int)*c) != 0) {
break;
}
}
/* Wenn ein Leerzeichen da ist, ist *c != 0 und
* zeigt auf das Leerzeichen. */
if (*c == 0) {
continue;
}
kontakt = atoi(c);
if (kontakt == mage->no) {
kontaktiert = 1;
break;
}
}
}
}
if (kontaktiert == 0) {
/* Fehler: "Die Ziel-Einheit hat keinen Kontakt mit uns
* aufgenommen" */
cmistake(mage, cmdstrings->s, 72, MSG_EVENT);
return;
}
if (!can_survive(target_unit, r)) {
cmistake(mage, cmdstrings->s, 231, MSG_EVENT);
return;
}
/* Zahl prüfen */
if (get_item(mage, I_TELEPORTCRYSTAL) < target_unit->number) {
/* Fehler: "Die Einheit hat nicht mehr genug Kristalle fuer so
* viele Personen" */
cmistake(mage, cmdstrings->s, 141, MSG_EVENT);
return;
}
/* Kristalle abziehen */
set_item(mage, I_TELEPORTCRYSTAL,
get_item(mage, I_TELEPORTCRYSTAL) - target_unit->number);
/* Einheit verschieben. Diesmal ohne großen Aufwand, da ja
* immer nur ans Ende der aktuellen Region angehängt werden
* kann. */
move_unit(target_unit, r, NULL);
/* Langen Befehl der Einheit löschen, sonst sind Mehrfachzauber
* möglich */
set_string(&target_unit->thisorder, "");
/* Meldung an die Parteien */
add_message(&mage->faction->msgs, new_message(mage->faction,
"teleport_success%u:unit%r:source%r:target", target_unit, target_region, r));
if (target_unit->faction != mage->faction) {
add_message(&target_unit->faction->msgs, new_message(target_unit->faction,
"teleport_success%u:unit%r:source%r:target", target_unit, target_region, r));
}
}
}
#endif

12
src/eressea/old/teleportcrystal.h
View File

@ -1,12 +0,0 @@
/* vi: set ts=2:
+-------------------+ Christian Schlittchen <corwin@amber.kn-bremen.de>
| | Enno Rehling <enno@eressea-pbem.de>
| Eressea PBEM host | Katja Zedel <katze@felidae.kn-bremen.de>
| (c) 1998 - 2001 | Henning Peters <faroul@beyond.kn-bremen.de>
| | Ingo Wilken <Ingo.Wilken@informatik.uni-oldenburg.de>
+-------------------+ Stefan Reich <reich@halbling.de>
This program may not be used, modified or distributed
without prior permission by the authors of Eressea.
*/
extern void use_teleportcrystal(region * r, unit * mage, strlist * cmdstrings)

916
src/eressea/old/trigger.c
View File

@ -1,916 +0,0 @@
/* vi: set ts=2:
*
*
* Eressea PB(E)M host Copyright (C) 1998-2000
* 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-pbem.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 "trigger.h"
#include <item.h>
#include <faction.h>
#include <unit.h>
#include <region.h>
#include <save.h>
#include <magic.h>
#include <spell.h>
#include <resolve.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#if defined(OLD_TRIGGER) || defined(CONVERT_TRIGGER)
#define NULLSTRING "<iuw_null>"
static int action_resid;
static int timeout_resid;
static int trigger_resid;
static int
make_id(int *itemidP, int *globalidP)
{
if( *(itemidP) <= 0 ) {
(*globalidP)++;
*itemidP = *globalidP;
}
return *itemidP;
}
#define action_id(a) make_id(&(a)->resid, &action_resid)
#define trigger_id(t) make_id(&(t)->resid, &trigger_resid)
#define timeout_id(t) make_id(&(t)->resid, &timeout_resid)
/********** action attribute **********/
static action *all_actions;
static void
action_init(attrib *a)
{
action *act;
act = calloc(1, sizeof(action));
act->next = all_actions;
all_actions = act;
act->magic = ACTION_MAGIC;
a->data.v = act;
}
static void
action_done(attrib *a)
{
action *act = (action *)a->data.v;
if( act->string )
free(act->string);
free(act);
}
#ifdef OLD_TRIGGER
static void
action_save(const attrib *a, FILE *f)
{
action *act = (action *)a->data.v;
int nints, j;
fprintf(f, "%d ", action_id(act));
fprintf(f, "%d ", (int)act->atype);
write_ID(f, get_ID(act->obj, act->typ));
fprintf(f, "%d ", (int)act->typ);
#if RELEASE_VERSION < ACTIONFIX1_VERSION
fprintf(f, "%d %d ", act->i[0], act->i[1]);
#else
for( nints = 0, j = 0; j < ACTION_INTS; j++ ) {
if( act->i[j] != 0 )
nints = j+1;
}
fprintf(f, "%d ", nints);
for( j = 0; j < nints; j++ )
fprintf(f, "%d ", act->i[j]);
#endif
fprintf(f, "%s\n", act->string ? estring(act->string) : NULLSTRING);
}
#endif
static int
action_load(attrib *a, FILE *f)
{
action *act = (action *)a->data.v;
int i, j, nints;
obj_ID id;
fscanf(f, "%d", &i); act->resid = -(i);
fscanf(f, "%d", &i); act->atype = i;
id = read_ID(f);
fscanf(f, "%d", &i); act->typ = i;
add_ID_resolve(id, &act->obj, act->typ);
if( global.data_version < ACTIONFIX1_VERSION )
fscanf(f, "%d %d", &act->i[0], &act->i[1]);
else {
fscanf(f, "%d", &nints);
assert(nints <= ACTION_INTS);
for( j = 0; j < nints ; j++ )
fscanf(f, "%d", &act->i[j]);
}
fscanf(f, "%s", buf);
if( strcmp(buf, NULLSTRING) != 0 )
act->string = strdup(cstring(buf));
else
act->string = NULL;
#if 0
/* speziell für Runde 199->200 */
iuw_fix_action(act);
#endif
/* irace fix für AC_CHANGERACE */
if (act->atype == AC_CHANGERACE){
if (!act->i[1]){
act->i[1] = act->i[0];
while (act->i[1] == RC_DAEMON){
act->i[1] = rand()%11;
}
}
}
return 1;
}
/* garbage collection */
#ifdef OLD_TRIGGER
static int
action_age(attrib *a)
{
action *act = (action *)a->data.v;
if( act->atype == AC_NONE ) {
change_all_pointers(act, TYP_ACTION, NULL); /* zur Sicherheit */
return 0; /* dieses Attrib kann gelöscht werden */
}
/* wenn keine Auslöser (old_trigger/Timeouts) mehr auf uns zeigen, dann
* kann sie auch gelöscht werden.
*/
return (count_all_pointers(act, TYP_ACTION) != 0);
}
#endif
attrib_type at_action = {
"event_action",
action_init,
action_done,
#ifdef CONVERT_TRIGGER
NULL, NULL,
#else
action_age,
action_save,
#endif
action_load,
};
void *
action_resolve(void *pp)
{
int id = (int)pp;
action *a;
for( a = all_actions; a != NULL; a = a->next ) {
if( a->resid == -(id) ) {
return a;
}
}
#ifdef DIE
assert(0);
#else
fprintf(stderr, "WARNING: could not resolve action %d\n", id);
#endif
return NULL;
}
static action *
alloc_action(action_t atype, void *obj2, typ_t typ2, spread_t spr2)
{
attrib *a;
attrib **ap;
action *act;
ap = typdata[typ2].getattribs(obj2);
a = a_new(&at_action);
a_add(ap, a);
act = (action *)a->data.v;
act->atype = atype;
act->obj = obj2;
act->typ = typ2;
act->spread = spr2;
return act;
}
/********** actionlist **********/
static actionlist *
new_actionlist_entry(actionlist **al_startP)
{
actionlist *al;
al = calloc(1, sizeof(actionlist));
al->next = (*al_startP);
(*al_startP) = al;
return al;
}
static void
add_actionlist_entry(actionlist **al_startP, action *a)
{
actionlist *al;
al = new_actionlist_entry(al_startP);
al->act = a;
tag_pointer(&al->act, TYP_ACTION, TAG_NORMAL);
}
static void
free_actionlist_entry(actionlist *al)
{
#if 0
if( al->act )
untag_pointer(&al->act, TYP_ACTION, TAG_NORMAL);
free(al);
#endif
}
static void
free_actionlist(actionlist *al_start)
{
actionlist *al;
while( (al = al_start)!=NULL ) {
al_start = al->next;
free_actionlist_entry(al);
}
}
static void
save_actionlist(actionlist *al_start, FILE *f)
{
actionlist *al;
int count;
count = 0;
for( al = al_start; al != NULL; al = al->next ) {
if( al->act && al->act->atype != AC_NONE )
++count;
}
fprintf(f, " %d\n", count);
for( al = al_start; al != NULL; al = al->next ) {
if( al->act && al->act->atype != AC_NONE )
save_action_pointer(f, al->act, TAG_NORMAL);
}
}
static actionlist *
load_actionlist(FILE *f)
{
actionlist *al, *al_start = NULL;
int count;
fscanf(f, "%d", &count);
while( count-- ) {
al = new_actionlist_entry(&al_start);
load_action_pointer(f, &al->act);
}
return al_start;
}
/********** old_trigger attribute **********/
static old_trigger *all_triggers;
static void
trigger_init(attrib *a)
{
old_trigger *t;
t = calloc(1, sizeof(old_trigger));
a->data.v = t;
}
static void
trigger_done(attrib *a)
{
old_trigger *t = (old_trigger *)a->data.v;
free_actionlist(t->acts);
while (t->attribs) {
a_remove(&t->attribs, t->attribs);
}
free(t);
}
#ifdef OLD_TRIGGER
static void
trigger_save(const attrib *a, FILE *f)
{
old_trigger *t = (old_trigger *)a->data.v;
fprintf(f, "%d ", trigger_id(t));
write_ID(f, get_ID(t->obj, t->typ));
fprintf(f, "%d ", (int)t->typ);
fprintf(f, "%d ", (int)t->condition);
save_actionlist(t->acts, f);
}
#endif
static int
trigger_load(attrib *a, FILE *f)
{
old_trigger *t = (old_trigger *)a->data.v;
int i;
obj_ID id;
fscanf(f, "%d", &i); t->resid = -(i);
id = read_ID(f);
fscanf(f, "%d", &i); t->typ = i;
add_ID_resolve(id, &t->obj, t->typ);
fscanf(f, "%d", &i); t->condition = i;
t->acts = load_actionlist(f);
return 1;
}
#ifdef OLD_TRIGGER
/* garbage collection */
static int
trigger_age(attrib *a)
{
old_trigger *t = (old_trigger *)a->data.v;
actionlist *al;
int count;
if( t->condition == TR_NONE ) {
change_all_pointers(t, TYP_TRIGGER, NULL); /* zur Sicherheit */
return 0;
}
count = 0;
for( al = t->acts; al != NULL; al = al->next ) {
if( al->act != NULL )
++count;
}
/* wenn keine Aktionen mehr von diesem old_trigger abhängen, dann
* kann dieses Attrib gelöscht werden.
*/
return (count != 0);
}
#endif
attrib_type at_trigger = {
"event_trigger",
trigger_init,
trigger_done,
#ifdef CONVERT_TRIGGER
NULL, NULL,
#else
trigger_age,
trigger_save,
#endif
trigger_load,
};
void *
trigger_resolve(void * data)
{
int id = (int)data;
old_trigger *a;
for( a = all_triggers; a != NULL; a = a->next ) {
if( a->resid == -(id) ) {
return a;
}
}
#ifdef DIE
assert(0);
#else
fprintf(stderr, "WARNING: could not resolve old_trigger %d\n", id);
#endif
return NULL;
}
/********** timeout **********/
timeout *all_timeouts;
static timeout *
alloc_timeout(int ticks)
{
timeout *t;
t = calloc(1, sizeof(timeout));
t->next = all_timeouts;
all_timeouts = t;
t->ticks = ticks;
return t;
}
/******************************************************/
static actionlist *datalist, *deathlist;
static void
prepare_actions(actionlist **al_startP)
{
actionlist *al;
while( (al = *al_startP)!=NULL ) {
*al_startP = al->next; /* unlink */
/* TODO */
if( !al->act ) continue;
if( al->act->atype == AC_DESTROY ) {
al->next = deathlist;
deathlist = al;
} else {
al->next = datalist;
datalist = al;
}
}
}
static void
do_actions(void)
{
actionlist *al;
action *act;
static int in_progress;
if( in_progress )
return;
in_progress = 1;
for(;;) {
if( datalist ) {
al = datalist;
datalist = al->next;
} else if( deathlist ) {
al = deathlist;
deathlist = al->next;
} else
break; /* keine Einträge mehr in den Listen */
act = al->act;
free_actionlist_entry(al);
if( !act )
continue;
switch( act->atype ) {
case AC_NONE:
break;
case AC_DESTROY:
if( typdata[act->typ].destroy )
typdata[act->typ].destroy(act->obj);
break;
case AC_REMOVECURSE: {
attrib **ap;
ap = typdata[act->typ].getattribs(act->obj);
remove_curse(ap, (curse_t)act->i[0], act->i[1]);
break;
}
case AC_REMOVERELATION:
remove_relation(act->obj, act->typ, act->i[0]);
break;
case AC_SENDMESSAGE: {
unit *u;
assert(act->typ == TYP_UNIT);
u = (unit*)act->obj;
addmessage(u->region, u->faction, act->string, act->i[0], act->i[1]);
break;
}
case AC_CHANGERACE: {
unit *u;
assert(act->typ == TYP_UNIT);
u = (unit*)act->obj;
if(u->race == RC_TOAD && rand()%100 > 20){
change_item(u, I_TOADSLIME, 1);
}
u->race = (race_t)act->i[0];
u->irace = (race_t)act->i[1];
break;
}
case AC_CHANGEIRACE: {
unit *u;
assert(act->typ == TYP_UNIT);
u = (unit*)act->obj;
u->irace = (race_t)act->i[0];
break;
}
case AC_SHOCK:
assert(act->typ == TYP_UNIT);
do_shock((unit*)act->obj, "");
break;
case AC_CHANGEFACTION: {
faction *f;
assert(act->typ == TYP_UNIT);
f = findfaction_unique_id(act->i[0]);
u_setfaction((unit*)act->obj, f);
break;
}
case AC_CREATEUNIT:{
faction *f;
f = findfaction_unique_id(act->i[0]);
createunit((region *)act->obj, f, act->i[1], (race_t)act->i[2]);
break;
}
case AC_CREATEMAGICBOOSTCURSE:{
unit *mage = (unit*)act->obj;
create_curse(mage, &mage->attribs, C_AURA, 0, act->i[0], 6, 50, 1);
break;
}
default:
assert(0);
}
remove_action(act);
}
in_progress = 0;
}
/***************************************************************
PUBLIC FUNCTIONS
***************************************************************/
struct old_trigger *
create_trigger(void *obj1, typ_t typ1, spread_t spread1, trigger_t condition)
{
attrib *a;
attrib **ap;
old_trigger *t;
ap = typdata[typ1].getattribs(obj1);
a = a_new(&at_trigger);
a_add(ap, a);
t = (old_trigger *)a->data.v;
t->obj = obj1;
t->typ = typ1;
t->condition = condition;
t->spread = spread1;
return t;
}
#if 0
attrib *
a_find_by_vdata(attrib *attrs, const attrib_type *atP, void *vdata)
{
attrib *a;
a = a_find(attrs, atP);
while( a ) {
if( a->data.v == vdata )
return a;
a = a->nexttype;
}
return NULL;
}
#endif
void
remove_trigger(old_trigger *t)
{
#if 0
attrib *a;
attrib **ap;
#endif
if( t ) {
change_all_pointers(t, TYP_TRIGGER, NULL);
t->condition = TR_NONE;
/* die Struktur selber bleibt bis zum Ende des Programms im
* Speicher, weil evtl noch Stackvariablen hierauf zeigen.
*/
#if 0
ap = typdata[t->typ].getattribs(t->obj);
a = a_find_by_vdata(*ap, &at_trigger, (void *)t);
assert(a != NULL);
a_remove(ap, a);
#endif
}
}
extern void ur_add2(int id, void ** ptrptr, typ_t typ, tag_t tag, resolve_fun fun);
void
do_trigger(void *obj1, typ_t typ1, trigger_t condition)
{
#if 0
attrib *a, *next_a;
attrib **ap;
old_trigger *t;
assert(condition != TR_NONE);
ap = typdata[typ1].getattribs(obj1);
a = a_find(*ap, &at_trigger);
while( a ) {
next_a = a->nexttype;
t = (old_trigger *)a->data.v;
if( t->condition == condition ) {
prepare_actions(&t->acts);
t->condition = TR_NONE;
#if 0
a_remove(ap, a);
#endif
}
a = next_a;
}
do_actions();
#endif
}
/******************************************/
struct timeout *
create_timeout(int ticks)
{
return alloc_timeout(ticks+1);
}
void
remove_timeout(timeout *t)
{
if( t ) {
change_all_pointers(t, TYP_TIMEOUT, NULL);
/* die Timeout-Struktur selber bleibt noch bis zum Ende des
* Programms erhalten, weil evtl noch Stackvariablen hierauf
* zeigen.
*/
t->ticks = -1;
free_actionlist(t->acts);
t->acts = NULL;
}
}
void
save_timeout_pointer(FILE *f, timeout *ptr, tag_t tag)
{
if( ptr && ptr->ticks < 0 )
ptr = NULL;
fprintf(f, " %d %d ", ptr ? timeout_id(ptr) : 0, (int)tag);
}
void
save_timeouts(FILE *f)
{
timeout *t;
int count;
count = 0;
for( t = all_timeouts; t != NULL; t = t->next ) {
if( t->ticks > 0 )
++count;
}
fprintf(f, "\n%d\n", count);
for( t = all_timeouts; t != NULL; t = t->next ) {
if( t->ticks > 0 ) {
fprintf(f, " %d", timeout_id(t));
fprintf(f, " %d", t->ticks);
save_actionlist(t->acts, f);
fprintf(f, "\n");
}
}
}
void
load_timeouts(FILE *f)
{
timeout *t;
int count, ticks, id;
fscanf(f, "%d", &count);
while( count-- ) {
fscanf(f, "%d", &id);
fscanf(f, "%d", &ticks);
t = alloc_timeout(ticks);
t->resid = -(id);
t->acts = load_actionlist(f);
}
}
/******************************************/
void
link_action_trigger(struct action *a, struct old_trigger *t)
{
add_actionlist_entry(&t->acts, a);
}
void
link_action_timeout(struct action *a, struct timeout *t)
{
add_actionlist_entry(&t->acts, a);
}
/******************************************/
void
countdown_timeouts(void)
{
timeout *t;
for( t = all_timeouts; t != NULL; t = t->next ) {
t->ticks--;
if( t->ticks == 0 )
prepare_actions(&t->acts);
}
do_actions();
}
/********************************************************/
void
save_action_pointer(FILE *f, action *ptr, tag_t tag)
{
if( ptr && ptr->atype == AC_NONE )
ptr = NULL;
fprintf(f, " %d %d ", ptr ? action_id(ptr) : 0, (int)tag);
}
int
load_action_pointer(FILE *f, action **ptrP)
{
int id, tag;
fscanf(f, "%d %d", &id, &tag);
if( id )
/* TODO: cast void ** richtig? */
ur_add2(id, (void **)ptrP, TYP_ACTION, (tag_t)tag, action_resolve);
else
*ptrP = NULL;
return id;
}
void
remove_all_actions(void *obj, typ_t typ)
{
attrib *a;
attrib **ap;
action *act;
ap = typdata[typ].getattribs(obj);
a = a_find(*ap, &at_action);
while( a ) {
act = (action *)a->data.v;
change_all_pointers(act, TYP_ACTION, NULL);
act->atype = AC_NONE;
a = a->nexttype;
}
}
void
remove_action(action *act)
{
#if 0
attrib **ap;
attrib *a;
#endif
if( act ) {
change_all_pointers(act, TYP_ACTION, NULL);
act->atype = AC_NONE;
/* die Aktionsstruktur selber bleibt noch erhalten und wird erst
* beim Garbage Collect vorm Speichern gelöscht, weil evtl noch
* lokale Stackvariablen auf diese Struktur zeigen.
*/
#if 0
ap = typdata[act->typ].getattribs(act->obj);
a = a_find_by_vdata(*ap, &at_action, (void *)act);
assert(a != NULL);
a_remove(ap, a);
#endif
}
}
/************ Frontends für die einzelnen Aktionen *************/
struct action *
action_destroy(void *obj2, typ_t typ2, spread_t spr2)
{
return alloc_action(AC_DESTROY, obj2, typ2, spr2);
}
struct action *
action_removecurse(void *obj2, typ_t typ2, spread_t spr2, curse_t id, int id2)
{
action *ac;
ac = alloc_action(AC_REMOVECURSE, obj2, typ2, spr2);
ac->i[0] = (int)id;
ac->i[1] = id2;
return ac;
}
struct action *
action_removerelation(void *obj2, typ_t typ2, spread_t spr2, relation_t id)
{
action *ac;
ac = alloc_action(AC_REMOVERELATION, obj2, typ2, spr2);
ac->i[0] = (int)id;
return ac;
}
struct action *
action_sendmessage(void *obj2, typ_t typ2, spread_t spr2,
char *m, msg_t mtype, int mlevel)
{
action *ac;
assert(typ2 == TYP_UNIT);
ac = alloc_action(AC_SENDMESSAGE, obj2, typ2, spr2);
ac->string = strdup(m);
ac->i[0] = (int)mtype;
ac->i[1] = mlevel;
return ac;
}
struct action *
action_changeirace(void *obj2, typ_t typ2, spread_t spr2,
race_t race)
{
action *ac;
assert(typ2 == TYP_UNIT);
ac = alloc_action(AC_CHANGEIRACE, obj2, typ2, spr2);
ac->i[0] = (int)race;
return ac;
}
struct action *
action_changerace(void *obj2, typ_t typ2, spread_t spr2,
race_t race, race_t irace)
{
action *ac;
assert(typ2 == TYP_UNIT);
ac = alloc_action(AC_CHANGERACE, obj2, typ2, spr2);
ac->i[0] = (int)race;
ac->i[1] = (int)irace;
return ac;
}
struct action *
action_shock(void *obj2, typ_t typ2, spread_t spr2)
{
action *ac;
assert(typ2 == TYP_UNIT);
ac = alloc_action(AC_SHOCK, obj2, typ2, spr2);
return ac;
}
struct action *
action_changefaction(void *obj2, typ_t typ2, spread_t spr2,
int unique_id)
{
action *ac;
assert(typ2 == TYP_UNIT);
ac = alloc_action(AC_CHANGEFACTION, obj2, typ2, spr2);
ac->i[0] = unique_id;
return ac;
}
struct action *
action_createunit(void *obj2, typ_t typ2, spread_t spr2,
int fno, int number, race_t race)
{
action *ac;
assert(typ2 == TYP_REGION);
ac = alloc_action(AC_CREATEUNIT, obj2, typ2, spr2);
ac->i[0] = fno;
ac->i[1] = number;
ac->i[2] = race;
return ac;
}
struct action *
action_createmagicboostcurse(void *obj2, typ_t typ2, spread_t spr2, int power)
{
action *ac;
assert(typ2 == TYP_UNIT);
ac = alloc_action(AC_CREATEMAGICBOOSTCURSE, obj2, typ2, spr2);
ac->i[0] = power;
return ac;
}
#endif

94
src/eressea/old/trigger.h
View File

@ -1,94 +0,0 @@
/* vi: set ts=2:
*
*
* Eressea PB(E)M host Copyright (C) 1998-2000
* 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-pbem.de)
* Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de)
*
* This program may not be used, modified or distributed without
* prior permission by the authors of Eressea.
*/
#if !(defined(OLD_TRIGGER) || defined(CONVERT_TRIGGER))
# error "Do not include unless for old code or to enable conversion"
#endif
#ifndef TRIGGER_H
#define TRIGGER_H
#include "relation.h"
#include "attrspread.h"
/* Ausloeser/Conditions */
typedef enum {
TR_NONE, /* wird intern benutzt, nicht verwenden */
TR_DESTRUCT, /* wenn das Objekt stirbt/zerstört wird */
MAX_TRIGGER_T /* must be last */
} trigger_t;
#include "trigger_internal.h"
/* old_trigger functions */
old_trigger *create_trigger(void *obj1, typ_t typ1, spread_t spread1,
trigger_t condition);
void remove_trigger(old_trigger *t);
void do_trigger(void *obj1, typ_t typ1, trigger_t condition);
/* timeout functions */
#include "pointertags.h"
timeout *create_timeout(int ticks);
void remove_timeout(timeout *t);
void save_timeout_pointer(FILE *f, timeout *t, tag_t tag);
void save_timeouts(FILE *f);
void load_timeouts(FILE *f);
void countdown_timeouts(void);
/* link */
void link_action_trigger(action *a, old_trigger *t);
void link_action_timeout(action *a, timeout *t);
/* action functions */
void remove_action(action *a);
void remove_all_actions(void *obj, typ_t typ);
void save_action_pointer(FILE *f, action *a, tag_t tag);
int load_action_pointer(FILE *f, action **aP);
action *action_destroy(void *obj2, typ_t typ2, spread_t spread2);
action *action_removecurse(void *obj2, typ_t typ2, spread_t spread2,
curse_t id, int id2);
action *action_removerelation(void *obj2, typ_t typ2, spread_t spread2,
relation_t id);
action *action_sendmessage(void *obj2, typ_t typ2, spread_t spread2,
char *m, msg_t mtype, int mlevel);
action *action_changeirace(void *obj2, typ_t typ2, spread_t spread2,
race_t race);
action *action_changerace(void *obj2, typ_t typ2, spread_t spread2,
race_t race, race_t irace);
action *action_shock(void *obj2, typ_t typ2, spread_t spread2);
action *action_changefaction(void *obj2, typ_t typ2, spread_t spread2,
int unique_faction_id);
struct action * action_createunit(void *obj2, typ_t typ2, spread_t spr2,
int fno, int number, race_t race);
struct action * action_createmagicboostcurse(void *obj2, typ_t typ2, spread_t spr2,
int power);
#include "attrib.h"
extern attrib_type at_trigger;
extern attrib_type at_action;
#endif /* TRIGGER_H */

87
src/eressea/old/trigger_internal.h
View File

@ -1,87 +0,0 @@
/* vi: set ts=2:
*
*
* Eressea PB(E)M host Copyright (C) 1998-2000
* 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-pbem.de)
* Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de)
*
* This program may not be used, modified or distributed without
* prior permission by the authors of Eressea.
*/
#if !(defined(OLD_TRIGGER) || defined(CONVERT_TRIGGER))
# error "Do not include unless for old code or to enable conversion"
#endif
#ifndef TRIGGER_INTERNAL_H
#define TRIGGER_INTERNAL_H
#ifndef OBJTYPES_H
# include <old/objtypes.h>
#endif
typedef enum {
AC_NONE, /* wird intern verwendet, nicht benutzen! */
AC_DESTROY,
AC_REMOVECURSE,
AC_REMOVERELATION,
AC_SENDMESSAGE,
AC_CHANGERACE,
AC_SHOCK,
AC_CHANGEFACTION,
AC_CREATEUNIT,
AC_CHANGEIRACE,
AC_CREATEMAGICBOOSTCURSE,
MAX_ACTION_T
} action_t;
#define ACTION_MAGIC 0xC0DEBABE
typedef struct action {
int magic;
struct action *next; /* Link in globaler action-List */
int resid; /* temporäre resolve-id */
attrib *attribs; /* für pointertags */
action_t atype;
void *obj; /* points to self */
typ_t typ;
spread_t spread;
/* arguments */
#define ACTION_INTS 4
int i[ACTION_INTS];
char *string;
} action;
typedef struct actionlist {
struct actionlist *next;
action *act;
} actionlist;
typedef struct old_trigger {
struct old_trigger *next; /* Link in globaler old_trigger-List */
int resid; /* temporäre resolve-id */
attrib *attribs; /* für pointertags */
void *obj; /* points to self */
typ_t typ;
trigger_t condition;
spread_t spread;
actionlist *acts;
} old_trigger;
typedef struct timeout {
struct timeout *next;
int resid; /* temporäre resolve-id */
attrib *attribs; /* für pointertags */
int ticks;
actionlist *acts;
} timeout;
#endif /* TRIGGER_INTERNAL_H */