static Object *initObject(ObjectParsed *objectParsed) {
GList *nextEventHandler;
Object *object = createObject(FALSE);
object->name = objectParsed->name;
object->description = objectParsed->description;
object->weight = objectParsed->weight;
object->takeable = objectParsed->takeable;
object->droppable = objectParsed->droppable;
object->messages = objectParsed->messages;
object->weapon = objectParsed->weapon;
object->damage = objectParsed->damage;
object->synonyms = objectParsed->synonyms;
/* initialize lua state for object */
object->L = initLuaState(objectParsed->scripts);
/* initialize entity-specific event handlers */
nextEventHandler = objectParsed->eventHandlers;
while (NULL != nextEventHandler) {
EventHandlerParsed *handler = (EventHandlerParsed *)nextEventHandler->data;
addLuaEventHandler(dstrview(handler->event), object->events,
dstrview(handler->function), object->L);
nextEventHandler = g_list_next(nextEventHandler);
}
return object;
}
static Room *initRoom(RoomParsed *roomParsed) {
int i;
GList *nextEventHandler;
GArray *creatureNames = roomParsed->creatures; /* creatures in the room */
GArray *objectNames = roomParsed->objects; /* objects in the room */
Room *room = createRoom(FALSE); /* actual room object */
/* list of objects referenced by a name */
GList *synonymList;
/* don't free these dstring_t objects when we free the parsed rooms table! */
room->name = roomParsed->name;
room->title = roomParsed->title;
room->description = roomParsed->description;
/* rooms will be connected later by another function */
room->north = NULL;
room->south = NULL;
room->east = NULL;
room->west = NULL;
room->in = NULL;
room->out = NULL;
room->up = NULL;
room->down = NULL;
room->messages = roomParsed->messages;
/* add creatures to the room */
for (i = 0; i < creatureNames->len; i++) {
room->creatureList = addCreature(room->creatureList, room->creatureByName,
g_array_index(creatureNames, dstring_t, i));
}
/* add objects to the room */
for (i = 0; i < objectNames->len; i++) {
dstring_t *objectName = g_array_index(objectNames, dstring_t, i);
Object *object = g_hash_table_lookup(g_objects, (char *)dstrview(objectName));
room->objectList = addObject(room->objectList, room->objectByName, objectName);
object->state.owner.entity = room;
object->state.owner.type = entity_room;
}
/* initialize lua state for room */
room->L = initLuaState(roomParsed->scripts);
/* initialize entity-specific event handlers */
nextEventHandler = roomParsed->eventHandlers;
while (NULL != nextEventHandler) {
EventHandlerParsed *handler = (EventHandlerParsed *)nextEventHandler->data;
addLuaEventHandler(dstrview(handler->event), room->events,
dstrview(handler->function), room->L);
nextEventHandler = g_list_next(nextEventHandler);
}
return room;
}
static void initGlobalEvents() {
GList *nextEventHandler = globalEventHandlersParsed;
globalL = initLuaState(globalScriptsParsed);
while (nextEventHandler != NULL) {
EventHandlerParsed *handler = (EventHandlerParsed *)nextEventHandler->data;
addGlobalLuaEventHandler(dstrview(handler->event),
dstrview(handler->function), globalL);
nextEventHandler = g_list_next(nextEventHandler);
}
}
LoadResult SyntaxReader::load ( const string& langDefPath, const string& pluginReadFilePath, OutputType outputType, bool clear )
{
currentPath=langDefPath;
disableHighlighting=false;
if (!Platform::fileExists(langDefPath)){
return LOAD_FAILED;
}
try {
if (luaState) delete luaState;
luaState=new Diluculum::LuaState();
Diluculum::LuaState& ls=*luaState;
initLuaState(ls, langDefPath, pluginReadFilePath, outputType);
lua_register (ls.getState(),"AddKeyword",luaAddKeyword);
SyntaxReader **s = (SyntaxReader **)lua_newuserdata(ls.getState(), sizeof(SyntaxReader *));
*s=this;
lua_setglobal(ls.getState(), GLOBAL_INSTANCE_NAME);
// ececute script and read values
ls.doFile (langDefPath);
langDesc = ls["Description"].value().asString();
if (pluginChunks.size()){
Diluculum::LuaValueList params;
params.push_back(langDesc);
for (unsigned int i=0;i<pluginChunks.size();i++){
ls.call(*pluginChunks[i], params, "syntax user function");
}
}
Diluculum::LuaValueMap globals = ls.globals();
ignoreCase=readFlag(ls["IgnoreCase"]);
reformatCode=readFlag(ls["EnableIndentation"]);
disableHighlighting=readFlag(ls["DisableHighlighting"]);
int idx=1;
int keywordIdx=0;
int kwId=0;
char kwName[5]={0};
while (ls["Keywords"][idx].value() !=Diluculum::Nil) {
keywordIdx=ls["Keywords"][idx]["Id"].value().asNumber();
snprintf(kwName, sizeof(kwName), "kw%c", ('a'+keywordIdx-1)); // TODO kwa -> kw1...
kwId= generateNewKWClass ( kwName );
if (ls["Keywords"][idx]["List"].value()!=Diluculum::Nil) {
int listIdx=1;
Diluculum::LuaVariable luaList=ls["Keywords"][idx]["List"];
while (luaList[listIdx].value()!=Diluculum::Nil) {
keywords.insert ( make_pair ( luaList[listIdx].value().asString(), kwId ) );
++listIdx;
}
} else if (ls["Keywords"][idx]["Regex"].value()!=Diluculum::Nil) {
string reString=StringTools::trim(ls["Keywords"][idx]["Regex"].value().asString());
int captGroup=-1;
if (ls["Keywords"][idx]["Group"].value()!=Diluculum::Nil) {
captGroup=ls["Keywords"][idx]["Group"].value().asNumber();
}
regex.push_back ( new RegexElement ( KEYWORD, KEYWORD_END, reString, kwId, captGroup ) );
}
idx++;
}
if (globals.count("Comments")) {
int listIdx=1;
int openDelimId=0;
int closeDelimId=0;
while (ls["Comments"][listIdx].value()!=Diluculum::Nil) {
if (ls["Comments"][listIdx]["Block"].value().asBoolean()) {
if (ls["Comments"][listIdx]["Nested"].value()!=Diluculum::Nil)
allowNestedComments = ls["Comments"][listIdx]["Nested"].value().asBoolean();
string openDelim=StringTools::trim(ls["Comments"][listIdx]["Delimiter"][1].value().asString());
RegexElement* elem=new RegexElement ( ML_COMMENT,ML_COMMENT_END, openDelim, 0, -1 );
openDelimId=elem->instanceId;
regex.push_back ( elem );
string closeDelim=StringTools::trim(ls["Comments"][listIdx]["Delimiter"][2].value().asString());
elem= new RegexElement ( ML_COMMENT_END,ML_COMMENT_END, closeDelim, 0, -1 );
closeDelimId=elem->instanceId;
regex.push_back ( elem);
delimiterDistinct[openDelimId]=openDelim!=closeDelim;
delimiterDistinct[closeDelimId]=openDelim!=closeDelim;
delimIds2[closeDelimId]=openDelimId;
} else {
regex.push_back ( new RegexElement ( SL_COMMENT, SL_COMMENT_END, StringTools::trim(ls["Comments"][listIdx]["Delimiter"][1].value().asString()), 0, -1 ) );
}
++listIdx;
}
}
//move behind comment section because of fortran comments (^cC.*$)
string re_digit = StringTools::trim(ls["Digits"].value().asString());
string re_identifier= StringTools::trim(ls["Identifiers"].value().asString());
// insert identifier and number regex after keyword regexes
regex.push_back ( new RegexElement ( IDENTIFIER_BEGIN, IDENTIFIER_END,
re_identifier ) );
regex.push_back ( new RegexElement ( NUMBER, NUMBER_END,
re_digit ) );
if (globals.count("Strings")) {
if (ls["Strings"]["RawPrefix"].value()!=Diluculum::Nil) {
rawStringPrefix=ls["Strings"]["RawPrefix"].value().asString().at(0);
}
if (ls["Strings"]["Delimiter"].value()!=Diluculum::Nil) {
RegexElement* elem=new RegexElement ( STRING,STRING_END, StringTools::trim( ls["Strings"]["Delimiter"].value().asString()), 0, -1 );
delimiterDistinct[elem->instanceId]=true;
regex.push_back (elem );
}
if (ls["Strings"]["Interpolation"].value()!=Diluculum::Nil) {
RegexElement* elem=new RegexElement ( STRING_INTERPOLATION, STRING_INTERPOLATION_END, StringTools::trim( ls["Strings"]["Interpolation"].value().asString()), 0, -1 );
regex.push_back (elem );
}
if (ls["Strings"]["DelimiterPairs"].value()!=Diluculum::Nil) {
int listIdx=1;
int openDelimId=0;
int closeDelimId=0;
while (ls["Strings"]["DelimiterPairs"][listIdx].value()!=Diluculum::Nil) {
string openDelim=StringTools::trim(ls["Strings"]["DelimiterPairs"][listIdx]["Open"].value().asString());
RegexElement* elem =new RegexElement(STRING, STRING_END, openDelim, 0, -1);
openDelimId=elem->instanceId;
regex.push_back( elem );
string closeDelim=StringTools::trim(ls["Strings"]["DelimiterPairs"][listIdx]["Close"].value().asString());
elem = new RegexElement(STRING_END, STRING_END, closeDelim, 0, -1);
closeDelimId=elem->instanceId;
regex.push_back( elem );
delimIds2[closeDelimId]=openDelimId;
if (ls["Strings"]["DelimiterPairs"][listIdx]["Raw"].value()!=Diluculum::Nil){
rawStringOpenDelims[openDelimId]=ls["Strings"]["DelimiterPairs"][listIdx]["Raw"].value().asBoolean();
}
++listIdx;
}
}
string escRegex=(ls["Strings"]["Escape"].value()==Diluculum::Nil)?REGEX_ESCSEQ:ls["Strings"]["Escape"].value().asString();
regex.push_back ( new RegexElement ( ESC_CHAR,ESC_CHAR_END, StringTools::trim(escRegex), 0, -1 ) );
}
if (globals.count("PreProcessor")) {
regex.push_back ( new RegexElement ( DIRECTIVE,DIRECTIVE_END, StringTools::trim(ls["PreProcessor"]["Prefix"].value().asString()), 0, -1 ) );
if (ls["PreProcessor"]["Continuation"].value()!=Diluculum::Nil) {
continuationChar=ls["PreProcessor"]["Continuation"].value().asString().at(0);
}
}
if (globals.count("Operators")) {
regex.push_back ( new RegexElement ( SYMBOL,SYMBOL_END, StringTools::trim( ls["Operators"].value().asString()), 0, -1 ) );
}
if (globals.count("NestedSections")) {
int listIdx=1;
while (ls["NestedSections"][listIdx].value()!=Diluculum::Nil) {
string lang= ls["NestedSections"][listIdx]["Lang"].value().asString();
string openDelim=StringTools::trim(ls["NestedSections"][listIdx]["Delimiter"][1].value().asString());
regex.insert(regex.begin(), 1, new RegexElement(EMBEDDED_CODE_BEGIN, EMBEDDED_CODE_BEGIN, openDelim, 0, -1, lang));
string closeDelim=StringTools::trim(ls["NestedSections"][listIdx]["Delimiter"][2].value().asString());
exitDelimiters[getNewPath(lang)] = closeDelim;
++listIdx;
}
}
if (globals.count("HeaderInjection")) {
headerInjection+= ls["HeaderInjection"].value().asString();
}
if (globals.count("FooterInjection")) {
footerInjection+= ls["FooterInjection"].value().asString();
}
// load hook functions
if (globals.count("OnStateChange")) {
validateStateChangeFct=new Diluculum::LuaFunction(ls["OnStateChange"].value().asFunction());
}
if (globals.count("Decorate")) {
decorateFct=new Diluculum::LuaFunction(ls["Decorate"].value().asFunction());
}
} catch (Diluculum::LuaError err) {
luaErrorMsg = string(err.what());
return LOAD_FAILED_LUA;
}
return LOAD_OK;
}
static Creature *initCreature(CreatureParsed *creatureParsed) {
int i;
GList *nextEventHandler;
Creature *creature = createCreature(FALSE);
GArray *objectNames = creatureParsed->objects;
creature->name = creatureParsed->name;
creature->title = creatureParsed->title;
creature->description = creatureParsed->description;
creature->messages = creatureParsed->messages;
creature->attackable = creatureParsed->attackable;
creature->woundRate = creatureParsed->woundRate;
creature->counterattack = creatureParsed->counterattack;
/* creature's attributes */
creature->attributes.strength = creatureParsed->attributes.strength;
creature->attributes.dexterity = creatureParsed->attributes.dexterity;
creature->attributes.intelligence = creatureParsed->attributes.intelligence;
creature->attributes.initialTotal = creature->attributes.strength +
creature->attributes.dexterity + creature->attributes.intelligence;
/* health settings */
creature->maxHealth = creatureParsed->maxHealth;
creature->state.health = creatureParsed->health;
creature->state.alive = creatureParsed->alive;
if (NULL != creatureParsed->allegiance) {
if (0 == strcmp(dstrview(creatureParsed->allegiance), "neutral")) {
creature->allegiance = CREATURE_ALLEGIANCE_NEUTRAL;
}
else if (0 == strcmp(dstrview(creatureParsed->allegiance), "friend")) {
creature->allegiance = CREATURE_ALLEGIANCE_FRIEND;
}
else if (0 == strcmp(dstrview(creatureParsed->allegiance), "enemy")) {
creature->allegiance = CREATURE_ALLEGIANCE_ENEMY;
}
else {
g_outputError("%s is not a valid allegiance for creature '%s'!\n",
dstrview(creatureParsed->allegiance),
dstrview(creatureParsed->name));
exit(EXIT_FAILURE);
}
}
/* initialize lua state for creature */
creature->L = initLuaState(creatureParsed->scripts);
/* initialize entity-specific event handlers */
nextEventHandler = creatureParsed->eventHandlers;
while (NULL != nextEventHandler) {
EventHandlerParsed *handler = (EventHandlerParsed *)nextEventHandler->data;
addLuaEventHandler(dstrview(handler->event), creature->events,
dstrview(handler->function), creature->L);
nextEventHandler = g_list_next(nextEventHandler);
}
/* add objects to the creature's inventory */
for (i = 0; i < objectNames->len; i++) {
dstring_t *objectName = g_array_index(objectNames, dstring_t, i);
Object *object = g_hash_table_lookup(g_objects, (char *)dstrview(objectName));
creature->inventory.list = addObject(creature->inventory.list,
creature->inventory.byName, objectName);
object->state.owner.entity = creature;
object->state.owner.type = entity_creature;
}
return creature;
}
