static void LoadPlayerTemplate(
PlayerTemplate *t, json_t *node, const int version)
{
strcpy(t->name, json_find_first_label(node, "Name")->child->text);
t->Class = StrCharacterClass(
json_find_first_label(node, "Face")->child->text);
CASSERT(t->Class != NULL, "cannot find character class");
if (version == 1)
{
// Version 1 used integer palettes
int skin, arms, body, legs, hair;
LoadInt(&skin, node, "Skin");
LoadInt(&arms, node, "Arms");
LoadInt(&body, node, "Body");
LoadInt(&legs, node, "Legs");
LoadInt(&hair, node, "Hair");
ConvertCharacterColors(skin, arms, body, legs, hair, &t->Colors);
}
else
{
LoadColor(&t->Colors.Skin, node, "Skin");
LoadColor(&t->Colors.Arms, node, "Arms");
LoadColor(&t->Colors.Body, node, "Body");
LoadColor(&t->Colors.Legs, node, "Legs");
LoadColor(&t->Colors.Hair, node, "Hair");
}
}
static void LoadStaticKeys(Mission *m, json_t *node, char *name)
{
CArrayInit(&m->u.Static.Keys, sizeof(KeyPositions));
json_t *keys = json_find_first_label(node, name);
if (!keys || !keys->child)
{
return;
}
keys = keys->child;
for (keys = keys->child; keys; keys = keys->next)
{
KeyPositions kp;
LoadInt(&kp.Index, keys, "Index");
CArrayInit(&kp.Positions, sizeof(Vec2i));
json_t *positions = json_find_first_label(keys, "Positions");
if (!positions || !positions->child)
{
continue;
}
positions = positions->child;
for (positions = positions->child;
positions;
positions = positions->next)
{
Vec2i pos;
json_t *position = positions->child;
pos.x = atoi(position->text);
position = position->next;
pos.y = atoi(position->text);
CArrayPushBack(&kp.Positions, &pos);
}
CArrayPushBack(&m->u.Static.Keys, &kp);
}
}
void AutosaveLoad(Autosave *autosave, const char *filename)
{
FILE *f = fopen(filename, "r");
json_t *root = NULL;
if (f == NULL)
{
printf("Error loading autosave '%s'\n", filename);
goto bail;
}
if (json_stream_parse(f, &root) != JSON_OK)
{
printf("Error parsing autosave '%s'\n", filename);
goto bail;
}
// Note: need to load missions before LastMission because the former
// will overwrite the latter, since AutosaveAddMission also
// writes to LastMission
LoadMissionNodes(autosave, root, "Missions");
if (json_find_first_label(root, "LastMission"))
{
LoadMissionNode(
&autosave->LastMission,
json_find_first_label(root, "LastMission")->child);
}
bail:
json_free_value(&root);
if (f != NULL)
{
fclose(f);
}
}
static void LoadStaticCharacters(Mission *m, json_t *node, char *name)
{
CArrayInit(&m->u.Static.Characters, sizeof(CharacterPositions));
json_t *chars = json_find_first_label(node, name);
if (!chars || !chars->child)
{
return;
}
chars = chars->child;
for (chars = chars->child; chars; chars = chars->next)
{
CharacterPositions cp;
LoadInt(&cp.Index, chars, "Index");
CArrayInit(&cp.Positions, sizeof(Vec2i));
json_t *positions = json_find_first_label(chars, "Positions");
if (!positions || !positions->child)
{
continue;
}
positions = positions->child;
for (positions = positions->child;
positions;
positions = positions->next)
{
Vec2i pos;
json_t *position = positions->child;
pos.x = atoi(position->text);
position = position->next;
pos.y = atoi(position->text);
CArrayPushBack(&cp.Positions, &pos);
}
CArrayPushBack(&m->u.Static.Characters, &cp);
}
}
void BulletLoadJSON(
BulletClasses *bullets, CArray *classes, json_t *bulletNode)
{
int version;
LoadInt(&version, bulletNode, "Version");
if (version > VERSION || version <= 0)
{
CASSERT(false, "cannot read bullets file version");
return;
}
// Defaults
json_t *defaultNode = json_find_first_label(bulletNode, "DefaultBullet");
if (defaultNode != NULL)
{
BulletClassFree(&bullets->Default);
LoadBullet(&bullets->Default, defaultNode->child, NULL);
}
json_t *bulletsNode = json_find_first_label(bulletNode, "Bullets")->child;
for (json_t *child = bulletsNode->child; child; child = child->next)
{
BulletClass b;
LoadBullet(&b, child, &bullets->Default);
CArrayPushBack(classes, &b);
}
bullets->root = bulletNode;
}
static void LoadMissionNode(MissionSave *m, json_t *node)
{
MissionSaveInit(m);
LoadCampaignNode(&m->Campaign, json_find_first_label(node, "Campaign")->child);
strcpy(m->Password, json_find_first_label(node, "Password")->child->text);
LoadInt(&m->MissionsCompleted, node, "MissionsCompleted");
// Check that file exists
m->IsValid = access(m->Campaign.Path, F_OK | R_OK) != -1;
}
static void LoadPlayerTemplate(PlayerTemplate *t, json_t *node)
{
strcpy(t->name, json_find_first_label(node, "Name")->child->text);
t->Looks.face = StrFaceIndex(json_find_first_label(node, "Face")->child->text);
LoadInt(&t->Looks.body, node, "Body");
LoadInt(&t->Looks.arm, node, "Arms");
LoadInt(&t->Looks.leg, node, "Legs");
LoadInt(&t->Looks.skin, node, "Skin");
LoadInt(&t->Looks.hair, node, "Hair");
}
void WeaponLoadJSON(GunClasses *g, CArray *classes, json_t *root)
{
int version;
LoadInt(&version, root, "Version");
if (version > VERSION || version <= 0)
{
CASSERT(false, "cannot read guns file version");
return;
}
GunDescription *defaultDesc = &g->Default;
json_t *defaultNode = json_find_first_label(root, "DefaultGun");
if (defaultNode != NULL)
{
LoadGunDescription(defaultDesc, defaultNode->child, NULL);
for (int i = 0; i < GUN_COUNT; i++)
{
CArrayPushBack(&g->Guns, defaultDesc);
}
}
json_t *gunsNode = json_find_first_label(root, "Guns")->child;
for (json_t *child = gunsNode->child; child; child = child->next)
{
GunDescription gd;
LoadGunDescription(&gd, child, defaultDesc);
int idx = -1;
LoadInt(&idx, child, "Index");
CASSERT(
!(idx >= 0 && idx < GUN_COUNT && classes != &g->Guns),
"Cannot load gun with index as custom gun");
if (idx >= 0 && idx < GUN_COUNT && classes == &g->Guns)
{
memcpy(CArrayGet(&g->Guns, idx), &gd, sizeof gd);
}
else
{
CArrayPushBack(classes, &gd);
}
}
json_t *pseudoGunsNode = json_find_first_label(root, "PseudoGuns");
if (pseudoGunsNode != NULL)
{
for (json_t *child = pseudoGunsNode->child->child;
child;
child = child->next)
{
GunDescription gd;
LoadGunDescription(&gd, child, defaultDesc);
gd.IsRealGun = false;
CArrayPushBack(classes, &gd);
}
}
}
static void LoadMissionNodes(Autosave *a, json_t *root, const char *nodeName)
{
json_t *child;
if (json_find_first_label(root, nodeName) == NULL)
{
return;
}
child = json_find_first_label(root, nodeName)->child->child;
while (child != NULL)
{
MissionSave m;
LoadMissionNode(&m, child);
AutosaveAddMission(a, &m);
child = child->next;
}
}
void MapObjectsLoadJSON(CArray *classes, json_t *root)
{
int version;
LoadInt(&version, root, "Version");
if (version > VERSION || version <= 0)
{
CASSERT(false, "cannot read map objects file version");
return;
}
json_t *pickupsNode = json_find_first_label(root, "MapObjects")->child;
for (json_t *child = pickupsNode->child; child; child = child->next)
{
MapObject m;
LoadMapObject(&m, child);
CArrayPushBack(classes, &m);
}
ReloadDestructibles(&gMapObjects);
// Load blood objects
CArrayClear(&gMapObjects.Bloods);
for (int i = 0;; i++)
{
char buf[CDOGS_FILENAME_MAX];
sprintf(buf, "blood%d", i);
if (StrMapObject(buf) == NULL)
{
break;
}
char *tmp;
CSTRDUP(tmp, buf);
CArrayPushBack(&gMapObjects.Bloods, &tmp);
}
}
static void LoadGameConfigNode(GameConfig *config, json_t *node)
{
if (node == NULL)
{
return;
}
node = node->child;
LoadBool(&config->FriendlyFire, node, "FriendlyFire");
config->RandomSeed = atoi(json_find_first_label(node, "RandomSeed")->child->text);
JSON_UTILS_LOAD_ENUM(config->Difficulty, node, "Difficulty", StrDifficulty);
LoadBool(&config->SlowMotion, node, "SlowMotion");
LoadInt(&config->EnemyDensity, node, "EnemyDensity");
LoadInt(&config->NonPlayerHP, node, "NonPlayerHP");
LoadInt(&config->PlayerHP, node, "PlayerHP");
LoadBool(&config->Fog, node, "Fog");
LoadInt(&config->SightRange, node, "SightRange");
LoadBool(&config->Shadows, node, "Shadows");
LoadBool(&config->MoveWhenShooting, node, "MoveWhenShooting");
JSON_UTILS_LOAD_ENUM(
config->SwitchMoveStyle, node, "SwitchMoveStyle", StrSwitchMoveStyle);
LoadBool(&config->ShotsPushback, node, "ShotsPushback");
JSON_UTILS_LOAD_ENUM(
config->AllyCollision, node, "AllyCollision", StrAllyCollision);
LoadBool(&config->HealthPickups, node, "HealthPickups");
}
bool getFilecacheType_method(LSHandle* lshandle, LSMessage *message, void *ctx) {
LSError lserror;
LSErrorInit(&lserror);
if (access_denied(message)) return true;
char filename[MAXLINLEN];
// Extract the id argument from the message
json_t *object = json_parse_document(LSMessageGetPayload(message));
json_t *type = json_find_first_label(object, "type");
if (!type || (type->child->type != JSON_STRING) || (strspn(type->child->text, ALLOWED_CHARS) != strlen(type->child->text))) {
if (!LSMessageRespond(message,
"{\"returnValue\": false, \"errorCode\": -1, \"errorText\": \"Invalid or missing type\"}",
&lserror)) goto error;
return true;
}
sprintf(filename, "/etc/palm/filecache_types/%s", type->child->text);
return read_file(message, filename, true);
error:
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
end:
return false;
}
int MapNewScanJSON(json_t *root, char **title, int *numMissions)
{
int err = 0;
int version;
LoadInt(&version, root, "Version");
if (version > MAP_VERSION || version <= 0)
{
err = -1;
goto bail;
}
*title = GetString(root, "Title");
*numMissions = 0;
if (version < 3)
{
for (json_t *missionNode =
json_find_first_label(root, "Missions")->child->child;
missionNode;
missionNode = missionNode->next)
{
(*numMissions)++;
}
}
else
{
LoadInt(numMissions, root, "Missions");
}
bail:
return err;
}
static const MapObject *LoadMapObjectRef(json_t *itemNode, const int version)
{
if (version <= 3)
{
int idx;
LoadInt(&idx, itemNode, "Index");
return IntMapObject(idx);
}
else
{
const char *moName =
json_find_first_label(itemNode, "MapObject")->child->text;
const MapObject *mo = StrMapObject(moName);
if (mo == NULL && version <= 11 && StrEndsWith(moName, " spawner"))
{
char buf[256];
// Old version had same name for ammo and gun spawner
char itemName[256];
strncpy(itemName, moName, strlen(moName) - strlen(" spawner"));
itemName[strlen(moName) - strlen(" spawner")] = '\0';
snprintf(buf, 256, "%s ammo spawner", itemName);
mo = StrMapObject(buf);
}
if (mo == NULL)
{
LOG(LM_MAP, LL_ERROR, "Failed to load map object (%s)", moName);
}
return mo;
}
}
void LoadPlayerTemplates(
CArray *templates, const CharacterClasses *classes, const char *filename)
{
// Note: not used, but included in function to express dependency
CASSERT(classes->Classes.size > 0,
"cannot load player templates without character classes");
json_t *root = NULL;
int version = 1;
// initialise templates
CArrayInit(templates, sizeof(PlayerTemplate));
FILE *f = fopen(GetConfigFilePath(filename), "r");
if (!f)
{
printf("Error loading player templates '%s'\n", filename);
goto bail;
}
if (json_stream_parse(f, &root) != JSON_OK)
{
printf("Error parsing player templates '%s'\n", filename);
goto bail;
}
LoadInt(&version, root, "Version");
if (json_find_first_label(root, "PlayerTemplates") == NULL)
{
printf("Error: unknown player templates format\n");
goto bail;
}
json_t *child = json_find_first_label(root, "PlayerTemplates")->child->child;
while (child != NULL)
{
PlayerTemplate t;
LoadPlayerTemplate(&t, child, version);
child = child->next;
CArrayPushBack(templates, &t);
}
bail:
json_free_value(&root);
if (f != NULL)
{
fclose(f);
}
}
void LoadPic(
const Pic **value, json_t *node, const char *name, const char *oldPicName)
{
if (json_find_first_label(node, name))
{
char *tmp = GetString(node, name);
*value = PicManagerGetPic(&gPicManager, tmp);
CFREE(tmp);
}
if ((*value == NULL || ConfigGetBool(&gConfig, "Graphics.OriginalPics")) &&
json_find_first_label(node, oldPicName))
{
int oldPic;
LoadInt(&oldPic, node, oldPicName);
*value = PicManagerGetFromOld(&gPicManager, oldPic);
}
}
void LoadPic(const Pic **value, json_t *node, const char *name)
{
if (json_find_first_label(node, name))
{
char *tmp = GetString(node, name);
*value = PicManagerGetPic(&gPicManager, tmp);
CFREE(tmp);
}
}
static void LoadMapObject(MapObject *m, json_t *node)
{
memset(m, 0, sizeof *m);
m->Idx = -1;
LoadInt(&m->Idx, node, "Index");
m->Name = GetString(node, "Name");
LoadPic(&m->Normal.Pic, node, "Pic", "OldPic");
LoadPic(&m->Wreck.Pic, node, "WreckPic", "OldWreckPic");
if (m->Normal.Pic)
{
// Default offset: centered X, align bottom of tile and sprite
m->Normal.Offset = Vec2iNew(
-m->Normal.Pic->size.x / 2,
TILE_HEIGHT / 2 - m->Normal.Pic->size.y);
LoadVec2i(&m->Normal.Offset, node, "Offset");
}
if (m->Wreck.Pic)
{
m->Wreck.Offset = Vec2iScaleDiv(m->Wreck.Pic->size, -2);
LoadVec2i(&m->Wreck.Offset, node, "WreckOffset");
}
// Default tile size
m->Size = Vec2iNew(TILE_WIDTH, TILE_HEIGHT);
LoadVec2i(&m->Size, node, "Size");
LoadInt(&m->Health, node, "Health");
LoadBulletGuns(&m->DestroyGuns, node, "DestroyGuns");
json_t *flagsNode = json_find_first_label(node, "Flags");
if (flagsNode != NULL && flagsNode->child != NULL)
{
for (json_t *flagNode = flagsNode->child->child;
flagNode;
flagNode = flagNode->next)
{
m->Flags |= 1 << StrPlacementFlag(flagNode->text);
}
}
// Special types
JSON_UTILS_LOAD_ENUM(m->Type, node, "Type", StrMapObjectType);
switch (m->Type)
{
case MAP_OBJECT_TYPE_NORMAL:
// Do nothing
break;
case MAP_OBJECT_TYPE_PICKUP_SPAWNER:
{
char *tmp = GetString(node, "Pickup");
m->u.PickupClass = StrPickupClass(tmp);
CFREE(tmp);
}
break;
default:
CASSERT(false, "unknown error");
break;
}
}
void ScriptDialog::setScript(const QString &filename)
{
json_t *root = BatDownUtils::readJsonFromFile(filename);
json_t *idNode = json_find_first_label(root, "id");
json_t *titleNode = json_find_first_label(root, "title");
json_t *urlNode = json_find_first_label(root, "url");
json_t *stepsNode = json_find_first_label(root, "steps");
json_t *seqNode = json_find_first_label(stepsNode->child, "seq");
m_id = QString(idNode->child->text);
m_title = QString::fromLocal8Bit(titleNode->child->text);
m_url = QString::fromLocal8Bit(urlNode->child->text);
json_t *item = item=seqNode->child->child;
m_stepSeq.clear();
while( item ){
m_stepSeq.append(item->text);
item = item->next;
}
item = seqNode->next;
m_steps.clear();
while( item ){
json_t *testNode = item->child->child;
json_t *scriptNode = testNode->next;
char *t = json_unescape(testNode->child->text);
char *c = json_unescape(scriptNode->child->text);
m_steps.insert( item->text, QString::fromLocal8Bit(c) );
m_stepTests.insert( item->text, QString::fromLocal8Bit(t) );
m_stepFuncs.append(
QString::fromLocal8Bit("Yew.%1=function(){%2};")
.arg(item->text)
.arg( QString::fromLocal8Bit(item->child->text) )
);
item = item->next;
}
json_free_value(&root);
m_pSeqEdit->setText(m_stepSeq.join(","));
m_pStepsEdit->addItems(m_stepSeq);
setWindowTitle(m_title);
}
//
// Return a polite response.
// Called directly from webOS, and returns directly to webOS.
//
bool set_debug_log_method(LSHandle* lshandle, LSMessage *message, void *ctx)
{
log("set_debug_log_method");
LSError lserror;
LSErrorInit(&lserror);
// Extract the id argument from the message
json_t *object = json_parse_document(LSMessageGetPayload(message));
json_t *enableDebugLogging = json_find_first_label(object, "enableDebugLogging");
if(enableDebugLogging)
{
if(enableDebugLogging->child->type == JSON_TRUE)
{
log("enableDebugLogging: JSON_TRUE");
g_debugLoggingEnabled = true;
}
else if(enableDebugLogging->child->type == JSON_FALSE)
{
log("enableDebugLogging: JSON_FALSE");
g_debugLoggingEnabled = false;
remove(LOG_FILE);
}
else
{
log("enableDebugLogging: %d", enableDebugLogging->child->type);
}
}
else
{
if (!LSMessageReply(lshandle, message, "{\"returnValue\": false, \"errorCode\": -1, \"errorText\": \"Invalid or missing parameters\"}", &lserror))
{
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
return false;
}
}
// Local buffer to store the reply
char reply[MAXLINLEN];
sprintf(reply, "{\"returnValue\": true, \"debugLoggingEnabled\": %s}", g_debugLoggingEnabled ? "true" : "false");
log(reply);
if (!LSMessageReply(lshandle, message, reply, &lserror))
{
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
return false;
}
return true;
}
static void LoadStaticExit(Mission *m, json_t *node, char *name)
{
json_t *exitNode = json_find_first_label(node, name);
if (!exitNode || !exitNode->child)
{
return;
}
exitNode = exitNode->child;
LoadVec2i(&m->u.Static.Exit.Start, exitNode, "Start");
LoadVec2i(&m->u.Static.Exit.End, exitNode, "End");
}
static void LoadClassicPillars(Mission *m, json_t *node, char *name)
{
json_t *child = json_find_first_label(node, name);
if (!child || !child->child)
{
return;
}
child = child->child;
LoadInt(&m->u.Classic.Pillars.Count, child, "Count");
LoadInt(&m->u.Classic.Pillars.Min, child, "Min");
LoadInt(&m->u.Classic.Pillars.Max, child, "Max");
}
void LoadColor(color_t *c, json_t *node, const char *name)
{
if (json_find_first_label(node, name) == NULL)
{
return;
}
if (!TryLoadValue(&node, name))
{
return;
}
*c = StrColor(node->text);
}
static void LoadClassicDoors(Mission *m, json_t *node, char *name)
{
json_t *child = json_find_first_label(node, name);
if (!child || !child->child)
{
return;
}
child = child->child;
LoadBool(&m->u.Classic.Doors.Enabled, child, "Enabled");
LoadInt(&m->u.Classic.Doors.Min, child, "Min");
LoadInt(&m->u.Classic.Doors.Max, child, "Max");
}
void LoadSoundFromNode(Mix_Chunk **value, json_t *node, const char *name)
{
if (json_find_first_label(node, name) == NULL)
{
return;
}
if (!TryLoadValue(&node, name))
{
return;
}
*value = StrSound(node->text);
}
void ConfigLoadJSON(Config *config, const char *filename)
{
FILE *f = fopen(filename, "r");
json_t *root = NULL;
int version;
if (f == NULL)
{
printf("Error loading config '%s'\n", filename);
goto bail;
}
if (json_stream_parse(f, &root) != JSON_OK)
{
printf("Error parsing config '%s'\n", filename);
goto bail;
}
LoadInt(&version, root, "Version");
LoadGameConfigNode(&config->Game, json_find_first_label(root, "Game"));
LoadGraphicsConfigNode(&config->Graphics, json_find_first_label(root, "Graphics"));
LoadInputConfigNode(&config->Input, json_find_first_label(root, "Input"));
LoadInterfaceConfigNode(
&config->Interface,
json_find_first_label(root, "Interface"),
version);
LoadSoundConfigNode(&config->Sound, json_find_first_label(root, "Sound"));
LoadQuickPlayConfigNode(&config->QuickPlay, json_find_first_label(root, "QuickPlay"));
bail:
json_free_value(&root);
if (f != NULL)
{
fclose(f);
}
}
void LoadPlayerTemplates(CArray *templates, const char *filename)
{
json_t *root = NULL;
// initialise templates
CArrayInit(templates, sizeof(PlayerTemplate));
FILE *f = fopen(GetConfigFilePath(filename), "r");
if (!f)
{
printf("Error loading player templates '%s'\n", filename);
goto bail;
}
if (json_stream_parse(f, &root) != JSON_OK)
{
printf("Error parsing player templates '%s'\n", filename);
goto bail;
}
if (json_find_first_label(root, "PlayerTemplates") == NULL)
{
printf("Error: unknown player templates format\n");
goto bail;
}
json_t *child = json_find_first_label(root, "PlayerTemplates")->child->child;
while (child != NULL)
{
PlayerTemplate t;
LoadPlayerTemplate(&t, child);
child = child->next;
CArrayPushBack(templates, &t);
}
bail:
json_free_value(&root);
if (f != NULL)
{
fclose(f);
}
}
static void LoadQuickPlayConfigNode(QuickPlayConfig *config, json_t *node)
{
if (node == NULL)
{
return;
}
node = node->child;
config->MapSize = StrQuickPlayQuantity(json_find_first_label(node, "MapSize")->child->text);
config->WallCount = StrQuickPlayQuantity(json_find_first_label(node, "WallCount")->child->text);
config->WallLength = StrQuickPlayQuantity(json_find_first_label(node, "WallLength")->child->text);
config->RoomCount = StrQuickPlayQuantity(json_find_first_label(node, "RoomCount")->child->text);
config->SquareCount = StrQuickPlayQuantity(json_find_first_label(node, "SquareCount")->child->text);
config->EnemyCount = StrQuickPlayQuantity(json_find_first_label(node, "EnemyCount")->child->text);
config->EnemySpeed = StrQuickPlayQuantity(json_find_first_label(node, "EnemySpeed")->child->text);
config->EnemyHealth = StrQuickPlayQuantity(json_find_first_label(node, "EnemyHealth")->child->text);
LoadBool(&config->EnemiesWithExplosives, node, "EnemiesWithExplosives");
config->ItemCount = StrQuickPlayQuantity(json_find_first_label(node, "ItemCount")->child->text);
}
static void LoadStaticItems(
Mission *m, json_t *node, const char *name, const int version)
{
json_t *items = json_find_first_label(node, name);
if (!items || !items->child)
{
return;
}
items = items->child;
for (items = items->child; items; items = items->next)
{
MapObjectPositions mop;
mop.M = LoadMapObjectRef(items, version);
if (mop.M == NULL)
{
continue;
}
CArrayInit(&mop.Positions, sizeof(Vec2i));
json_t *positions = json_find_first_label(items, "Positions");
if (!positions || !positions->child)
{
continue;
}
positions = positions->child;
for (positions = positions->child;
positions;
positions = positions->next)
{
Vec2i pos;
json_t *position = positions->child;
pos.x = atoi(position->text);
position = position->next;
pos.y = atoi(position->text);
CArrayPushBack(&mop.Positions, &pos);
}
CArrayPushBack(&m->u.Static.Items, &mop);
}
}
void LoadBulletGuns(CArray *guns, json_t *node, const char *name)
{
node = json_find_first_label(node, name);
if (node == NULL || node->child == NULL)
{
return;
}
CArrayInit(guns, sizeof(const GunDescription *));
for (json_t *gun = node->child->child; gun; gun = gun->next)
{
const GunDescription *g = StrGunDescription(gun->text);
CArrayPushBack(guns, &g);
}
}
