void AutosaveSave(Autosave *autosave, const char *filename)
{
FILE *f = fopen(filename, "w");
char *text = NULL;
json_t *root;
if (f == NULL)
{
printf("Error saving autosave '%s'\n", filename);
return;
}
setlocale(LC_ALL, "");
root = json_new_object();
json_insert_pair_into_object(root, "Version", json_new_number("2"));
json_insert_pair_into_object(
root, "LastMission", CreateMissionNode(&autosave->LastMission));
AddMissionNodes(autosave, root, "Missions");
json_tree_to_string(root, &text);
char *formatText = json_format_string(text);
fputs(formatText, f);
// clean up
free(formatText);
free(text);
json_free_value(&root);
fclose(f);
}
int MapArchiveSave(const char *filename, CampaignSetting *c)
{
int res = 1;
json_t *root = NULL;
char relbuf[CDOGS_PATH_MAX];
if (strcmp(StrGetFileExt(filename), "cdogscpn") == 0 ||
strcmp(StrGetFileExt(filename), "CDOGSCPN") == 0)
{
strcpy(relbuf, filename);
}
else
{
sprintf(relbuf, "%s.cdogscpn", filename);
}
char buf[CDOGS_PATH_MAX];
RealPath(relbuf, buf);
// Make dir but ignore error, as we may be saving over an existing dir
mkdir_deep(buf);
// Campaign
root = json_new_object();
AddIntPair(root, "Version", MAP_VERSION);
AddStringPair(root, "Title", c->Title);
AddStringPair(root, "Author", c->Author);
AddStringPair(root, "Description", c->Description);
AddIntPair(root, "Missions", c->Missions.size);
char buf2[CDOGS_PATH_MAX];
sprintf(buf2, "%s/campaign.json", buf);
if (!TrySaveJSONFile(root, buf2))
{
res = 0;
goto bail;
}
json_free_value(&root);
root = json_new_object();
json_insert_pair_into_object(root, "Missions", SaveMissions(&c->Missions));
sprintf(buf2, "%s/missions.json", buf);
if (!TrySaveJSONFile(root, buf2))
{
res = 0;
goto bail;
}
json_free_value(&root);
root = json_new_object();
json_insert_pair_into_object(
root, "Characters", SaveCharacters(&c->characters));
sprintf(buf2, "%s/characters.json", buf);
if (!TrySaveJSONFile(root, buf2))
{
res = 0;
goto bail;
}
bail:
json_free_value(&root);
return res;
}
static void AddCampaignNode(CampaignEntry *c, json_t *root)
{
json_t *subConfig = json_new_object();
// Save relative path so that save files are portable across installs
char path[CDOGS_PATH_MAX] = "";
RelPathFromCWD(path, c->Path);
json_insert_pair_into_object(
subConfig, "Path", json_new_string(path));
json_insert_pair_into_object(root, "Campaign", subConfig);
}
static void AddGameConfigNode(GameConfig *config, json_t *root)
{
char buf[32];
json_t *subConfig = json_new_object();
json_insert_pair_into_object(
subConfig, "FriendlyFire", json_new_bool(config->FriendlyFire));
sprintf(buf, "%u", config->RandomSeed);
json_insert_pair_into_object(
subConfig, "RandomSeed", json_new_number(buf));
JSON_UTILS_ADD_ENUM_PAIR(subConfig, "Difficulty", config->Difficulty, DifficultyStr);
json_insert_pair_into_object(
subConfig, "SlowMotion", json_new_bool(config->SlowMotion));
AddIntPair(subConfig, "EnemyDensity", config->EnemyDensity);
AddIntPair(subConfig, "NonPlayerHP", config->NonPlayerHP);
AddIntPair(subConfig, "PlayerHP", config->PlayerHP);
json_insert_pair_into_object(
subConfig, "Fog", json_new_bool(config->Fog));
AddIntPair(subConfig, "SightRange", config->SightRange);
json_insert_pair_into_object(
subConfig, "Shadows", json_new_bool(config->Shadows));
json_insert_pair_into_object(
subConfig, "MoveWhenShooting", json_new_bool(config->MoveWhenShooting));
JSON_UTILS_ADD_ENUM_PAIR(
subConfig, "SwitchMoveStyle", config->SwitchMoveStyle, SwitchMoveStyleStr);
json_insert_pair_into_object(
subConfig, "ShotsPushback", json_new_bool(config->ShotsPushback));
JSON_UTILS_ADD_ENUM_PAIR(
subConfig, "AllyCollision", config->AllyCollision, AllyCollisionStr);
json_insert_pair_into_object(
subConfig, "HealthPickups", json_new_bool(config->HealthPickups));
json_insert_pair_into_object(root, "Game", subConfig);
}
static void AddInputConfigNode(InputConfig *config, json_t *root)
{
int i;
json_t *subConfig = json_new_object();
json_t *keyConfigs = json_new_array();
for (i = 0; i < 2; i++)
{
AddKeyConfigNode(&config->PlayerKeys[i], keyConfigs);
}
json_insert_pair_into_object(subConfig, "Keys", keyConfigs);
json_insert_pair_into_object(root, "Input", subConfig);
}
void AddStringPair(json_t *parent, const char *name, const char *s)
{
if (!s)
{
json_insert_pair_into_object(parent, name, json_new_string(""));
}
else
{
json_insert_pair_into_object(
parent, name, json_new_string(json_escape(s)));
}
}
static void AddSoundConfigNode(SoundConfig *config, json_t *root)
{
json_t *subConfig = json_new_object();
AddIntPair(subConfig, "SoundVolume", config->SoundVolume);
AddIntPair(subConfig, "MusicVolume", config->MusicVolume);
json_insert_pair_into_object(
subConfig, "Footsteps", json_new_bool(config->Footsteps));
json_insert_pair_into_object(
subConfig, "Hits", json_new_bool(config->Hits));
json_insert_pair_into_object(
subConfig, "Reloads", json_new_bool(config->Reloads));
json_insert_pair_into_object(root, "Sound", subConfig);
}
static void AddGraphicsConfigNode(GraphicsConfig *config, json_t *root)
{
json_t *subConfig = json_new_object();
AddIntPair(subConfig, "Brightness", config->Brightness);
AddIntPair(subConfig, "ResolutionWidth", config->Res.x);
AddIntPair(subConfig, "ResolutionHeight", config->Res.y);
json_insert_pair_into_object(
subConfig, "Fullscreen", json_new_bool(config->Fullscreen));
AddIntPair(subConfig, "ScaleFactor", config->ScaleFactor);
AddIntPair(subConfig, "ShakeMultiplier", config->ShakeMultiplier);
JSON_UTILS_ADD_ENUM_PAIR(subConfig, "ScaleMode", config->ScaleMode, ScaleModeStr);
json_insert_pair_into_object(root, "Graphics", subConfig);
}
static void AddInterfaceConfigNode(InterfaceConfig *config, json_t *root)
{
json_t *subConfig = json_new_object();
json_insert_pair_into_object(
subConfig, "ShowFPS", json_new_bool(config->ShowFPS));
json_insert_pair_into_object(
subConfig, "ShowTime", json_new_bool(config->ShowTime));
json_insert_pair_into_object(
subConfig, "Splitscreen",
json_new_string(SplitscreenStyleStr(config->Splitscreen)));
json_insert_pair_into_object(
subConfig, "ShowHUDMap", json_new_bool(config->ShowHUDMap));
json_insert_pair_into_object(root, "Interface", subConfig);
}
bool jps_method(LSHandle* lshandle, LSMessage *message, void *ctx) {
bool returnVal = true;
char line[MAXLINELEN];
// %%% MAGIC NUMBERS ALERT %%%
char name[128];
LSError lserror;
LSErrorInit(&lserror);
char *jsonResponse = 0;
int len = 0;
json_t *response = json_new_object();
FILE *fp = popen("/usr/bin/jps", "r");
if (fp) {
json_t *array = json_new_array();
// Skip the first line
(void)fgets( line, sizeof line, fp);
while ( fgets( line, sizeof line, fp)) {
if (sscanf(line, "%*d %*d %*d %*d %*d %*d %*d %127c",
(char*)&name) == 1) {
// %%% HACK ALERT %%%
*strchr(name,'\n') = 0;
json_t *object = json_new_object();
// %%% IGNORING RETURN ALERT %%%
json_insert_pair_into_object(object, "name", json_new_string(name));
json_insert_child(array, object);
}
}
if (!pclose(fp)) {
// %%% IGNORING RETURN ALERT %%%
json_insert_pair_into_object(response, "returnValue", json_new_true());
json_insert_pair_into_object(response, "threads", array);
json_tree_to_string(response, &jsonResponse);
}
}
if (jsonResponse) {
LSMessageReply(lshandle, message, jsonResponse, &lserror);
free(jsonResponse);
} else
LSMessageReply(lshandle, message, "{\"returnValue\":false,\"errorCode\":-1,\"errorText\":\"Generic error\"}", &lserror);
json_free_value(&response);
LSErrorFree(&lserror);
return returnVal;
}
void ConfigSaveJSON(Config *config, const char *filename)
{
FILE *f = fopen(filename, "w");
char *text = NULL;
json_t *root;
if (f == NULL)
{
printf("Error saving config '%s'\n", filename);
return;
}
setlocale(LC_ALL, "");
root = json_new_object();
json_insert_pair_into_object(root, "Version", json_new_number(VERSION));
AddGameConfigNode(&config->Game, root);
AddGraphicsConfigNode(&config->Graphics, root);
AddInputConfigNode(&config->Input, root);
AddInterfaceConfigNode(&config->Interface, root);
AddSoundConfigNode(&config->Sound, root);
AddQuickPlayConfigNode(&config->QuickPlay, root);
json_tree_to_string(root, &text);
char *formatText = json_format_string(text);
fputs(formatText, f);
// clean up
CFREE(formatText);
CFREE(text);
json_free_value(&root);
fclose(f);
}
void ConfigSaveJSON(const Config *config, const char *filename)
{
FILE *f = fopen(filename, "w");
char *text = NULL;
json_t *root;
if (f == NULL)
{
printf("Error saving config '%s'\n", filename);
return;
}
setlocale(LC_ALL, "");
root = json_new_object();
json_insert_pair_into_object(root, "Version", json_new_number(VERSION));
ConfigSaveVisit(config, root);
json_tree_to_string(root, &text);
char *formatText = json_format_string(text);
fputs(formatText, f);
// clean up
CFREE(formatText);
CFREE(text);
json_free_value(&root);
fclose(f);
}
static json_t *SaveCharacters(CharacterStore *s)
{
json_t *charNode = json_new_array();
int i;
for (i = 0; i < (int)s->OtherChars.size; i++)
{
json_t *node = json_new_object();
Character *c = CArrayGet(&s->OtherChars, i);
AddIntPair(node, "face", c->looks.Face);
AddIntPair(node, "skin", c->looks.Skin);
AddIntPair(node, "arm", c->looks.Arm);
AddIntPair(node, "body", c->looks.Body);
AddIntPair(node, "leg", c->looks.Leg);
AddIntPair(node, "hair", c->looks.Hair);
AddIntPair(node, "speed", c->speed);
json_insert_pair_into_object(
node, "Gun", json_new_string(c->Gun->name));
AddIntPair(node, "maxHealth", c->maxHealth);
AddIntPair(node, "flags", c->flags);
AddIntPair(node, "probabilityToMove", c->bot->probabilityToMove);
AddIntPair(node, "probabilityToTrack", c->bot->probabilityToTrack);
AddIntPair(node, "probabilityToShoot", c->bot->probabilityToShoot);
AddIntPair(node, "actionDelay", c->bot->actionDelay);
json_insert_child(charNode, node);
}
return charNode;
}
static void AddMissionNodes(Autosave *a, json_t *root, const char *nodeName)
{
json_t *missions = json_new_array();
CA_FOREACH(MissionSave, m, a->Missions)
json_insert_child(missions, CreateMissionNode(m));
CA_FOREACH_END()
json_insert_pair_into_object(root, nodeName, missions);
}
static json_t *CreateMissionNode(MissionSave *m)
{
json_t *subConfig = json_new_object();
AddCampaignNode(&m->Campaign, subConfig);
json_insert_pair_into_object(subConfig, "Password", json_new_string(m->Password));
AddIntPair(subConfig, "MissionsCompleted", m->MissionsCompleted);
return subConfig;
}
static void ConfigSaveVisit(const Config *c, json_t *node)
{
switch (c->Type)
{
case CONFIG_TYPE_STRING:
CASSERT(false, "not implemented");
break;
case CONFIG_TYPE_INT:
AddIntPair(node, c->Name, c->u.Int.Value);
break;
case CONFIG_TYPE_FLOAT:
CASSERT(false, "not implemented");
break;
case CONFIG_TYPE_BOOL:
json_insert_pair_into_object(
node, c->Name, json_new_bool(c->u.Bool.Value));
break;
case CONFIG_TYPE_ENUM:
JSON_UTILS_ADD_ENUM_PAIR(
node, c->Name, c->u.Enum.Value, c->u.Enum.EnumToStr);
break;
case CONFIG_TYPE_GROUP:
{
json_t *child = node;
// If the config has no name, then it is the root element
// Add children directly to the node
// Otherwise, create a new child
if (c->Name != NULL)
{
child = json_new_object();
}
CA_FOREACH(Config, cg, c->u.Group)
ConfigSaveVisit(cg, child);
CA_FOREACH_END()
if (c->Name != NULL)
{
json_insert_pair_into_object(node, c->Name, child);
}
}
break;
default:
CASSERT(false, "Unknown config type");
break;
}
}
static json_t *SaveStaticObjectives(Mission *m)
{
json_t *objs = json_new_array();
CA_FOREACH(ObjectivePositions, op, m->u.Static.Objectives)
json_t *objNode = json_new_object();
AddIntPair(objNode, "Index", op->Index);
json_t *positions = json_new_array();
for (int j = 0; j < (int)op->Positions.size; j++)
{
Vec2i *pos = CArrayGet(&op->Positions, j);
json_insert_child(positions, SaveVec2i(*pos));
}
json_insert_pair_into_object(
objNode, "Positions", positions);
json_insert_pair_into_object(
objNode, "Indices", SaveIntArray(&op->Indices));
json_insert_child(objs, objNode);
CA_FOREACH_END()
return objs;
}
static void AddKeysNode(input_keys_t *keys, json_t *parent)
{
json_t *subConfig = json_new_object();
// TODO: key names (there's no key name to int conversion)
AddIntPair(subConfig, "left", keys->left);
AddIntPair(subConfig, "right", keys->right);
AddIntPair(subConfig, "up", keys->up);
AddIntPair(subConfig, "down", keys->down);
AddIntPair(subConfig, "button1", keys->button1);
AddIntPair(subConfig, "button2", keys->button2);
AddIntPair(subConfig, "map", keys->map);
json_insert_pair_into_object(parent, "Keys", subConfig);
}
void ScriptDialog::saveJson()
{
json_t *root = json_new_object();
json_t *t;
t = json_new_number((const char*)m_id.toLatin1());
json_insert_pair_into_object(root, "id", t);
t = json_new_string((const char*)m_title.toLocal8Bit());
json_insert_pair_into_object(root, "title", t);
t = json_new_string((const char*)m_url.toLocal8Bit());
json_insert_pair_into_object(root, "url", t);
json_t *seqNode = json_new_array();
for(int i=0, len=m_stepSeq.size(); i<len; ++i){
QString s = m_stepSeq.at(i);
json_t *v = json_new_string((const char*)s.toLocal8Bit());
json_insert_child(seqNode, v);
}
json_t *stepsNode = json_new_object();
json_insert_pair_into_object(stepsNode, "seq", seqNode);
QMapIterator<QString, QString> iter(m_steps);
while(iter.hasNext()){
iter.next();
if(iter.value().isEmpty())continue;
QByteArray ba_k = iter.key().toLocal8Bit();
const char *k = (const char*)ba_k;
QByteArray ba_v = iter.value().toLocal8Bit();
char *v = ba_v.data();
QByteArray ba_t = m_stepTests.value(iter.key()).toLocal8Bit();
char *t = ba_t.data();
v = json_escape(v);
t = json_escape(t);
json_t *vn = json_new_string( v );
json_t *tn = json_new_string( t );
json_t *step = json_new_object();
json_insert_pair_into_object(step, "test", tn);
json_insert_pair_into_object(step, "script", vn);
json_insert_pair_into_object(stepsNode, k, step);
}
json_insert_pair_into_object(root, "steps", stepsNode);
BatDownUtils::writeJsonToFile(root, m_fn);
}
json_t*
YtkUtils::mapToJson(const YtkUtils::map_t& map)
{
json_t* root = json_new_object();
YtkUtils::map_t::const_iterator pos;
for(pos = map.begin(); pos != map.end(); ++pos) {
const char* k = pos->first.c_str();
const char* val = pos->second.c_str();
char* t = new char[strlen(val)+1];
strcpy(t, val);
char* s = json_escape( t );
delete[] t;
json_t *v = json_new_string(s);
json_insert_pair_into_object(root, k, v);
}
return root;
}
static json_t *SaveStaticKeys(Mission *m)
{
json_t *keys = json_new_array();
CA_FOREACH(KeyPositions, kp, m->u.Static.Keys)
json_t *keyNode = json_new_object();
AddIntPair(keyNode, "Index", kp->Index);
json_t *positions = json_new_array();
for (int j = 0; j < (int)kp->Positions.size; j++)
{
Vec2i *pos = CArrayGet(&kp->Positions, j);
json_insert_child(positions, SaveVec2i(*pos));
}
json_insert_pair_into_object(
keyNode, "Positions", positions);
json_insert_child(keys, keyNode);
CA_FOREACH_END()
return keys;
}
static json_t *SaveStaticCharacters(Mission *m)
{
json_t *chars = json_new_array();
CA_FOREACH(CharacterPositions, cp, m->u.Static.Characters)
json_t *charNode = json_new_object();
AddIntPair(charNode, "Index", cp->Index);
json_t *positions = json_new_array();
for (int j = 0; j < (int)cp->Positions.size; j++)
{
Vec2i *pos = CArrayGet(&cp->Positions, j);
json_insert_child(positions, SaveVec2i(*pos));
}
json_insert_pair_into_object(
charNode, "Positions", positions);
json_insert_child(chars, charNode);
CA_FOREACH_END()
return chars;
}
static json_t *SaveStaticWrecks(Mission *m)
{
json_t *wrecks = json_new_array();
CA_FOREACH(MapObjectPositions, mop, m->u.Static.Wrecks)
json_t *wreckNode = json_new_object();
AddStringPair(wreckNode, "MapObject", mop->M->Name);
json_t *positions = json_new_array();
for (int j = 0; j < (int)mop->Positions.size; j++)
{
Vec2i *pos = CArrayGet(&mop->Positions, j);
json_insert_child(positions, SaveVec2i(*pos));
}
json_insert_pair_into_object(
wreckNode, "Positions", positions);
json_insert_child(wrecks, wreckNode);
CA_FOREACH_END()
return wrecks;
}
static json_t *SaveStaticItems(Mission *m)
{
json_t *items = json_new_array();
for (int i = 0; i < (int)m->u.Static.Items.size; i++)
{
MapObjectPositions *mop =
CArrayGet(&m->u.Static.Items, i);
json_t *itemNode = json_new_object();
AddStringPair(itemNode, "MapObject", mop->M->Name);
json_t *positions = json_new_array();
for (int j = 0; j < (int)mop->Positions.size; j++)
{
Vec2i *pos = CArrayGet(&mop->Positions, j);
json_insert_child(positions, SaveVec2i(*pos));
}
json_insert_pair_into_object(
itemNode, "Positions", positions);
json_insert_child(items, itemNode);
}
return items;
}
static json_t *SaveCharacters(CharacterStore *s)
{
json_t *charNode = json_new_array();
CA_FOREACH(Character, c, s->OtherChars)
json_t *node = json_new_object();
AddStringPair(node, "Class", c->Class->Name);
AddColorPair(node, "Skin", c->Colors.Skin);
AddColorPair(node, "Arms", c->Colors.Arms);
AddColorPair(node, "Body", c->Colors.Body);
AddColorPair(node, "Legs", c->Colors.Legs);
AddColorPair(node, "Hair", c->Colors.Hair);
AddIntPair(node, "speed", c->speed);
json_insert_pair_into_object(
node, "Gun", json_new_string(c->Gun->name));
AddIntPair(node, "maxHealth", c->maxHealth);
AddIntPair(node, "flags", c->flags);
AddIntPair(node, "probabilityToMove", c->bot->probabilityToMove);
AddIntPair(node, "probabilityToTrack", c->bot->probabilityToTrack);
AddIntPair(node, "probabilityToShoot", c->bot->probabilityToShoot);
AddIntPair(node, "actionDelay", c->bot->actionDelay);
json_insert_child(charNode, node);
CA_FOREACH_END()
return charNode;
}
void AddBoolPair(json_t *parent, const char *name, int value)
{
json_insert_pair_into_object(parent, name, json_new_bool(value));
}
void AddIntPair(json_t *parent, const char *name, int number)
{
char buf[32];
sprintf(buf, "%d", number);
json_insert_pair_into_object(parent, name, json_new_number(buf));
}
static json_t *SaveMissions(CArray *a)
{
json_t *missionsNode = json_new_array();
for (int i = 0; i < (int)a->size; i++)
{
json_t *node = json_new_object();
Mission *mission = CArrayGet(a, i);
AddStringPair(node, "Title", mission->Title);
AddStringPair(node, "Description", mission->Description);
AddStringPair(node, "Type", MapTypeStr(mission->Type));
AddIntPair(node, "Width", mission->Size.x);
AddIntPair(node, "Height", mission->Size.y);
AddIntPair(node, "WallStyle", mission->WallStyle);
AddIntPair(node, "FloorStyle", mission->FloorStyle);
AddIntPair(node, "RoomStyle", mission->RoomStyle);
AddIntPair(node, "ExitStyle", mission->ExitStyle);
AddIntPair(node, "KeyStyle", mission->KeyStyle);
AddStringPair(node, "DoorStyle", mission->DoorStyle);
json_insert_pair_into_object(
node, "Objectives", SaveObjectives(&mission->Objectives));
json_insert_pair_into_object(
node, "Enemies", SaveIntArray(&mission->Enemies));
json_insert_pair_into_object(
node, "SpecialChars", SaveIntArray(&mission->SpecialChars));
json_t *modsNode = json_new_array();
for (int j = 0; j < (int)mission->MapObjectDensities.size; j++)
{
const MapObjectDensity *mod =
CArrayGet(&mission->MapObjectDensities, j);
json_t *modNode = json_new_object();
AddStringPair(modNode, "MapObject", mod->M->Name);
AddIntPair(modNode, "Density", mod->Density);
json_insert_child(modsNode, modNode);
}
json_insert_pair_into_object(node, "MapObjectDensities", modsNode);
AddIntPair(node, "EnemyDensity", mission->EnemyDensity);
json_insert_pair_into_object(
node, "Weapons", SaveWeapons(&mission->Weapons));
json_insert_pair_into_object(
node, "Song", json_new_string(mission->Song));
AddColorPair(node, "WallMask", mission->WallMask);
AddColorPair(node, "FloorMask", mission->FloorMask);
AddColorPair(node, "RoomMask", mission->RoomMask);
AddColorPair(node, "AltMask", mission->AltMask);
switch (mission->Type)
{
case MAPTYPE_CLASSIC:
AddIntPair(node, "Walls", mission->u.Classic.Walls);
AddIntPair(node, "WallLength", mission->u.Classic.WallLength);
AddIntPair(
node, "CorridorWidth", mission->u.Classic.CorridorWidth);
json_insert_pair_into_object(
node, "Rooms", SaveClassicRooms(mission));
AddIntPair(node, "Squares", mission->u.Classic.Squares);
json_insert_pair_into_object(
node, "Doors", SaveClassicDoors(mission));
json_insert_pair_into_object(
node, "Pillars", SaveClassicPillars(mission));
break;
case MAPTYPE_STATIC:
{
json_insert_pair_into_object(
node, "Tiles", SaveStaticTiles(mission));
json_insert_pair_into_object(
node, "StaticItems", SaveStaticItems(mission));
json_insert_pair_into_object(
node, "StaticWrecks", SaveStaticWrecks(mission));
json_insert_pair_into_object(
node, "StaticCharacters", SaveStaticCharacters(mission));
json_insert_pair_into_object(
node, "StaticObjectives", SaveStaticObjectives(mission));
json_insert_pair_into_object(
node, "StaticKeys", SaveStaticKeys(mission));
json_insert_pair_into_object(
node, "Start", SaveVec2i(mission->u.Static.Start));
json_t *exitNode = json_new_object();
json_insert_pair_into_object(
exitNode, "Start",
SaveVec2i(mission->u.Static.Exit.Start));
json_insert_pair_into_object(
exitNode, "End",
SaveVec2i(mission->u.Static.Exit.End));
json_insert_pair_into_object(node, "Exit", exitNode);
}
break;
default:
assert(0 && "unknown map type");
break;
}
json_insert_child(missionsNode, node);
}
return missionsNode;
}
static void AddQuickPlayConfigNode(QuickPlayConfig *config, json_t *root)
{
json_t *subConfig = json_new_object();
json_insert_pair_into_object(
subConfig, "MapSize", json_new_string(QuickPlayQuantityStr(config->MapSize)));
json_insert_pair_into_object(
subConfig, "WallCount", json_new_string(QuickPlayQuantityStr(config->WallCount)));
json_insert_pair_into_object(
subConfig, "WallLength", json_new_string(QuickPlayQuantityStr(config->WallLength)));
json_insert_pair_into_object(
subConfig, "RoomCount", json_new_string(QuickPlayQuantityStr(config->RoomCount)));
json_insert_pair_into_object(
subConfig, "SquareCount", json_new_string(QuickPlayQuantityStr(config->SquareCount)));
json_insert_pair_into_object(
subConfig, "EnemyCount", json_new_string(QuickPlayQuantityStr(config->EnemyCount)));
json_insert_pair_into_object(
subConfig, "EnemySpeed", json_new_string(QuickPlayQuantityStr(config->EnemySpeed)));
json_insert_pair_into_object(
subConfig, "EnemyHealth", json_new_string(QuickPlayQuantityStr(config->EnemyHealth)));
json_insert_pair_into_object(
subConfig, "EnemiesWithExplosives", json_new_bool(config->EnemiesWithExplosives));
json_insert_pair_into_object(
subConfig, "ItemCount", json_new_string(QuickPlayQuantityStr(config->ItemCount)));
json_insert_pair_into_object(root, "QuickPlay", subConfig);
}
bool list_method(LSHandle* lshandle, LSMessage *message, void *ctx) {
bool returnVal = true;
char line[MAXLINELEN];
// %%% MAGIC NUMBERS ALERT %%%
char name[128];
char state[16];
char status[128];
LSError lserror;
LSErrorInit(&lserror);
char *jsonResponse = 0;
int len = 0;
json_t *response = json_new_object();
FILE *fp = popen("/sbin/initctl list", "r");
if (fp) {
json_t *array = json_new_array();
while ( fgets( line, sizeof line, fp)) {
// %%% MAGIC NUMBERS ALERT %%%
if (sscanf(line, "%127s (start) %127c",
(char*)&name, (char *)&status) == 2) {
// %%% HACK ALERT %%%
*strchr(status,'\n') = 0;
json_t *object = json_new_object();
// %%% IGNORING RETURN ALERT %%%
json_insert_pair_into_object(object, "name", json_new_string(name));
json_insert_pair_into_object(object, "state", json_new_string("start"));
json_insert_pair_into_object(object, "status", json_new_string(status));
json_insert_child(array, object);
}
// %%% MAGIC NUMBERS ALERT %%%
else if (sscanf(line, "%127s (stop) %127c",
(char*)&name, (char *)&status) == 2) {
// %%% HACK ALERT %%%
*strchr(status,'\n') = 0;
json_t *object = json_new_object();
// %%% IGNORING RETURN ALERT %%%
json_insert_pair_into_object(object, "name", json_new_string(name));
json_insert_pair_into_object(object, "state", json_new_string("stop"));
json_insert_pair_into_object(object, "status", json_new_string(status));
json_insert_child(array, object);
}
}
if (!pclose(fp)) {
// %%% IGNORING RETURN ALERT %%%
json_insert_pair_into_object(response, "returnValue", json_new_true());
json_insert_pair_into_object(response, "jobs", array);
json_tree_to_string(response, &jsonResponse);
}
}
if (jsonResponse) {
LSMessageReply(lshandle, message, jsonResponse, &lserror);
free(jsonResponse);
} else
LSMessageReply(lshandle, message, "{\"returnValue\":false,\"errorCode\":-1,\"errorText\":\"Generic error\"}", &lserror);
json_free_value(&response);
LSErrorFree(&lserror);
return returnVal;
}
