bool ESceneLightTools::Load(IReader& F)
{
u16 version = 0;
if(F.r_chunk(CHUNK_VERSION,&version))
if( version!=LIGHT_TOOLS_VERSION ){
ELog.DlgMsg( mtError, "%s tools: Unsupported version.",ClassDesc());
return false;
}
if (!inherited::Load(F)) return false;
if (F.find_chunk(CHUNK_FLAGS))
m_Flags.assign (F.r_u32());
if (F.find_chunk(CHUNK_SUN_SHADOW)){
F.r_u8 ();
F.r_fvector2 (m_SunShadowDir);
}
if (F.find_chunk(CHUNK_LCONTROLS_LAST))
lcontrol_last_idx = F.r_u32();
IReader* R = F.open_chunk(CHUNK_LCONTROLS);
if (R){
while (!R->eof()){
shared_str l_name;
R->r_stringZ(l_name);
u32 l_idx = R->r_u32();
AppendLightControl(l_name.c_str(),&l_idx);
}
R->close ();
}
return true;
}
bool EDetail::Load(IReader& F)
{
// check version
R_ASSERT (F.find_chunk(DETOBJ_CHUNK_VERSION));
u32 version = F.r_u32();
if (version!=DETOBJ_VERSION){
ELog.Msg(mtError,"EDetail: unsupported version.");
return false;
}
// references
string256 buf;
R_ASSERT (F.find_chunk(DETOBJ_CHUNK_REFERENCE));
F.r_stringZ (buf,sizeof(buf));
// scale
R_ASSERT (F.find_chunk(DETOBJ_CHUNK_SCALE_LIMITS));
m_fMinScale = F.r_float(); if (fis_zero(m_fMinScale)) m_fMinScale = 0.1f;
m_fMaxScale = F.r_float(); if (m_fMaxScale<m_fMinScale) m_fMaxScale = m_fMinScale;
// density factor
if (F.find_chunk(DETOBJ_CHUNK_DENSITY_FACTOR))
m_fDensityFactor= F.r_float();
if (F.find_chunk(DETOBJ_CHUNK_FLAGS))
m_Flags.assign (F.r_u32());
// update object
return Update(buf);
}
bool ESceneObjectTools::Load(IReader& F)
{
u16 version = 0;
if(F.r_chunk(CHUNK_VERSION,&version)){
if( version!=OBJECT_TOOLS_VERSION ){
ELog.DlgMsg( mtError, "%s tools: Unsupported version.",ClassDesc());
return false;
}
}
if (!inherited::Load(F)) return false;
if (F.find_chunk(CHUNK_FLAGS))
m_Flags.assign(F.r_u32());
if (F.find_chunk(CHUNK_APPEND_RANDOM)){
F.r_fvector3(m_AppendRandomMinScale);
F.r_fvector3(m_AppendRandomMaxScale);
F.r_fvector3(m_AppendRandomMinRotation);
F.r_fvector3(m_AppendRandomMaxRotation);
int cnt = F.r_u32();
if (cnt){
shared_str buf;
for (int i=0; i<cnt; i++){
F.r_stringZ (buf);
m_AppendRandomObjects.push_back (buf);
}
}
};
m_Flags.set(flAppendRandom,FALSE);
return true;
}
void SGameMtl::Load(IReader& fs)
{
R_ASSERT(fs.find_chunk(GAMEMTL_CHUNK_MAIN));
ID = fs.r_u32();
fs.r_stringZ (m_Name);
if (fs.find_chunk(GAMEMTL_CHUNK_DESC)){
fs.r_stringZ (m_Desc);
}
R_ASSERT(fs.find_chunk(GAMEMTL_CHUNK_FLAGS));
Flags.assign (fs.r_u32());
R_ASSERT(fs.find_chunk(GAMEMTL_CHUNK_PHYSICS));
fPHFriction = fs.r_float();
fPHDamping = fs.r_float();
fPHSpring = fs.r_float();
fPHBounceStartVelocity = fs.r_float();
fPHBouncing = fs.r_float();
R_ASSERT(fs.find_chunk(GAMEMTL_CHUNK_FACTORS));
fShootFactor = fs.r_float();
fBounceDamageFactor = fs.r_float();
fVisTransparencyFactor = fs.r_float();
fSndOcclusionFactor = fs.r_float();
if(fs.find_chunk(GAMEMTL_CHUNK_FLOTATION))
fFlotationFactor = fs.r_float();
if(fs.find_chunk(GAMEMTL_CHUNK_INJURIOUS))
fInjuriousSpeed = fs.r_float();
}
void CBone::LoadData(IReader& F)
{
R_ASSERT(F.find_chunk(BONE_CHUNK_DEF));
F.r_stringZ (name); xr_strlwr(name);
R_ASSERT(F.find_chunk(BONE_CHUNK_MATERIAL));
F.r_stringZ (game_mtl);
R_ASSERT(F.find_chunk(BONE_CHUNK_SHAPE));
F.r (&shape,sizeof(SBoneShape));
if (F.find_chunk(BONE_CHUNK_FLAGS))
IK_data.ik_flags.assign(F.r_u32());
R_ASSERT(F.find_chunk(BONE_CHUNK_IK_JOINT));
IK_data.type = (EJointType)F.r_u32();
F.r (IK_data.limits,sizeof(SJointLimit)*3);
IK_data.spring_factor = F.r_float();
IK_data.damping_factor = F.r_float();
if (F.find_chunk(BONE_CHUNK_IK_JOINT_BREAK)){
IK_data.break_force = F.r_float();
IK_data.break_torque= F.r_float();
}
if (F.find_chunk(BONE_CHUNK_IK_JOINT_FRICTION)){
IK_data.friction = F.r_float();
}
if (F.find_chunk(BONE_CHUNK_MASS)){
mass = F.r_float();
F.r_fvector3(center_of_mass);
}
}
bool CCustomMotion::Load(IReader& F)
{
F.r_stringZ (name);
iFrameStart = F.r_u32();
iFrameEnd = F.r_u32();
fFPS = F.r_float();
return true;
}
void CALifeSpawnHeader::load (IReader &file_stream)
{
m_version = file_stream.r_u32();
R_ASSERT2 (XRAI_CURRENT_VERSION == m_version,"'game.spawn' version mismatch!");
file_stream.r (&m_guid,sizeof(m_guid));
file_stream.r (&m_graph_guid,sizeof(m_graph_guid));
m_count = file_stream.r_u32();
m_level_count = file_stream.r_u32();
}
bool ESceneAIMapTool::LoadStream(IReader& F)
{
inherited::LoadStream (F);
u16 version = 0;
R_ASSERT(F.r_chunk(AIMAP_CHUNK_VERSION,&version));
if( version!=AIMAP_VERSION ){
ELog.DlgMsg( mtError, "AIMap: Unsupported version.");
return false;
}
R_ASSERT(F.find_chunk(AIMAP_CHUNK_FLAGS));
F.r (&m_Flags,sizeof(m_Flags));
R_ASSERT(F.find_chunk(AIMAP_CHUNK_BOX));
F.r (&m_AIBBox,sizeof(m_AIBBox));
R_ASSERT(F.find_chunk(AIMAP_CHUNK_PARAMS));
F.r (&m_Params,sizeof(m_Params));
R_ASSERT(F.find_chunk(AIMAP_CHUNK_NODES));
m_Nodes.resize (F.r_u32());
for (AINodeIt it=m_Nodes.begin(); it!=m_Nodes.end(); it++){
*it = xr_new<SAINode>();
(*it)->LoadStream (F,this);
}
DenumerateNodes ();
if (F.find_chunk(AIMAP_CHUNK_INTERNAL_DATA)){
m_VisRadius = F.r_float();
m_BrushSize = F.r_u32();
}
if (F.find_chunk(AIMAP_CHUNK_INTERNAL_DATA2)){
m_SmoothHeight = F.r_float();
}
// snap objects
if (F.find_chunk(AIMAP_CHUNK_SNAP_OBJECTS)){
shared_str buf;
int cnt = F.r_u32();
if (cnt){
for (int i=0; i<cnt; i++){
F.r_stringZ (buf);
CCustomObject* O = Scene->FindObjectByName(buf.c_str(),OBJCLASS_SCENEOBJECT);
if (!O) ELog.Msg(mtError,"AIMap: Can't find snap object '%s'.",buf.c_str());
else m_SnapObjects.push_back(O);
}
}
}
hash_FillFromNodes ();
return true;
}
//------------------------------------------------------------------------------
// I/O part
//------------------------------------------------------------------------------
BOOL CPGDef::Load(IReader& F)
{
R_ASSERT (F.find_chunk(PGD_CHUNK_VERSION));
u16 version = F.r_u16();
if (version!=PGD_VERSION){
Log ("!Unsupported PG version. Load failed.");
return FALSE;
}
R_ASSERT (F.find_chunk(PGD_CHUNK_NAME));
F.r_stringZ (m_Name);
F.r_chunk (PGD_CHUNK_FLAGS,&m_Flags);
if (F.find_chunk(PGD_CHUNK_EFFECTS)){
m_Effects.resize(F.r_u32());
for (EffectIt it=m_Effects.begin(); it!=m_Effects.end(); it++){
*it = xr_new<SEffect>();
F.r_stringZ ((*it)->m_EffectName);
F.r_stringZ ((*it)->m_OnPlayChildName);
F.r_stringZ ((*it)->m_OnBirthChildName);
F.r_stringZ ((*it)->m_OnDeadChildName);
(*it)->m_Time0 = F.r_float();
(*it)->m_Time1 = F.r_float();
(*it)->m_Flags.assign (F.r_u32());
}
}else{ //.??? убрать через некоторое время
R_ASSERT (F.find_chunk(PGD_CHUNK_EFFECTS2));
m_Effects.resize(F.r_u32());
for (EffectIt it=m_Effects.begin(); it!=m_Effects.end(); it++){
*it = xr_new<SEffect>();
F.r_stringZ ((*it)->m_EffectName);
F.r_stringZ ((*it)->m_OnPlayChildName);
(*it)->m_Time0 = F.r_float();
(*it)->m_Time1 = F.r_float();
(*it)->m_Flags.assign (F.r_u32());
}
}
if (F.find_chunk(PGD_CHUNK_TIME_LIMIT)){
m_fTimeLimit= F.r_float();
}
#ifdef _EDITOR
if (F.find_chunk(PGD_CHUNK_OWNER)){
F.r_stringZ (m_OwnerName);
F.r_stringZ (m_ModifName);
F.r (&m_CreateTime,sizeof(m_CreateTime));
F.r (&m_ModifTime,sizeof(m_ModifTime));
}
#endif
return TRUE;
}
bool CEditableObject::LoadBoneData(IReader& F)
{
BoneVec load_bones;
int count=0;
IReader* R;
while(0!=(R=F.open_chunk(count++)))
{
CBone* nBone = xr_new<CBone>();
load_bones.push_back(nBone);
nBone->LoadData(*R);
Msg("loaded bone [%s]", nBone->Name().c_str());
}
bool bRes = true;
// load bones
if (!load_bones.empty()){
for (BoneIt b_it=m_Bones.begin(); b_it!=m_Bones.end(); b_it++){
CBone* B = *b_it;
BoneIt n_it = std::find_if(load_bones.begin(),load_bones.end(),fBoneNameEQ(B->Name()));
if (n_it!=load_bones.end())
{
B->CopyData (*n_it);
}else{
ELog.Msg (mtError,"Can't find bone: '%s'.",*(*b_it)->Name());
bRes = false;
// break;
}
}
for (BoneIt n_it=load_bones.begin(); n_it!=load_bones.end(); n_it++)
xr_delete(*n_it);
load_bones.clear();
}else{
ELog.Msg (mtError,"Empty bone list.");
bRes = false;
}
// load bone part
if (F.find_chunk(EOBJ_CHUNK_BONEPARTS2)){
shared_str buf;
m_BoneParts.resize(F.r_u32());
for (BPIt bp_it=m_BoneParts.begin(); bp_it!=m_BoneParts.end(); bp_it++){
F.r_stringZ (buf); bp_it->alias=buf;
bp_it->bones.resize (F.r_u32());
for (RStringVecIt s_it=bp_it->bones.begin(); s_it!=bp_it->bones.end(); s_it++)
F.r_stringZ (*s_it);
}
if (!m_BoneParts.empty()&&!VerifyBoneParts())
ELog.Msg (mtError,"Invalid bone parts. Found missing or duplicate bone.");
}else{
ELog.Msg (mtError,"Can't load bone parts. Invalid version.");
}
return bRes;
}
void st_LevelOptions::Read(IReader& F)
{
R_ASSERT(F.find_chunk(CHUNK_LO_VERSION));
DWORD vers = F.r_u32( );
if( vers < 0x00000008 )
{
ELog.DlgMsg( mtError, "Skipping bad version of level options." );
return;
}
R_ASSERT(F.find_chunk(CHUNK_LO_NAMES));
F.r_stringZ (m_FNLevelPath);
if (F.find_chunk(CHUNK_LO_PREFIX)) F.r_stringZ (m_LevelPrefix);
R_ASSERT(F.find_chunk(CHUNK_LO_BOP));
F.r_stringZ (m_BOPText);
if (F.find_chunk(CHUNK_LO_MAP_VER))
F.r_stringZ (m_map_version);
vers = 0;
if (F.find_chunk(CHUNK_LO_BP_VERSION))
vers = F.r_u32( );
if (CURRENT_LEVELOP_BP_VERSION==vers){
if (F.find_chunk(CHUNK_BUILD_PARAMS))
F.r(&m_BuildParams, sizeof(m_BuildParams));
}else{
ELog.DlgMsg (mtError, "Skipping bad version of build params.");
m_BuildParams.Init();
}
if (F.find_chunk(CHUNK_LIGHT_QUALITY))
{
m_LightHemiQuality = F.r_u8();
m_LightSunQuality = F.r_u8();
}
if (F.find_chunk(CHUNK_MAP_USAGE))
{
if(vers > 0x00000008)
{
m_mapUsage.m_GameType.assign (F.r_u16());
}else
{
m_mapUsage.m_GameType.zero ();
m_mapUsage.m_GameType.set (eGameIDDeathmatch , F.r_s32());
m_mapUsage.m_GameType.set (eGameIDTeamDeathmatch, F.r_s32());
m_mapUsage.m_GameType.set (eGameIDArtefactHunt, F.r_s32());
}
}
}
bool CSavedGameWrapper::valid_saved_game (IReader &stream)
{
if (stream.length() < 8)
return (false);
if (stream.r_u32() != u32(-1))
return (false);
if (stream.r_u32() < 0x0002)
return (false);
return (true);
}
void CLAItem::Load(IReader& F)
{
R_ASSERT(F.find_chunk(CHUNK_ITEM_COMMON));
F.r_stringZ (cName);
fFPS = F.r_float();
iFrameCount = F.r_u32();
int key_cnt,key;
R_ASSERT(F.find_chunk(CHUNK_ITEM_KEYS));
key_cnt = F.r_u32();
for (int i=0; i<key_cnt; i++){
key = F.r_u32 ();
Keys[key] = F.r_u32();
}
}
u32 CParticleManager::LoadActions(int alist_id, IReader& R)
{
// Execute the specified action list.
ParticleActions* pa = GetActionListPtr(alist_id);
pa->clear ();
if (R.length()){
u32 cnt = R.r_u32();
for (u32 k=0; k<cnt; k++){
ParticleAction* act = CreateAction ((PActionEnum)R.r_u32());
act->Load (R);
pa->append (act);
}
}
return pa->size();
}
bool CALifeStorageManager::load (LPCSTR save_name_no_check)
{
LPCSTR game_saves_path = FS.get_path("$game_saves$")->m_Path;
string_path save_name;
strncpy_s (save_name, sizeof(save_name), save_name_no_check, sizeof(save_name)-5-xr_strlen(SAVE_EXTENSION)-xr_strlen(game_saves_path));
CTimer timer;
timer.Start ();
string_path save;
xr_strcpy (save,m_save_name);
if (!save_name) {
if (!xr_strlen(m_save_name))
R_ASSERT2 (false,"There is no file name specified!");
}
else
{
strconcat (sizeof(m_save_name), m_save_name, save_name, SAVE_EXTENSION);
}
string_path file_name;
FS.update_path (file_name,"$game_saves$",m_save_name);
xr_strcpy (g_last_saved_game, save_name);
xr_strcpy (g_bug_report_file, file_name);
IReader *stream;
stream = FS.r_open(file_name);
if (!stream) {
Msg ("* Cannot find saved game %s",file_name);
xr_strcpy (m_save_name,save);
return (false);
}
CHECK_OR_EXIT (CSavedGameWrapper::valid_saved_game(*stream),make_string("%s\nSaved game version mismatch or saved game is corrupted",file_name));
/*
string512 temp;
strconcat (sizeof(temp),temp,CStringTable().translate("st_loading_saved_game").c_str()," \"",save_name,SAVE_EXTENSION,"\"");
g_pGamePersistent->LoadTitle(temp);
*/
g_pGamePersistent->LoadTitle();
unload ();
reload (m_section);
u32 source_count = stream->r_u32();
void *source_data = xr_malloc(source_count);
rtc_decompress (source_data,source_count,stream->pointer(),stream->length() - 3*sizeof(u32));
FS.r_close (stream);
load (source_data, source_count, file_name);
xr_free (source_data);
groups().on_after_game_load ();
VERIFY (graph().actor());
Msg ("* Game %s is successfully loaded from file '%s' (%.3fs)",save_name, file_name,timer.GetElapsed_sec());
return (true);
}
void CEnvironment::mods_load()
{
Modifiers.clear_and_free();
string_path path;
if (FS.exist(path, "$level$", "level.env_mod"))
{
IReader* fs = FS.r_open(path);
u32 id = 0;
u32 ver = 0x0015;
u32 sz;
while (0 != (sz = fs->find_chunk(id)))
{
if (id == 0 && sz == sizeof(u32))
{
ver = fs->r_u32();
}
else
{
CEnvModifier E;
E.load(fs, ver);
Modifiers.push_back(E);
}
id++;
}
FS.r_close(fs);
}
load_level_specific_ambients();
}
bool CGroupObject::Load(IReader& F)
{
u32 version = 0;
char buf[1024];
R_ASSERT(F.r_chunk(GROUPOBJ_CHUNK_VERSION,&version));
if (version!=GROUPOBJ_CURRENT_VERSION){
ELog.DlgMsg( mtError, "CGroupObject: unsupported file version. Object can't load.");
return false;
}
CCustomObject::Load(F);
F.r_chunk(GROUPOBJ_CHUNK_FLAGS,&m_Flags);
// objects
if (IsOpened()){
m_PObjects = xr_new<SStringVec>();
R_ASSERT(F.find_chunk(GROUPOBJ_CHUNK_OPEN_OBJECT_LIST));
u32 cnt = F.r_u32();
xr_string tmp;
for (u32 k=0; k<cnt; k++){
F.r_stringZ (tmp);
m_PObjects->push_back (tmp);
}
}else{
Scene->ReadObjects(F,GROUPOBJ_CHUNK_OBJECT_LIST,AppendObjectCB,0);
}
VERIFY(m_Objects.size()||(0!=m_PObjects));
if (F.find_chunk(GROUPOBJ_CHUNK_REFERENCE))
F.r_stringZ (m_ReferenceName);
return true;
}
void CObjectAnimator::LoadMotions(LPCSTR fname)
{
string_path full_path;
if (!FS.exist( full_path, "$level$", fname ))
if (!FS.exist( full_path, "$game_anims$", fname ))
Debug.fatal(DEBUG_INFO,"Can't find motion file '%s'.",fname);
LPCSTR ext = strext(full_path);
if (ext){
Clear ();
if (0==xr_strcmp(ext,".anm")){
COMotion* M = xr_new<COMotion> ();
if (M->LoadMotion(full_path)) m_Motions.push_back(M);
else FATAL("ERROR: Can't load motion. Incorrect file version.");
}else if (0==xr_strcmp(ext,".anms")){
IReader* F = FS.r_open(full_path);
u32 dwMCnt = F->r_u32(); VERIFY(dwMCnt);
for (u32 i=0; i<dwMCnt; i++){
COMotion* M = xr_new<COMotion> ();
bool bRes = M->Load(*F);
if (!bRes) FATAL("ERROR: Can't load motion. Incorrect file version.");
m_Motions.push_back(M);
}
FS.r_close (F);
}
std::sort(m_Motions.begin(),m_Motions.end(),motion_sort_pred);
}
}
void CALifeSimulatorHeader::load (IReader &file_stream)
{
R_ASSERT2 (file_stream.find_chunk(ALIFE_CHUNK_DATA),"Can't find chunk ALIFE_CHUNK_DATA");
m_version = file_stream.r_u32();
R_ASSERT2 (m_version>=0x0002,"ALife version mismatch! (Delete saved game and try again)");
};
void PDomain::Load(IReader& F)
{
type = PDomainEnum(F.r_u32());
F.r_fvector3(v[0]);
F.r_fvector3(v[1]);
F.r_fvector3(v[2]);
}
void CMapLocation::load(IReader &stream)
{
u16 c = stream.r_u16();
xr_string hint;
stream.r_stringZ(hint);
SetHint (hint.c_str());
SetRefCount (c);
m_flags.flags = stream.r_u32 ();
}
void SHeliEnemy::load(IReader &input_packet)
{
type = (EHeliHuntState)input_packet.r_s16();
input_packet.r_fvector3 (destEnemyPos);
destEnemyID = input_packet.r_u32();
fire_trail_length_des = input_packet.r_float();
bUseFireTrail = !!input_packet.r_u8();
}
void CMapLocation::load(IReader &stream)
{
xr_string str;
stream.r_stringZ(str);
SetHint (str.c_str());
m_flags.flags = stream.r_u32 ();
stream.r_stringZ(str);
m_owner_task_id = str.c_str();
}
void STextureParams::Load(IReader& F)
{
R_ASSERT(F.find_chunk(THM_CHUNK_TEXTUREPARAM));
F.r (&fmt,sizeof(ETFormat));
flags.assign(F.r_u32());
border_color= F.r_u32();
fade_color = F.r_u32();
fade_amount = F.r_u32();
mip_filter = F.r_u32();
width = F.r_u32();
height = F.r_u32();
if (F.find_chunk(THM_CHUNK_TEXTURE_TYPE)){
type = (ETType)F.r_u32();
}
if (F.find_chunk(THM_CHUNK_DETAIL_EXT)){
F.r_stringZ(detail_name);
detail_scale = F.r_float();
}
if (F.find_chunk(THM_CHUNK_MATERIAL)){
material = (ETMaterial)F.r_u32 ();
material_weight = F.r_float ();
}
if (F.find_chunk(THM_CHUNK_BUMP)){
bump_virtual_height = F.r_float ();
bump_mode = (ETBumpMode)F.r_u32 ();
if (bump_mode<STextureParams::tbmNone){
bump_mode = STextureParams::tbmNone; //.. временно (до полного убирания Autogen)
}
F.r_stringZ (bump_name);
}
if (F.find_chunk(THM_CHUNK_EXT_NORMALMAP))
F.r_stringZ (ext_normal_map_name);
if (F.find_chunk(THM_CHUNK_FADE_DELAY))
fade_delay = F.r_u8();
}
void SGameMtlPair::Load(IReader& fs)
{
shared_str buf;
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_PAIR));
mtl0 = fs.r_u32();
mtl1 = fs.r_u32();
ID = fs.r_u32();
ID_parent = fs.r_u32();
OwnProps.assign (fs.r_u32());
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_BREAKING));
fs.r_stringZ (buf); BreakingSounds = *buf;
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_STEP));
fs.r_stringZ (buf); StepSounds = *buf;
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_COLLIDE));
fs.r_stringZ (buf); CollideSounds = *buf;
fs.r_stringZ (buf); CollideParticles= *buf;
fs.r_stringZ (buf); CollideMarks = *buf;
}
void SGameMtlPair::Load(IReader& fs)
{
shared_str buf;
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_PAIR));
mtl0 = fs.r_u32();
mtl1 = fs.r_u32();
ID = fs.r_u32();
ID_parent = fs.r_u32();
u32 own_mask = fs.r_u32();
if (GAMEMTL_NONE_ID==ID_parent) OwnProps.one ();
else OwnProps.assign (own_mask);
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_BREAKING));
fs.r_stringZ (buf); BreakingSounds = buf.size()?*buf:"";
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_STEP));
fs.r_stringZ (buf); StepSounds = buf.size()?*buf:"";
R_ASSERT(fs.find_chunk(GAMEMTLPAIR_CHUNK_COLLIDE));
fs.r_stringZ (buf); CollideSounds = buf.size()?*buf:"";
fs.r_stringZ (buf); CollideParticles= buf.size()?*buf:"";
fs.r_stringZ (buf); CollideMarks = buf.size()?*buf:"";
}
bool ESceneSpawnTool::LoadStream(IReader& F)
{
u16 version = 0;
if(F.r_chunk(CHUNK_VERSION,&version))
if( version!=SPAWN_TOOLS_VERSION ){
ELog.DlgMsg( mtError, "%s tools: Unsupported version.",ClassDesc());
return false;
}
if (!inherited::LoadStream(F)) return false;
if (F.find_chunk(CHUNK_FLAGS))
m_Flags.assign (F.r_u32());
return true;
}
bool EScene::ReadObjectStream(IReader& F, CCustomObject*& O)
{
ObjClassID clsid =OBJCLASS_DUMMY;
R_ASSERT (F.find_chunk(CHUNK_OBJECT_CLASS));
clsid = ObjClassID(F.r_u32());
O = GetOTool(clsid)->CreateObject(0,0);
IReader* S = F.open_chunk(CHUNK_OBJECT_BODY);
R_ASSERT (S);
bool bRes = O->LoadStream(*S);
S->close ();
if (!bRes)
xr_delete (O);
return bRes;
}
CSavedGameWrapper::CSavedGameWrapper (LPCSTR saved_game_name)
{
string_path file_name;
saved_game_full_name (saved_game_name,file_name);
R_ASSERT3 (FS.exist(file_name),"There is no saved game ",file_name);
IReader *stream = FS.r_open(file_name);
if (!valid_saved_game(*stream)) {
FS.r_close (stream);
CALifeTimeManager time_manager(alife_section);
m_game_time = time_manager.game_time();
m_actor_health = 1.f;
m_level_id = ai().game_graph().header().levels().begin()->first;
return;
}
u32 source_count = stream->r_u32();
void *source_data = xr_malloc(source_count);
rtc_decompress (source_data,source_count,stream->pointer(),stream->length() - 3*sizeof(u32));
FS.r_close (stream);
IReader reader(source_data,source_count);
{
CALifeTimeManager time_manager(alife_section);
time_manager.load (reader);
m_game_time = time_manager.game_time();
}
{
R_ASSERT2 (reader.find_chunk(OBJECT_CHUNK_DATA),"Can't find chunk OBJECT_CHUNK_DATA!");
u32 count = reader.r_u32();
VERIFY (count > 0);
CSE_ALifeDynamicObject *object = CALifeObjectRegistry::get_object(reader);
VERIFY (object->ID == 0);
CSE_ALifeCreatureActor *actor = smart_cast<CSE_ALifeCreatureActor*>(object);
VERIFY (actor);
m_actor_health = actor->g_Health();
m_level_id = ai().game_graph().vertex(object->m_tGraphID)->level_id();
F_entity_Destroy (object);
}
xr_free (source_data);
}
bool CEditShape::LoadStream(IReader& F)
{
R_ASSERT(F.find_chunk(SHAPE_CHUNK_VERSION));
u16 vers = F.r_u16();
inherited::LoadStream (F);
R_ASSERT(F.find_chunk(SHAPE_CHUNK_SHAPES));
shapes.resize (F.r_u32());
F.r (shapes.begin(),shapes.size()*sizeof(shape_def));
if(F.find_chunk(SHAPE_CHUNK_DATA))
m_shape_type = F.r_u8();
ComputeBounds();
return true;
}
