void wxArchive::SkipData(wxUint8 hdr)
{
switch(hdr)
{
case wxARCHIVE_HDR_BOOL:
LoadBool();
break;
case wxARCHIVE_HDR_INT8:
LoadChar();
break;
case wxARCHIVE_HDR_INT16:
LoadUint16();
break;
case wxARCHIVE_HDR_INT32:
LoadUint32();
break;
case wxARCHIVE_HDR_INT64:
LoadUint64();
break;
case wxARCHIVE_HDR_DOUBLE:
LoadDouble();
break;
case wxARCHIVE_HDR_STRING:
LoadString();
break;
case wxARCHIVE_HDR_ARRSTRING:
LoadArrayString();
break;
case wxARCHIVE_HDR_RECORD:
{
wxCharBuffer buf;
Load(buf);
}
break;
case wxARCHIVE_HDR_INT:
LoadInt();
break;
case wxARCHIVE_HDR_ENTER:
break;
case wxARCHIVE_HDR_LEAVE:
break;
default:
LogError(wxARCHIVE_ERR_ILL, wxARCHIVE_ERR_STR_ILL_UNKNOWN_HDR_s1, GetHeaderName(hdr));
break;
}
}
bool wxArchive::ReadDouble(double& value)
{
// load double value
if(LoadChunkHeader(wxARCHIVE_HDR_DOUBLE))
{
double tmpvalue = LoadDouble();
// when all is ok, assign
if(IsOk())
{
value = tmpvalue;
return true;
}
}
return false;
}
static void ConfigLoadVisit(Config *c, json_t *node)
{
if (node == NULL)
{
fprintf(stderr, "Error loading config: node %s not found\n",
c->Name);
return;
}
switch (c->Type)
{
case CONFIG_TYPE_STRING:
CASSERT(false, "not implemented");
break;
case CONFIG_TYPE_INT:
LoadInt(&c->u.Int.Value, node, c->Name);
if (c->u.Int.Min > 0)
c->u.Int.Value = MAX(c->u.Int.Value, c->u.Int.Min);
if (c->u.Int.Max > 0)
c->u.Int.Value = MIN(c->u.Int.Value, c->u.Int.Max);
break;
case CONFIG_TYPE_FLOAT:
LoadDouble(&c->u.Float.Value, node, c->Name);
if (c->u.Float.Min > 0)
c->u.Float.Value = MAX(c->u.Float.Value, c->u.Float.Min);
if (c->u.Float.Max > 0)
c->u.Float.Value = MIN(c->u.Float.Value, c->u.Float.Max);
break;
case CONFIG_TYPE_BOOL:
LoadBool(&c->u.Bool.Value, node, c->Name);
break;
case CONFIG_TYPE_ENUM:
JSON_UTILS_LOAD_ENUM(
c->u.Enum.Value, node, c->Name, c->u.Enum.StrToEnum);
if (c->u.Enum.Min > 0)
c->u.Enum.Value = MAX(c->u.Enum.Value, c->u.Enum.Min);
if (c->u.Enum.Max > 0)
c->u.Enum.Value = MIN(c->u.Enum.Value, c->u.Enum.Max);
break;
case CONFIG_TYPE_GROUP:
{
// If the config has no name, then it is the root element
// Load children directly to the node
// Otherwise, find the named child
if (c->Name != NULL)
{
node = json_find_first_label(node, c->Name);
if (node == NULL)
{
fprintf(stderr, "Error loading config: node %s not found\n",
c->Name);
return;
}
node = node->child;
}
CA_FOREACH(Config, child, c->u.Group)
ConfigLoadVisit(child, node);
CA_FOREACH_END()
}
break;
default:
CASSERT(false, "Unknown config type");
break;
}
}
void LoadMacfloat( Obj obj )
{
SET_VAL_MACFLOAT(obj, LoadDouble());
}
static bool TryLoadMapObject(MapObject *m, json_t *node, const int version)
{
memset(m, 0, sizeof *m);
m->Name = GetString(node, "Name");
// Pic
json_t *normalNode = json_find_first_label(node, "Pic");
if (normalNode != NULL && normalNode->child != NULL)
{
if (version < 2)
{
CPicLoadNormal(&m->Pic, normalNode->child);
}
else
{
CPicLoadJSON(&m->Pic, normalNode->child);
}
// Pic required for map object
if (!CPicIsLoaded(&m->Pic))
{
LOG(LM_MAIN, LL_ERROR, "pic not found for map object(%s)", m->Name);
goto bail;
}
}
if (CPicIsLoaded(&m->Pic))
{
// Default offset: centered X, align bottom of tile and sprite
const Vec2i size = CPicGetSize(&m->Pic);
m->Offset = Vec2iNew(-size.x / 2, TILE_HEIGHT / 2 - size.y);
LoadVec2i(&m->Offset, node, "Offset");
}
// Wreck
if (version < 3)
{
// Assume old wreck pic is wreck
json_t *wreckNode = json_find_first_label(node, "WreckPic");
if (wreckNode != NULL && wreckNode->child != NULL)
{
if (version < 2)
{
LoadStr(&m->Wreck, node, "WreckPic");
}
else
{
LoadStr(&m->Wreck, wreckNode, "Pic");
}
}
}
else
{
LoadStr(&m->Wreck, node, "Wreck");
}
// Default tile size
m->Size = TILE_SIZE;
LoadVec2i(&m->Size, node, "Size");
LoadVec2i(&m->PosOffset, node, "PosOffset");
LoadInt(&m->Health, node, "Health");
LoadBulletGuns(&m->DestroyGuns, node, "DestroyGuns");
// Flags
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);
}
}
LoadBool(&m->DrawLast, node, "DrawLast");
// 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;
}
// DestroySpawn - pickups to spawn on destruction
json_t *destroySpawnNode = json_find_first_label(node, "DestroySpawn");
if (destroySpawnNode != NULL && destroySpawnNode->child != NULL)
{
CArrayInit(&m->DestroySpawn, sizeof(MapObjectDestroySpawn));
for (json_t *dsNode = destroySpawnNode->child->child;
dsNode;
dsNode = dsNode->next)
{
MapObjectDestroySpawn mods;
memset(&mods, 0, sizeof mods);
JSON_UTILS_LOAD_ENUM(mods.Type, dsNode, "Type", StrPickupType);
LoadDouble(&mods.SpawnChance, dsNode, "SpawnChance");
CArrayPushBack(&m->DestroySpawn, &mods);
}
}
return true;
bail:
return false;
}
static void LoadGunDescription(
GunDescription *g, json_t *node, const GunDescription *defaultGun)
{
memset(g, 0, sizeof *g);
g->AmmoId = -1;
if (defaultGun)
{
memcpy(g, defaultGun, sizeof *g);
if (defaultGun->name)
{
CSTRDUP(g->name, defaultGun->name);
}
if (defaultGun->Description)
{
CSTRDUP(g->Description, defaultGun->Description);
}
g->MuzzleHeight /= Z_FACTOR;
}
char *tmp;
if (json_find_first_label(node, "Pic"))
{
tmp = GetString(node, "Pic");
if (strcmp(tmp, "blaster") == 0)
{
g->pic = GUNPIC_BLASTER;
}
else if (strcmp(tmp, "knife") == 0)
{
g->pic = GUNPIC_KNIFE;
}
else
{
g->pic = -1;
}
CFREE(tmp);
}
if (json_find_first_label(node, "Icon"))
{
tmp = GetString(node, "Icon");
g->Icon = PicManagerGet(&gPicManager, tmp, -1);
CFREE(tmp);
}
g->name = GetString(node, "Name");
if (json_find_first_label(node, "Description"))
{
g->Description = GetString(node, "Description");
}
if (json_find_first_label(node, "Bullet"))
{
tmp = GetString(node, "Bullet");
g->Bullet = StrBulletClass(tmp);
CFREE(tmp);
}
if (json_find_first_label(node, "Ammo"))
{
tmp = GetString(node, "Ammo");
g->AmmoId = StrAmmoId(tmp);
CFREE(tmp);
}
LoadInt(&g->Cost, node, "Cost");
LoadInt(&g->Lock, node, "Lock");
LoadInt(&g->ReloadLead, node, "ReloadLead");
LoadSoundFromNode(&g->Sound, node, "Sound");
LoadSoundFromNode(&g->ReloadSound, node, "ReloadSound");
LoadSoundFromNode(&g->SwitchSound, node, "SwitchSound");
LoadInt(&g->SoundLockLength, node, "SoundLockLength");
LoadDouble(&g->Recoil, node, "Recoil");
LoadInt(&g->Spread.Count, node, "SpreadCount");
LoadDouble(&g->Spread.Width, node, "SpreadWidth");
LoadDouble(&g->AngleOffset, node, "AngleOffset");
LoadInt(&g->MuzzleHeight, node, "MuzzleHeight");
g->MuzzleHeight *= Z_FACTOR;
if (json_find_first_label(node, "Elevation"))
{
LoadInt(&g->ElevationLow, node, "Elevation");
g->ElevationHigh = g->ElevationLow;
}
LoadInt(&g->ElevationLow, node, "ElevationLow");
LoadInt(&g->ElevationHigh, node, "ElevationHigh");
g->ElevationLow = MIN(g->ElevationLow, g->ElevationHigh);
g->ElevationHigh = MAX(g->ElevationLow, g->ElevationHigh);
if (json_find_first_label(node, "MuzzleFlashParticle"))
{
tmp = GetString(node, "MuzzleFlashParticle");
g->MuzzleFlash = StrParticleClass(&gParticleClasses, tmp);
CFREE(tmp);
}
if (json_find_first_label(node, "Brass"))
{
tmp = GetString(node, "Brass");
g->Brass = StrParticleClass(&gParticleClasses, tmp);
CFREE(tmp);
}
LoadBool(&g->CanShoot, node, "CanShoot");
LoadInt(&g->ShakeAmount, node, "ShakeAmount");
g->IsRealGun = true;
}
