- Ein Haufen kleiner Dinge, und ein crashfix in Bauernblut.

src/common/gamecode/creport.c

@@ -680,6 +680,7 @@ cr_output_unit(FILE * F, const region * r,
   if (u->faction == f || omniscient(f)) {
     order * ord;
     const char *c;
+    char * cmd;
     int i;
     const attrib * a;
 
@@ -716,10 +717,16 @@ cr_output_unit(FILE * F, const region * r,
 
     /* default commands */
     fprintf(F, "COMMANDS\n");
-	  if (u->lastorder) fprintf(F, "\"%s\"\n", getcommand(u->lastorder));
+    if (u->lastorder) {
+      cmd = getcommand(u->lastorder);
+      fprintf(F, "\"%s\"\n", cmd);
+      free(cmd);
+    }
     for (ord = u->orders; ord; ord = ord->next) {
       if (is_persistent(ord) && ord!=u->lastorder) {
-                    fprintf(F, "\"%s\"\n", getcommand(ord));
+        cmd = getcommand(ord);
+        fprintf(F, "\"%s\"\n", cmd);
+        free(cmd);
       }
     }
 

src/common/gamecode/monster.c

@@ -740,72 +740,6 @@ random_growl(void)
 
 extern attrib_type at_direction;
 
-static void
-make_ponnuki(void)
-{
-	int ponn = atoi36("ponn");
-	unit * u = ufindhash(ponn);
-	region * r = findregion(-67,-5);
-	if (u || !r) return;
-	u = createunit(r, findfaction(MONSTER_FACTION), 1, new_race[RC_ILLUSION]);
-	u->irace = new_race[RC_GOBLIN];
-	set_string(&u->name, "Ponnuki");
-	set_string(&u->display, "Go, Ponnuki, Go.");
-    uunhash(u);
-	u->no = ponn;
-	uhash(u);
-
-	/* 'andere' ponnukis mit eigener nummer */
-	ponn = atoi36("255x");
-	do {
-		u = ufindhash(ponn);
-		if (!u) break;
-		uunhash(u);
-		u->no = newunitid();
-		uhash(u);
-	} while (u);
-}
-
-static void ponnuki(unit * u)
-{
-	const char* joke[] = {
-		"Ein Bummerang ist, wenn man ihn wegwirft und er kommt nicht wieder, dann war's keiner.",
-
-		"Ein Riese und ein Zwerg sitzen an der Bar und trinken Bier. Der Zwerg spuckt - tftftf - dem Riesen ins Bier.\n"
-		"Riese: Hör auf, oder ich reiß Dir ein Ohr ab!\n"
-		"Zwerg: Mir egal, bei uns Zwergen wachsen die Ohren nach! - tftftf\n"
-		"Riese: Wenn Du nicht sofort aufhörst, reiße ich Dir ein Bein aus!\n"
-		"Zwerg: Na und, bei uns Zwergen wachsen Beine nach - tftftf\n"
-		"Riese: Jetzt reichts aber wirklich! Schluß, oder ich reiße Dir den\n"
-		"Schniedel aus.\n"
-		"Zwerg: Probier's doch, wir Zwerge haben gar keinen Schniedel - tftftf\n"
-		"Riese (verblüfft): So, und wie pinkelt Ihr dann???\n"
-		"Zwerg: tftftf",
-
-		"Ein Ingenieur und ein Mathematiker sitzen zusammen in einem Vortrag über Kulza-Klein Theorie, die sich mit\n"
-		"11, 12 und sogar höheren Dimensionen beschäftig. Der Mathematiker geniesst die Vorlesung, während der\n"
-		"Ingenieur immer mehr verwirrt aussieht. Als der Vortrag zu ende ist, hat der Ingenieur schreckliche\n"
-		"Kopfschmerzen davon.\n"
-		"\n"
-		"Ingenieur: Wie kannst du nur diesen schrecklichen, abgehobenen Vortrag verstehen?\n"
-		"Mathematiker: Ich stelle mir das ganze einfach vor.\n"
-		"Ingenieur: Wie kannst du dir einen 11-dimensionalen Raum vorstellen???\n"
-		"Mathematiker: Nun, ich stelle mir einen n-dimensionalen Raum vor und lasse dann n gegen 11 gehen..",
-
-		"Merke: Mit Schwabenwitzen soll man ganz sparsam sein.",
-
-		"F: Was bekommt man, wenn man Katzen und Elfen kreuzt?\nA: Elfen ohne Rheuma.",
-
-		"F: Was bekommt man, wenn man Insekten und Katzen kreuzt?\nA: Tiger, die Crisan benutzen.",
-
-		NULL };
-	int jokes = 0;
-
-	while(joke[jokes]) jokes++;
-	if (jokes) addmessage(u->region, 0, joke[rand() % jokes], MSG_MESSAGE, ML_IMPORTANT);
-
-}
-
 static void
 learn_monster(unit *u)
 {
@@ -981,13 +915,10 @@ void
 plan_monsters(void)
 {
   region *r;
-  faction *f;
   unit *u;
   attrib *ta;
 
-  u = findunitg(atoi36("ponn"), NULL);
+  faction *f = findfaction(MONSTER_FACTION);
-  if (!u) make_ponnuki();
-  f = findfaction(MONSTER_FACTION);
   if (!f)
     return;
 
@@ -1065,10 +996,6 @@ plan_monsters(void)
         /* Ab hier noch nicht generalisierte Spezialbehandlungen. */
 
         switch (old_race(u->race)) {
-        case RC_ILLUSION:
-          if (u->no==atoi36("ponn")) ponnuki(u);
-          break;
-          /* Alp */
         case RC_ALP:
           monster_seeks_target(r, u);
           break;

src/common/gamecode/randenc.c

@@ -960,7 +960,7 @@ move_iceberg(region *r)
 	}
 }
 
-void
+static void
 move_icebergs(void)
 {
 	region *r;
@@ -987,6 +987,7 @@ create_icebergs(void)
 		region *rc;
 		unit *u;
 
+    freset(r, RF_DH);
 		for (dir=0; dir < MAXDIRECTIONS; dir++) {
 			rc = rconnect(r, dir);
 			if (rc && rterrain(rc) == T_OCEAN) {
@@ -1009,7 +1010,7 @@ create_icebergs(void)
 	}
 }
 
-void
+static void
 godcurse(void)
 {
   region *r;
@@ -1076,26 +1077,16 @@ check_split(void)
   }
 }
 
-void
+/** handles the "orcish" curse that makes units grow like old orks
-randomevents(void)
+ * This would probably be better handled in an age-function for the curse,
+ * but it's now being called by randomevents()
+ */
+static void
+orc_growth(void)
 {
-	faction *f;
+  region * r;
-	region *r;
-	building *b, *b2;
-	unit *u;
-
-	/* Eiseberge */
-	for (r=regions; r; r=r->next) freset(r, RF_DH);
-	create_icebergs();
-	move_icebergs();
-
-	godcurse();
-
-	for (r=regions; r; r=r->next) {
-		drown(r);
-	}
-
   for (r = regions; r; r = r->next) {
+    unit *u;
     for (u = r->units; u; u = u->next) {
       curse *c = get_curse(u->attribs, ct_find("orcish"));
       if (c && !has_skill(u, SK_MAGIC) && !has_skill(u, SK_ALCHEMY)) {
@@ -1119,10 +1110,17 @@ randomevents(void)
       }
     }
   }
+}
 
-	/* Talentverschiebung: Talente von Dämonen verschieben sich */
+/** Talente von Dämonen verschieben sich.
+ */
+static void
+demon_skillchanges(void)
+{
+  region * r;
 
   for (r = regions; r; r = r->next) {
+    unit * u;
     for (u = r->units; u; u = u->next) {
       if (u->race == new_race[RC_DAEMON]) {
         skill * sv = u->skills;
@@ -1145,6 +1143,34 @@ randomevents(void)
       }
     }
   }
+}
+
+/** Eisberge entstehen und bewegen sich.
+ * Einheiten die im Wasser landen, ertrinken.
+ */
+static void 
+icebergs(void)
+{
+  region * r;
+  create_icebergs();
+  move_icebergs();
+  for (r=regions; r; r=r->next) {
+    drown(r);
+  }
+}
+
+void
+randomevents(void)
+{
+	faction *f;
+	region *r;
+	building *b, *b2;
+	unit *u;
+
+  icebergs();
+  godcurse();
+  orc_growth();
+  demon_skillchanges();
 
 #if RACE_ADJUSTMENTS == 0
 	/* Orks vermehren sich */

src/common/kernel/eressea.c

@@ -1218,7 +1218,10 @@ init_tokens_str(const char * initstr)
 void
 init_tokens(const struct order * ord)
 {
-  init_tokens_str(getcommand(ord));
+  static char * cmd = NULL;
+  if (cmd!=NULL) free(cmd);
+  cmd = getcommand(ord);
+  init_tokens_str(cmd);
 }
 
 void 

src/common/kernel/eressea.h

@@ -378,7 +378,7 @@ typedef struct ursprung {
 
 /* ----------------- Befehle ----------------------------------- */
 
-typedef int keyword_t;
+typedef unsigned char keyword_t;
 enum {
   K_KOMMENTAR,
   K_BANNER,

src/common/kernel/kernel.vcproj

@@ -233,9 +233,6 @@
 			<File
 				RelativePath=".\order.h">
 			</File>
-			<File
-				RelativePath=".\orders.h">
-			</File>
 			<File
 				RelativePath=".\pathfinder.h">
 			</File>
@@ -354,9 +351,6 @@
 		<File
 			RelativePath=".\order.c">
 		</File>
-		<File
-			RelativePath=".\orders.c">
-		</File>
 		<File
 			RelativePath=".\pathfinder.c">
 		</File>

src/common/kernel/magic.c

@@ -1859,7 +1859,7 @@ add_spellparameter(region *target_r, unit *u, const char *syntax, struct order *
 	par = calloc(1, sizeof(spellparameter));
 
 	/* Temporären Puffer initialisieren */
-	tbuf = strdup(getcommand(ord));
+	tbuf = getcommand(ord);
 
 	/* Tokens zählen */
 	token = strtok(tbuf, " ");
@@ -1867,6 +1867,7 @@ add_spellparameter(region *target_r, unit *u, const char *syntax, struct order *
 		par->length++;
 		token = strtok(NULL, " ");
 	}
+  free(tbuf);
 	/* length sollte nun nur noch die Anzahl der für den Zauber relevanten
 	 * Elemente enthalten */
 	par->length -= skip; /* Anzahl der Elemente ('temp 123' sind zwei!) */
@@ -1877,7 +1878,6 @@ add_spellparameter(region *target_r, unit *u, const char *syntax, struct order *
 		/* Fehler: Ziel vergessen */
 		cmistake(u, ord, 203, MSG_MAGIC);
 		/* Aufräumen */
-		free(tbuf);
 		free(par);
 		return 0;
 	}
@@ -1886,7 +1886,7 @@ add_spellparameter(region *target_r, unit *u, const char *syntax, struct order *
 	par->param = calloc(par->length, sizeof(spllprm *));
 
 	/* Tokens zuweisen */
-	strcpy(tbuf, getcommand(ord));
+	tbuf = getcommand(ord);
 	token = strtok (tbuf, " ");
 	while(token && syntax[c] != 0) {
 		if (i > skip) {
@@ -2216,6 +2216,7 @@ add_spellparameter(region *target_r, unit *u, const char *syntax, struct order *
 		i++;
 		token = strtok(NULL, " ");
 	}
+  free(tbuf);
 
 	/* im Endeffekt waren es nur l parameter */
 	par->length = l;
@@ -2226,14 +2227,10 @@ add_spellparameter(region *target_r, unit *u, const char *syntax, struct order *
 		/* Syntax Error. */
 		cmistake(u, ord, 209, MSG_MAGIC);
 		/* Aufräumen */
-		free(tbuf);
 		free_spellparameter(par);
 		return 0;
 	}
 
-	/* Aufräumen */
-	free(tbuf);
-
 	return par;
 }
 

src/common/kernel/order.c

@@ -21,6 +21,11 @@
 #include <stdlib.h>
 #include <string.h>
 
+static const struct locale * locale_array[16];
+static int nlocales = 0;
+
+#undef SHORT_STRINGS
+
 keyword_t
 get_keyword(const order * ord)
 {
@@ -30,17 +35,35 @@ get_keyword(const order * ord)
   return ord->_keyword;
 }
 
-const char * 
+char *
 getcommand(const order * ord)
 {
-  return ord->_str;
+  char sbuffer[DISPLAYSIZE*2];
+  char * str = sbuffer;
+  
+  assert(ord->_lindex<nlocales);
+  if (ord->_persistent) *str++ = '@';
+#ifdef SHORT_STRINGS
+  if (ord->_keyword!=NOKEYWORD) {
+    const struct locale * lang = locale_array[ord->_lindex];
+
+    strcpy(str, LOC(lang, keywords[ord->_keyword]));
+    str += strlen(str);
+    if (ord->_str) {
+      *str++ = ' ';
+      *str = 0;
+    }
+  }
+#endif
+  strcpy(str, ord->_str);
+  return strdup(sbuffer);
 }
 
 void 
 free_order(order * ord)
 {
 	if (ord!=NULL && --ord->_refcount==0) {
-		free(ord->_str);
+		if (ord->_str!=NULL) free(ord->_str);
 		free(ord);
 	}
 }
@@ -73,14 +96,45 @@ free_orders(order ** olist)
 order * 
 parse_order(const char * s, const struct locale * lang)
 {
-  while (isspace(*s)) ++s;
+  while (isspace(*(unsigned char*)s)) ++s;
   if (*s==0) return NULL;
   else {
+    const char * sptr;
     order * ord = (order*)malloc(sizeof(order));
-	ord->_str = strdup(s);
+    int i;
-	ord->_keyword = findkeyword(parse_token(&s), lang);
+
+    for (i=0;i!=nlocales;++i) {
+      if (locale_array[i]==lang) break;
+    }
+    if (i==nlocales) locale_array[nlocales++] = lang;
+    ord->_lindex = (unsigned char)i;
+    ord->_str = NULL;
+    ord->_persistent = 0;
     ord->_refcount = 1;
     ord->next = NULL;
+
+#ifdef AT_PERSISTENT
+    if (*s=='@') {
+      ord->_persistent = 1;
+#ifdef SHORT_STRINGS
+      ++s;
+#endif
+    }
+#endif
+    sptr = s;
+    ord->_keyword = findkeyword(parse_token(&sptr), lang);
+#ifdef SHORT_STRINGS
+    if (ord->_keyword==NOKEYWORD) {
+      ord->_str = strdup(s);
+    } else {
+      while (isspace(*(unsigned char*)sptr)) ++sptr;
+      if (*sptr) {
+        ord->_str = strdup(sptr);
+      }
+    }
+#else
+    ord->_str = strdup(s);
+#endif
     return ord;
   }
 }
@@ -88,22 +142,23 @@ parse_order(const char * s, const struct locale * lang)
 boolean
 is_persistent(const order * cmd)
 {
-#ifdef AT_PERSISTENT
-	if (cmd->_str[0] == '@') return true;
-#endif      /* Nur kurze Befehle! */
 	switch (cmd->_keyword) {
+    case NOKEYWORD:
+      return false;
     case K_KOMMENTAR:
     case K_LIEFERE:
       return true;
-		break;
 	}
+#ifdef AT_PERSISTENT
+  if (cmd->_persistent) return true;
+#endif      /* Nur kurze Befehle! */
 	return false;
 }
 
 char * 
-write_order(const order * cmd, const struct locale * lang, char * buffer, size_t size)
+write_order(const order * ord, const struct locale * lang, char * buffer, size_t size)
 {
-  if (cmd==0) {
+  if (ord==0 || ord->_keyword==NOKEYWORD) {
     buffer[0]=0;
   } else {
 #ifndef NDEBUG

src/common/kernel/order.h

@@ -30,7 +30,9 @@ typedef struct order {
   /* do not access this data: */
   char * _str; 
   keyword_t _keyword;
-  int _refcount;
+  int _lindex : 7;
+  int _persistent : 1;
+  int _refcount : 16;
 } order;
 
 /* constructor */
@@ -44,7 +46,7 @@ extern void free_orders(struct order ** olist);
 /* access functions for orders */
 extern keyword_t get_keyword(const struct order * ord);
 extern void set_order(struct order ** destp, struct order * src);
-extern const char * getcommand(const struct order * ord);
+extern char * getcommand(const struct order * ord);
 extern boolean is_persistent(const struct order *ord);
 extern char * write_order(const struct order * ord, const struct locale * lang, char * buffer, size_t size);
 #ifdef __cplusplus

src/common/kernel/orders.c

@@ -1,18 +0,0 @@
-/* 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-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.
- */
-
-#include <config.h>
-#include "eressea.h"
-#include "orders.h"
-

src/common/kernel/orders.h

@@ -1,18 +0,0 @@
-/* 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-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 ORDERS_H
-#define ORDERS_H
-
-#endif

src/common/kernel/reports.c

@@ -407,9 +407,11 @@ bufunit(const faction * f, const unit * u, int indent, int mode)
       }
     }
     if (!isbattle && u->lastorder) {
+      char * cmd = getcommand(u->lastorder);
       scat(", \"");
-      scat(getcommand(u->lastorder));
+      scat(cmd);
       scat("\"");
+      free(cmd);
     }
   }
   i = 0;

src/common/kernel/save.c

@@ -1095,7 +1095,8 @@ readunit(FILE * F)
 	free_orders(&u->orders);
 	rs(F, buf);
 	while(*buf != 0) {
-          addlist(&u->orders, parse_order(buf, u->faction->locale));
+    order * ord = parse_order(buf, u->faction->locale);
+    if (ord!=NULL) addlist(&u->orders, ord);
 		rs(F, buf);
 	}
   rs(F, buf);
@@ -1200,7 +1201,8 @@ writeunit(FILE * F, const unit * u)
 	wi(F, u->flags & UFL_SAVEMASK);
 	wnl(F);
 	for (ord = u->orders; ord; ord=ord->next) {
-		if (is_persistent(ord)) writeorder(ord, u->faction->locale, F);
+    if (is_persistent(ord) && get_keyword(ord)!=NOKEYWORD) {
+      writeorder(ord, u->faction->locale, F);
 	}
 	ws(F, ""); /* Abschluß der persistenten Befehle */
 	writeorder(u->lastorder, u->faction->locale, F);

src/common/util/command.c

@@ -87,10 +87,12 @@ do_command_i(const struct tnode * keys, void * u, const char * str, struct order
 	}
 }
 
-extern const char * getcommand(struct order * ord);
+extern char * getcommand(struct order * ord);
 
 void
 do_command(const struct tnode * keys, void * u, struct order * ord)
 {
-  do_command_i(keys, u, getcommand(ord), ord);
+  char * cmd = getcommand(ord);
+  do_command_i(keys, u, cmd, ord);
+  free(cmd);
 }

src/eressea/lua/alliance.cpp

@@ -22,10 +22,10 @@ public:
   static faction * value(faction_list * node) { return node->data; }
 };
 
-static eressea::list<faction, faction_list, factionlist_iterator>
+static eressea::list<faction *, faction_list *, factionlist_iterator>
 alliance_factions(const alliance& al)
 {
-  return eressea::list<faction, faction_list, factionlist_iterator>(al.members);
+  return eressea::list<faction *, faction_list *, factionlist_iterator>(al.members);
 }
 
 static alliance *
@@ -34,9 +34,9 @@ add_alliance(int id, const char * name)
   return makealliance(id, name);
 }
 
-static eressea::list<alliance>
+static eressea::list<alliance *>
 get_alliances(void) {
-  return eressea::list<alliance>(alliances);
+  return eressea::list<alliance *>(alliances);
 }
 
 void

src/eressea/lua/eressea.cpp

@@ -146,6 +146,13 @@ race_setscript(const char * rcname, const functor<void>& f)
   }
 }
 
+#ifdef LUABIND_NO_EXCEPTIONS
+static void
+error_callback(lua_State * L)
+{
+}
+#endif
+
 void
 bind_eressea(lua_State * L)
 {
@@ -177,4 +184,7 @@ bind_eressea(lua_State * L)
     /* planes not really implemented */
     def("get_plane_id", &find_plane_id)
   ];
+#ifdef LUABIND_NO_EXCEPTIONS
+  luabind::set_error_callback(error_callback);
+#endif
 }

src/eressea/lua/faction.cpp

@@ -32,9 +32,9 @@ add_faction(const char * email, const char * racename, const char * lang)
   return f;
 }
 
-static eressea::list<faction>
+static eressea::list<faction *>
 get_factions(void) {
-  return eressea::list<faction>(factions);
+  return eressea::list<faction *>(factions);
 }
 
 class factionunit {
@@ -43,10 +43,10 @@ public:
   static unit * value(unit * node) { return node; }
 };
 
-static eressea::list<unit, unit, factionunit>
+static eressea::list<unit *, unit *, factionunit>
 faction_units(const faction& f)
 {
-  return eressea::list<unit, unit, factionunit>(f.units);
+  return eressea::list<unit *, unit *, factionunit>(f.units);
 }
 
 #ifdef ALLIANCES

src/eressea/lua/list.h

@@ -6,8 +6,8 @@ namespace eressea {
   template<class T, class N = T>
   class listnode {
   public:
-    static N * next(N * node) { return node->next; }
+    static N next(N& node) { return node->next; }
-    static T * value(N * node) { return node; }
+    static T value(N& node) { return node; }
   };
 
   template<class T, class N = T, class nodetype = listnode<T, N> >
@@ -15,8 +15,8 @@ namespace eressea {
   public:
     class iterator {
     public:
-      iterator(N * index) : m_index(index) {}
+      iterator(const N& index) : m_index(index) {}
-      T * operator*() { return nodetype::value(m_index); }
+      T operator*() { return nodetype::value(m_index); }
       bool operator==(const iterator& iter) {
         return iter.m_index==m_index;
       }
@@ -25,15 +25,15 @@ namespace eressea {
         return *this;
       }
     private:
-      N * m_index;
+      N m_index;
     };
     typedef iterator const_iterator;
-    list<T, N, nodetype>(N * clist) : m_clist(clist) {}
+    list<T, N, nodetype>(const N& clist) : m_clist(clist) {}
     iterator begin() const { return iterator(m_clist); }
     iterator end() const { return iterator(NULL); }
 
   public:
-    N * m_clist;
+    N m_clist;
   };
 
 };

src/eressea/lua/region.cpp

@@ -17,24 +17,24 @@
 #include <ostream>
 using namespace luabind;
 
-static eressea::list<region>
+static eressea::list<region *>
 get_regions(void) {
-  return eressea::list<region>(regions);
+  return eressea::list<region *>(regions);
 }
 
-static eressea::list<unit>
+static eressea::list<unit *>
 region_units(const region& r) {
-  return eressea::list<unit>(r.units);
+  return eressea::list<unit *>(r.units);
 }
 
-static eressea::list<building>
+static eressea::list<building *>
 region_buildings(const region& r) {
-  return eressea::list<building>(r.buildings);
+  return eressea::list<building *>(r.buildings);
 }
 
-static eressea::list<ship>
+static eressea::list<ship *>
 region_ships(const region& r) {
-  return eressea::list<ship>(r.ships);
+  return eressea::list<ship *>(r.ships);
 }
 
 static void

src/eressea/lua/unit.cpp

@@ -26,6 +26,7 @@
 #include <luabind/iterator_policy.hpp>
 
 #include <ostream>
+#include <string>
 using namespace luabind;
 
 class bind_spell_ptr {
@@ -34,12 +35,12 @@ public:
   static spell * value(spell_ptr * node) { return find_spellbyid(node->spellid); }
 };
 
-static eressea::list<spell, spell_ptr, bind_spell_ptr>
+static eressea::list<spell *, spell_ptr *, bind_spell_ptr>
 unit_spells(const unit& u) {
   sc_mage * mage = get_mage(&u);
-  if (mage==NULL) return eressea::list<spell, spell_ptr, bind_spell_ptr>(NULL);
+  if (mage==NULL) return eressea::list<spell *, spell_ptr *, bind_spell_ptr>(NULL);
   spell_ptr * splist = mage->spellptr;
-  return eressea::list<spell, spell_ptr, bind_spell_ptr>(splist);
+  return eressea::list<spell *, spell_ptr *, bind_spell_ptr>(splist);
 }
 
 class bind_spell_list {
@@ -48,10 +49,26 @@ public:
   static spell * value(spell_list * node) { return node->data; }
 };
 
-static eressea::list<spell, spell_list, bind_spell_list>
+static eressea::list<spell *, spell_list *, bind_spell_list>
 unit_familiarspells(const unit& u) {
   spell_list * spells = familiarspells(u.race);
-  return eressea::list<spell, spell_list, bind_spell_list>(spells);
+  return eressea::list<spell *, spell_list *, bind_spell_list>(spells);
+}
+
+class bind_orders {
+public:
+  static order * next(order * node) { return node->next; }
+  static std::string value(order * node) { 
+    char * cmd = getcommand(node); 
+    std::string s(cmd);
+    free(cmd);
+    return s;
+  }
+};
+
+static eressea::list<std::string, order *, bind_orders>
+unit_orders(const unit& u) {
+  return eressea::list<std::string, order *, bind_orders>(u.orders);
 }
 
 static unit *
@@ -211,6 +228,23 @@ unit_getregion(const unit& u)
   return u.region;
 }
 
+static int
+unit_getid(const unit& u)
+{
+  return u.no;
+}
+
+static void
+unit_setid(unit& u, int id)
+{
+  unit * nu = findunit(id);
+  if (nu==NULL) {
+    uunhash(&u);
+    u.no = id;
+    uhash(&u);
+  }
+}
+
 static const char *
 unit_getname(const unit& u)
 {
@@ -223,6 +257,18 @@ unit_setname(unit& u, const char * name)
   set_string(&u.name, name);
 }
 
+static const char *
+unit_getinfo(const unit& u)
+{
+  return u.display;
+}
+
+static void
+unit_setinfo(unit& u, const char * info)
+{
+  set_string(&u.display, info);
+}
+
 static std::ostream& 
 operator<<(std::ostream& stream, unit& u)
 {
@@ -319,15 +365,21 @@ bind_unit(lua_State * L)
     def("add_unit", &add_unit),
 
     class_<struct unit>("unit")
-    .property("name", &unit_getname, &unit_setname)
     .def(tostring(self))
     .def(self == unit())
+    .property("name", &unit_getname, &unit_setname)
+    .property("info", &unit_getinfo, &unit_setinfo)
+    .property("id", &unit_getid, &unit_setid)
     .def_readonly("faction", &unit::faction)
-    .def_readonly("id", &unit::no)
     .def_readwrite("hp", &unit::hp)
     .def_readwrite("status", &unit::status)
+
+    // orders:
     .def("add_order", &unit_addorder)
     .def("clear_orders", &unit_clearorders)
+    .property("orders", &unit_orders, return_stl_iterator)
+
+    // items:
     .def("get_item", &unit_getitem)
     .def("add_item", &unit_additem)
     .def("get_skill", &unit_getskill)

src/eressea/server.cpp

@@ -142,6 +142,7 @@ static int nowrite = 0;
 static boolean g_writemap = false;
 static boolean opt_reportonly = false;
 static const char * luafile = "default.lua";
+static const char * script_path = NULL;
 
 struct settings global = {
   "Eressea", /* gamename */
@@ -272,6 +273,7 @@ lua_init(void)
   luaopen_math(luaState);
   luaopen_string(luaState);
   luaopen_io(luaState);
+  luaopen_table(luaState);
   luabind::open(luaState);
   bind_eressea(luaState);
   bind_spell(luaState);
@@ -590,7 +592,7 @@ read_args(int argc, char **argv, lua_State * luaState)
         }
         break;
       case 'l':
-        log_open(argv[++i]);
+        script_path = argv[++i];
         break;
       case 'w':
         g_writemap = true;
@@ -605,6 +607,7 @@ read_args(int argc, char **argv, lua_State * luaState)
 
   /* add some more variables to the lua globals */
   setLuaString(luaState, "datapath", datapath());
+  setLuaString(luaState, "scriptpath", script_path);
   setLuaString(luaState, "basepath", basepath());
   setLuaString(luaState, "reportpath", reportpath());
   setLuaString(luaState, "resourcepath", resourcepath());
@@ -663,8 +666,25 @@ main(int argc, char *argv[])
 
   // run the main script
   if (luafile==NULL) lua_console(luaState);
+  else {
+    try {
+      if (script_path) {
+        sprintf(buf, "%s/%s", script_path, luafile);
+        lua_dofile(luaState, buf);
+      }
       else lua_dofile(luaState, luafile);
-
+    } 
+    catch (luabind::error& e) {
+      lua_State* L = e.state();
+      const char* error = lua_tostring(L, -1);
+      log_error((error));
+      lua_pop(L, 1);
+      std::terminate();
+      // L will now point to the destructed
+      // lua state and be invalid
+      /* ... */
+    }
+  }
 #ifdef CLEANUP_CODE
   game_done();
 #endif

src/scripts/eressea.lua

@@ -0,0 +1,78 @@
+function write_emails()
+  local locales = { "de", "en" }
+  local files = {}
+  local key
+  for key in locales do
+    local locale = locales[key]
+    files[locale] = io.open(basepath .. "/emails." .. locale, "w")
+  end
+
+  local faction
+  for faction in factions() do
+    -- print(faction.id .. " - " .. faction.locale)
+    files[faction.locale]:write(faction.email .. "\n")
+  end
+
+  for key in files do
+    files[key]:close()
+  end
+end
+
+function process(orders)
+  file = "" .. get_turn()
+  if read_game(file)~=0 then
+    print("could not read game")
+    return -1
+  end
+
+  -- initialize starting equipment for new players
+  -- probably not necessary, since mapper sets new players, not server
+  add_equipment("conquesttoken", 1);
+  add_equipment("wood", 30);
+  add_equipment("stone", 30);
+  add_equipment("money", 2000 + get_turn() * 10);
+
+  -- initialize other scripts
+  local magrathea = get_region(-67, -5)
+  if magrathea~=nil and init_ponnuki~=nil then
+    init_ponnuki(magrathea)
+    return
+  end
+
+  -- run the turn:
+  read_orders(orders)
+  plan_monsters()
+  process_orders()
+  
+  write_passwords()
+  write_reports()
+
+  write_emails()
+
+  file = "" .. get_turn()
+  if write_game(file)~=0 then 
+    print("could not write game")
+    return -1
+  end
+end
+
+
+--
+-- main body of script
+--
+
+scripts= { "ponnuki.lua" }
+
+-- orderfile: contains the name of the orders.
+if orderfile==nil then
+  print "you must specify an orderfile"
+else
+  for index in scripts do
+    local script = scriptpath .. scripts[index]
+    if pcall(dofile, script)==0 then
+      print("Could not load " .. script)
+    end
+  end
+  process(orderfile)
+end
+

src/scripts/ponnuki.lua

@@ -0,0 +1,34 @@
+function ponnuki_brain(u)
+  jokes = {
+    "Ein Bummerang ist, wenn man ihn wegwirft und er kommt nicht wieder, dann war's keiner.",
+
+    "Merke: Mit Schwabenwitzen soll man ganz sparsam sein.",
+
+    "Was bekommt man, wenn man Katzen und Elfen kreuzt? Elfen ohne Rheuma.",
+
+    "Was bekommt man, wenn man Insekten und Katzen kreuzt? Tiger, die Crisan benutzen."
+  }
+  local i = math.random(table.getn(jokes))
+  u.region:add_notice(jokes[i])
+  local d = math.random(6)
+  r = u.region:next(d-1)
+  u:clear_orders()
+  directions = { "NW", "NO", "O", "SO", "SW", "W" }
+  u:add_order("NACH " .. directions[d])
+end
+
+function init_ponnuki(home)
+  local f = get_faction(0)
+  local u = get_unit(atoi36("ponn"))
+  if u == nil then
+    u = add_unit(f, home)
+    u.id = atoi36("ponn")
+    u.name = "Ponnuki"
+    u.info = "Go, Ponnuki, Go!"
+    u.race = "illusion"
+    u:set_racename("Ritter von Go")
+  end
+  if u.faction==f then
+    u:set_brain(ponnuki_brain)
+  end
+end

src/scripts/samples.lua

@@ -130,12 +130,26 @@ function test_write()
 end
 
 function move_north(u)
+  for order in u.orders do
+    print(order)
+  end
   u:clear_orders()
   u:add_order("NACH NORDEN")
 end
 
 function test_monsters()
   read_game("23")
+
+  -- magrathea = get_region(-67, -5)
+  local magrathea = get_region(0, 0)
+  if magrathea ~= nil then
+    if pcall(dofile, scriptpath .. "/ponnuki.lua") then
+      init_ponnuki(magrathea)
+    else
+      print("could not open ponnuki")
+    end
+  end
+
   set_brain("braineater", move_north)
   plan_monsters()
   process_orders()