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

Merge pull request #732 from ennorehling/develop 

refactor readorders
This commit is contained in:
Enno Rehling 2017-10-07 20:28:01 +02:00 committed by GitHub
parent 0ca0543c6e e87a26d961
commit 734c355ec3
8 changed files with 358 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/CMakeLists.txt
View File

@ -116,6 +116,7 @@ set (ERESSEA_SRC
magic.c
market.c
morale.c
orderfile.c
randenc.c
renumber.c
volcano.c
@ -217,6 +218,7 @@ set(TESTS_SRC
monsters.test.c
move.test.c
names.test.c
orderfile.test.c
piracy.test.c
prefix.test.c
renumber.test.c

1
src/bind_eressea.c
View File

@ -3,6 +3,7 @@
#include <platform.h>
#include "json.h"
#include "orderfile.h"
#include <kernel/faction.h>
#include <kernel/item.h>

211
src/kernel/save.c
View File

@ -123,217 +123,6 @@ char *rns(FILE * f, char *c, size_t size)
return c;
}
static unit *unitorders(FILE * F, int enc, struct faction *f)
{
int i;
unit *u;
if (!f)
return NULL;
i = getid();
u = findunitg(i, NULL);
if (u && u->faction == f) {
order **ordp;
if (!fval(u, UFL_ORDERS)) {
/* alle wiederholbaren, langen befehle werden gesichert: */
fset(u, UFL_ORDERS);
u->old_orders = u->orders;
ordp = &u->old_orders;
while (*ordp) {
order *ord = *ordp;
keyword_t kwd = getkeyword(ord);
if (!is_repeated(kwd)) {
*ordp = ord->next;
ord->next = NULL;
free_order(ord);
}
else {
ordp = &ord->next;
}
}
}
else {
free_orders(&u->orders);
}
u->orders = 0;
ordp = &u->orders;
for (;;) {
const char *s;
/* Erst wenn wir sicher sind, dass kein Befehl
* eingegeben wurde, checken wir, ob nun eine neue
* Einheit oder ein neuer Spieler drankommt */
s = getbuf(F, enc);
if (s == NULL)
break;
if (s[0]) {
if (s[0] != '@') {
char token[64];
const char *stok = s;
stok = parse_token(&stok, token, sizeof(token));
if (stok) {
bool quit = false;
param_t param = findparam(stok, u->faction->locale);
switch (param) {
case P_UNIT:
case P_REGION:
quit = true;
break;
case P_FACTION:
case P_NEXT:
case P_GAMENAME:
/* these terminate the orders, so we apply extra checking */
if (strlen(stok) >= 3) {
quit = true;
break;
}
else {
quit = false;
}
break;
default:
break;
}
if (quit) {
break;
}
}
}
/* Nun wird der Befehl erzeut und eingehängt */
*ordp = parse_order(s, u->faction->locale);
if (*ordp) {
ordp = &(*ordp)->next;
}
else {
ADDMSG(&f->msgs, msg_message("parse_error", "unit command", u, s));
}
}
}
}
else {
return NULL;
}
return u;
}
static faction *factionorders(void)
{
faction *f = NULL;
int fid = getid();
f = findfaction(fid);
if (f != NULL && !fval(f, FFL_NPC)) {
char token[128];
const char *pass = gettoken(token, sizeof(token));
if (!checkpasswd(f, (const char *)pass)) {
log_debug("Invalid password for faction %s", itoa36(fid));
ADDMSG(&f->msgs, msg_message("wrongpasswd", "password", pass));
return 0;
}
/* Die Partei hat sich zumindest gemeldet, so dass sie noch
* nicht als untätig gilt */
f->lastorders = turn;
}
else {
log_debug("orders for invalid faction %s", itoa36(fid));
}
return f;
}
int readorders(const char *filename)
{
FILE *F = NULL;
const char *b;
int nfactions = 0;
struct faction *f = NULL;
F = fopen(filename, "r");
if (!F) {
perror(filename);
return -1;
}
log_info("reading orders from %s", filename);
/* TODO: recognize UTF8 BOM */
b = getbuf(F, enc_gamedata);
/* Auffinden der ersten Partei, und danach abarbeiten bis zur letzten
* Partei */
while (b) {
char token[128];
const struct locale *lang = f ? f->locale : default_locale;
param_t p;
const char *s;
init_tokens_str(b);
s = gettoken(token, sizeof(token));
p = findparam_block(s, lang, true);
switch (p) {
case P_GAMENAME:
case P_FACTION:
f = factionorders();
if (f) {
++nfactions;
}
b = getbuf(F, enc_gamedata);
break;
/* in factionorders wird nur eine zeile gelesen:
* diejenige mit dem passwort. Die befehle der units
* werden geloescht, und die Partei wird als aktiv
* vermerkt. */
case P_UNIT:
if (!f || !unitorders(F, enc_gamedata, f)) {
do {
b = getbuf(F, enc_gamedata);
if (!b) {
break;
}
init_tokens_str(b);
s = gettoken(token, sizeof(token));
p = (s && s[0] != '@') ? findparam(s, lang) : NOPARAM;
} while ((p != P_UNIT || !f) && p != P_FACTION && p != P_NEXT
&& p != P_GAMENAME);
}
break;
/* Falls in unitorders() abgebrochen wird, steht dort entweder eine neue
* Partei, eine neue Einheit oder das File-Ende. Das switch() wird erneut
* durchlaufen, und die entsprechende Funktion aufgerufen. Man darf buf
* auf alle Fälle nicht überschreiben! Bei allen anderen Einträgen hier
* muss buf erneut gefüllt werden, da die betreffende Information in nur
* einer Zeile steht, und nun die nächste gelesen werden muss. */
case P_NEXT:
f = NULL;
b = getbuf(F, enc_gamedata);
break;
default:
b = getbuf(F, enc_gamedata);
break;
}
}
fclose(F);
log_info("done reading orders for %d factions", nfactions);
return 0;
}
/* ------------------------------------------------------------- */
/* #define INNER_WORLD */

1
src/kernel/save.h
View File

@ -43,7 +43,6 @@ extern "C" {
/* TODO: is this *really* still in use? */
extern int enc_gamedata;
int readorders(const char *filename);
int readgame(const char *filename);
int writegame(const char *filename);

245
src/orderfile.c Normal file
View File

@ -0,0 +1,245 @@
#include <platform.h>
#include <kernel/config.h>
#include "orderfile.h"
#include <kernel/faction.h>
#include <kernel/unit.h>
#include <kernel/order.h>
#include <kernel/messages.h>
#include <util/base36.h>
#include <util/message.h>
#include <util/language.h>
#include <util/log.h>
#include <util/filereader.h>
#include <util/parser.h>
#include <assert.h>
#include <stdio.h>
#include <string.h>
static unit *unitorders(input *in, faction *f)
{
int i;
unit *u;
if (!f)
return NULL;
i = getid();
u = findunitg(i, NULL);
if (u && u->faction == f) {
order **ordp;
if (!fval(u, UFL_ORDERS)) {
/* alle wiederholbaren, langen befehle werden gesichert: */
fset(u, UFL_ORDERS);
u->old_orders = u->orders;
ordp = &u->old_orders;
while (*ordp) {
order *ord = *ordp;
keyword_t kwd = getkeyword(ord);
if (!is_repeated(kwd)) {
*ordp = ord->next;
ord->next = NULL;
free_order(ord);
}
else {
ordp = &ord->next;
}
}
}
else {
free_orders(&u->orders);
}
u->orders = 0;
ordp = &u->orders;
for (;;) {
const char *s;
/* Erst wenn wir sicher sind, dass kein Befehl
* eingegeben wurde, checken wir, ob nun eine neue
* Einheit oder ein neuer Spieler drankommt */
s = in->getbuf(in->data);
if (s == NULL)
break;
if (s[0]) {
if (s[0] != '@') {
char token[64];
const char *stok = s;
stok = parse_token(&stok, token, sizeof(token));
if (stok) {
bool quit = false;
param_t param = findparam(stok, u->faction->locale);
switch (param) {
case P_UNIT:
case P_REGION:
quit = true;
break;
case P_FACTION:
case P_NEXT:
case P_GAMENAME:
/* these terminate the orders, so we apply extra checking */
if (strlen(stok) >= 3) {
quit = true;
break;
}
else {
quit = false;
}
break;
default:
break;
}
if (quit) {
break;
}
}
}
/* Nun wird der Befehl erzeut und eingehängt */
*ordp = parse_order(s, u->faction->locale);
if (*ordp) {
ordp = &(*ordp)->next;
}
else {
ADDMSG(&f->msgs, msg_message("parse_error", "unit command", u, s));
}
}
}
}
else {
return NULL;
}
return u;
}
static faction *factionorders(void)
{
faction *f = NULL;
int fid = getid();
f = findfaction(fid);
if (f != NULL && !fval(f, FFL_NPC)) {
char token[128];
const char *pass = gettoken(token, sizeof(token));
if (!checkpasswd(f, (const char *)pass)) {
log_debug("Invalid password for faction %s", itoa36(fid));
ADDMSG(&f->msgs, msg_message("wrongpasswd", "password", pass));
return 0;
}
/* Die Partei hat sich zumindest gemeldet, so dass sie noch
* nicht als untätig gilt */
f->lastorders = turn;
}
else {
log_debug("orders for invalid faction %s", itoa36(fid));
}
return f;
}
int read_orders(input *in)
{
const char *b;
int nfactions = 0;
struct faction *f = NULL;
/* TODO: recognize UTF8 BOM */
b = in->getbuf(in->data);
/* Auffinden der ersten Partei, und danach abarbeiten bis zur letzten
* Partei */
while (b) {
char token[128];
const struct locale *lang = f ? f->locale : default_locale;
param_t p;
const char *s;
init_tokens_str(b);
s = gettoken(token, sizeof(token));
p = findparam_block(s, lang, true);
switch (p) {
case P_GAMENAME:
case P_FACTION:
f = factionorders();
if (f) {
++nfactions;
}
b = in->getbuf(in->data);
break;
/* in factionorders wird nur eine zeile gelesen:
* diejenige mit dem passwort. Die befehle der units
* werden geloescht, und die Partei wird als aktiv
* vermerkt. */
case P_UNIT:
if (!f || !unitorders(in, f)) {
do {
b = in->getbuf(in->data);
if (!b) {
break;
}
init_tokens_str(b);
s = gettoken(token, sizeof(token));
p = (s && s[0] != '@') ? findparam(s, lang) : NOPARAM;
} while ((p != P_UNIT || !f) && p != P_FACTION && p != P_NEXT
&& p != P_GAMENAME);
}
break;
/* Falls in unitorders() abgebrochen wird, steht dort entweder eine neue
* Partei, eine neue Einheit oder das File-Ende. Das switch() wird erneut
* durchlaufen, und die entsprechende Funktion aufgerufen. Man darf buf
* auf alle Fälle nicht überschreiben! Bei allen anderen Einträgen hier
* muss buf erneut gefüllt werden, da die betreffende Information in nur
* einer Zeile steht, und nun die nächste gelesen werden muss. */
case P_NEXT:
f = NULL;
b = in->getbuf(in->data);
break;
default:
b = in->getbuf(in->data);
break;
}
}
log_info("done reading orders for %d factions", nfactions);
return 0;
}
static const char * file_getbuf(void *data)
{
FILE *F = (FILE *)data;
return getbuf(F, ENCODING_UTF8);
}
int readorders(const char *filename)
{
input in;
int result;
FILE *F = NULL;
F = fopen(filename, "r");
if (!F) {
perror(filename);
return -1;
}
log_info("reading orders from %s", filename);
in.getbuf = file_getbuf;
in.data = F;
result = read_orders(&in);
fclose(F);
return result;
}

21
src/orderfile.h Normal file
View File

@ -0,0 +1,21 @@
#ifndef H_ORDERFILE
#define H_ORDERFILE
#include <skill.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct input {
const char *(*getbuf)(void *data);
void *data;
} input;
int read_orders(struct input *in);
int readorders(const char *filename);
#ifdef __cplusplus
}
#endif
#endif

88
src/orderfile.test.c Normal file
View File

@ -0,0 +1,88 @@
#include <platform.h>
#include <kernel/config.h>
#include "orderfile.h"
#include <kernel/faction.h>
#include <CuTest.h>
#include <tests.h>
static const char *getbuf_null(void *data)
{
return NULL;
}
static void test_read_orders(CuTest *tc) {
input in;
test_setup();
in.getbuf = getbuf_null;
in.data = NULL;
CuAssertIntEquals(tc, 0, read_orders(&in));
test_cleanup();
}
typedef struct order_list {
const char **orders;
int next;
} order_list;
static const char *getbuf_list(void *data)
{
order_list * olist = (order_list *)data;
return olist->orders[olist->next++];
}
static void test_faction_password_okay(CuTest *tc) {
input in;
faction *f;
order_list olist;
const char *orders[] = { "ERESSEA 1 password", NULL };
test_setup();
f = test_create_faction(NULL);
renumber_faction(f, 1);
CuAssertIntEquals(tc, 1, f->no);
faction_setpassword(f, "password");
f->lastorders = turn - 1;
olist.orders = orders;
olist.next = 0;
in.getbuf = getbuf_list;
in.data = &olist;
CuAssertIntEquals(tc, 0, read_orders(&in));
CuAssertIntEquals(tc, 2, olist.next);
CuAssertIntEquals(tc, turn, f->lastorders);
test_cleanup();
}
static void test_faction_password_bad(CuTest *tc) {
input in;
faction *f;
order_list olist;
const char *orders[] = { "ERESSEA 1 password", NULL };
test_setup();
f = test_create_faction(NULL);
renumber_faction(f, 1);
CuAssertIntEquals(tc, 1, f->no);
faction_setpassword(f, "patzword");
f->lastorders = turn - 1;
olist.orders = orders;
olist.next = 0;
in.getbuf = getbuf_list;
in.data = &olist;
CuAssertIntEquals(tc, 0, read_orders(&in));
CuAssertIntEquals(tc, 2, olist.next);
CuAssertIntEquals(tc, turn - 1, f->lastorders);
test_cleanup();
}
CuSuite *get_orderfile_suite(void)
{
CuSuite *suite = CuSuiteNew();
SUITE_ADD_TEST(suite, test_read_orders);
SUITE_ADD_TEST(suite, test_faction_password_okay);
SUITE_ADD_TEST(suite, test_faction_password_bad);
return suite;
}

1
src/test_eressea.c
View File

@ -132,6 +132,7 @@ int RunAllTests(int argc, char *argv[])
ADD_SUITE(monsters);
ADD_SUITE(move);
ADD_SUITE(names);
ADD_SUITE(orderfile);
ADD_SUITE(otherfaction);
ADD_SUITE(piracy);
ADD_SUITE(prefix);