forked from github/server
324 lines
6.6 KiB
C++
324 lines
6.6 KiB
C++
#include <config.h>
|
|
#include <eressea.h>
|
|
|
|
#include "script.h"
|
|
#include "../korrektur.h"
|
|
|
|
#include <attributes/key.h>
|
|
#include <modules/autoseed.h>
|
|
#include <modules/score.h>
|
|
|
|
// gamecode includes
|
|
#include <gamecode/laws.h>
|
|
#include <gamecode/monster.h>
|
|
#include <gamecode/creport.h>
|
|
|
|
// kernel includes
|
|
#include <kernel/alliance.h>
|
|
#include <kernel/equipment.h>
|
|
#include <kernel/faction.h>
|
|
#include <kernel/item.h>
|
|
#include <kernel/plane.h>
|
|
#include <kernel/race.h>
|
|
#include <kernel/reports.h>
|
|
#include <kernel/save.h>
|
|
#include <kernel/skill.h>
|
|
#include <kernel/teleport.h>
|
|
#include <kernel/unit.h>
|
|
|
|
// lua includes
|
|
#include <lua.hpp>
|
|
#include <luabind/luabind.hpp>
|
|
#include <luabind/iterator_policy.hpp>
|
|
|
|
// util includes
|
|
#include <util/language.h>
|
|
#include <util/base36.h>
|
|
#include <util/rand.h>
|
|
|
|
#include <cstring>
|
|
#include <ctime>
|
|
|
|
using namespace luabind;
|
|
|
|
static int
|
|
lua_addequipment(const char * eqname, const char * iname, const char * value)
|
|
{
|
|
const struct item_type * itype = it_find(iname);
|
|
if (itype==NULL) return -1;
|
|
equipment_setitem(create_equipment(eqname), itype, value);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
get_turn(void)
|
|
{
|
|
return turn;
|
|
}
|
|
|
|
static int
|
|
read_game(const char * filename)
|
|
{
|
|
int rv = readgame(filename, false);
|
|
printf(" - Korrekturen Runde %d\n", turn);
|
|
korrektur();
|
|
return rv;
|
|
}
|
|
|
|
static int
|
|
write_game(const char *filename)
|
|
{
|
|
free_units();
|
|
remove_empty_factions(true);
|
|
|
|
return writegame(filename, 0);
|
|
}
|
|
|
|
static summary * sum_begin = 0;
|
|
|
|
static int
|
|
init_summary()
|
|
{
|
|
sum_begin = make_summary();
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
write_summary()
|
|
{
|
|
assert(sum_begin
|
|
|| !"init_summary must be called before before write_summary");
|
|
if (sum_begin) {
|
|
summary * sum_end = make_summary();
|
|
report_summary(sum_end, sum_begin, false);
|
|
report_summary(sum_end, sum_begin, true);
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
extern int process_orders(void);
|
|
|
|
static int
|
|
find_plane_id(const char * name)
|
|
{
|
|
plane * pl = getplanebyname(name);
|
|
return pl?pl->id:0;
|
|
}
|
|
|
|
static bool
|
|
get_flag(const char * name)
|
|
{
|
|
int flag = atoi36(name);
|
|
attrib * a = find_key(global.attribs, flag);
|
|
return (a!=NULL);
|
|
}
|
|
|
|
static void
|
|
set_flag(const char * name, bool value)
|
|
{
|
|
int flag = atoi36(name);
|
|
attrib * a = find_key(global.attribs, flag);
|
|
if (a==NULL && value) {
|
|
add_key(&global.attribs, flag);
|
|
} else if (a!=NULL && !value) {
|
|
a_remove(&global.attribs, a);
|
|
}
|
|
}
|
|
|
|
static const char *
|
|
get_gamename(void)
|
|
{
|
|
return global.gamename;
|
|
}
|
|
|
|
static void
|
|
lua_setstring(const char * lname, const char * key, const char * str)
|
|
{
|
|
struct locale * lang = find_locale(lname);
|
|
locale_setstring(lang, key, str);
|
|
}
|
|
|
|
static const char *
|
|
lua_getstring(const char * lname, const char * key)
|
|
{
|
|
struct locale * lang = find_locale(lname);
|
|
return locale_getstring(lang, key);
|
|
}
|
|
|
|
static void
|
|
lua_planmonsters(void)
|
|
{
|
|
unit * u;
|
|
faction * f = findfaction(MONSTER_FACTION);
|
|
|
|
if (f==NULL) return;
|
|
if (turn == 0) srand((int)time(0));
|
|
else srand(turn);
|
|
plan_monsters();
|
|
for (u=f->units;u;u=u->nextF) {
|
|
call_script(u);
|
|
}
|
|
}
|
|
|
|
static void
|
|
race_setscript(const char * rcname, const luabind::object& f)
|
|
{
|
|
race * rc = rc_find(rcname);
|
|
if (rc!=NULL) {
|
|
luabind::object * fptr = new luabind::object(f);
|
|
setscript(&rc->attribs, fptr);
|
|
}
|
|
}
|
|
|
|
#define ISLANDSIZE 20
|
|
#define TURNS_PER_ISLAND 4
|
|
static void
|
|
lua_autoseed(const char * filename, bool new_island)
|
|
{
|
|
newfaction * players = read_newfactions(filename);
|
|
while (players) {
|
|
int n = listlen(players);
|
|
int k = (n+ISLANDSIZE-1)/ISLANDSIZE;
|
|
k = n / k;
|
|
autoseed(&players, k, new_island || (turn % TURNS_PER_ISLAND)==0);
|
|
}
|
|
}
|
|
|
|
#ifdef LUABIND_NO_EXCEPTIONS
|
|
static void
|
|
error_callback(lua_State * L)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
get_direction(const char * name)
|
|
{
|
|
for (int i=0;i!=MAXDIRECTIONS;++i) {
|
|
if (strcasecmp(directions[i], name)==0) return i;
|
|
}
|
|
return NODIRECTION;
|
|
}
|
|
|
|
int
|
|
lua_writereport(faction * f)
|
|
{
|
|
time_t ltime = time(0);
|
|
return write_reports(f, ltime);
|
|
}
|
|
|
|
int
|
|
lua_writereports(void)
|
|
{
|
|
init_reports();
|
|
return reports();
|
|
}
|
|
|
|
static void
|
|
lua_equipunit(unit& u, const char * eqname)
|
|
{
|
|
equip_unit(&u, get_equipment(eqname));
|
|
}
|
|
|
|
static void
|
|
update_subscriptions(void)
|
|
{
|
|
FILE * F;
|
|
char zText[MAX_PATH];
|
|
faction * f;
|
|
strcat(strcpy(zText, basepath()), "/subscriptions");
|
|
F = fopen(zText, "r");
|
|
if (F==NULL) {
|
|
log_info((0, "could not open %s.\n", zText));
|
|
return;
|
|
}
|
|
for (;;) {
|
|
char zFaction[5];
|
|
int subscription, fno;
|
|
if (fscanf(F, "%d %s", &subscription, zFaction)<=0) break;
|
|
fno = atoi36(zFaction);
|
|
f = findfaction(fno);
|
|
if (f!=NULL) {
|
|
f->subscription=subscription;
|
|
}
|
|
}
|
|
fclose(F);
|
|
|
|
sprintf(zText, "subscriptions.%u", turn);
|
|
F = fopen(zText, "w");
|
|
for (f=factions;f!=NULL;f=f->next) {
|
|
fprintf(F, "%s:%u:%s:%s:%s:%u:\n",
|
|
itoa36(f->no), f->subscription, f->email, f->override,
|
|
dbrace(f->race), f->lastorders);
|
|
}
|
|
fclose(F);
|
|
}
|
|
|
|
static void
|
|
lua_learnskill(unit& u, const char * skname, float chances)
|
|
{
|
|
skill_t sk = sk_find(skname);
|
|
if (sk!=NOSKILL) {
|
|
learn_skill(&u, sk, chances);
|
|
}
|
|
}
|
|
|
|
void
|
|
bind_eressea(lua_State * L)
|
|
{
|
|
module(L)[
|
|
def("atoi36", &atoi36),
|
|
def("itoa36", &itoa36),
|
|
def("read_game", &read_game),
|
|
def("write_map", &crwritemap),
|
|
def("write_game", &write_game),
|
|
def("write_passwords", &writepasswd),
|
|
def("init_reports", &init_reports),
|
|
def("dice_roll", &dice_rand),
|
|
def("write_reports", &lua_writereports),
|
|
def("write_report", &lua_writereport),
|
|
def("init_summary", &init_summary),
|
|
def("write_summary", &write_summary),
|
|
def("read_orders", &readorders),
|
|
def("process_orders", &process_orders),
|
|
def("equipment_setitem", &lua_addequipment),
|
|
def("get_turn", &get_turn),
|
|
def("remove_empty_units", &remove_empty_units),
|
|
|
|
def("update_subscriptions", &update_subscriptions),
|
|
def("update_guards", &update_guards),
|
|
def("update_scores", &score),
|
|
|
|
def("equip_unit", &lua_equipunit),
|
|
def("learn_skill", &lua_learnskill),
|
|
|
|
/* scripted monsters */
|
|
def("plan_monsters", &lua_planmonsters),
|
|
def("set_brain", &race_setscript),
|
|
def("spawn_braineaters", &spawn_braineaters),
|
|
def("spawn_undead", &spawn_undead),
|
|
def("spawn_dragons", &spawn_dragons),
|
|
|
|
/* map making */
|
|
def("autoseed", lua_autoseed),
|
|
|
|
/* string to enum */
|
|
def("direction", &get_direction),
|
|
|
|
/* localization: */
|
|
def("set_string", &lua_setstring),
|
|
def("get_string", &lua_getstring),
|
|
|
|
def("set_flag", &set_flag),
|
|
def("get_flag", &get_flag),
|
|
|
|
def("get_gamename", &get_gamename),
|
|
/* planes not really implemented */
|
|
def("get_plane_id", &find_plane_id)
|
|
];
|
|
#ifdef LUABIND_NO_EXCEPTIONS
|
|
luabind::set_error_callback(error_callback);
|
|
#endif
|
|
}
|