void CLevelSpawnConstructor::load_objects ()
{
// loading spawn points
string_path file_name;
FS.update_path (file_name,"$game_levels$",*m_level.name());
strcat_s (file_name,"\\level.spawn");
IReader *level_spawn = FS.r_open(file_name);
u32 id;
IReader *chunk = level_spawn->open_chunk_iterator(id);
for ( ; chunk; chunk = level_spawn->open_chunk_iterator(id,chunk)) {
CSE_Abstract *abstract = create_object(chunk);
if (abstract->m_tClassID == CLSID_AI_GRAPH) {
add_graph_point (abstract);
continue;
}
// if (abstract->m_tClassID == CLSID_AI_SPAWN_GROUP) {
// add_spawn_group (abstract);
// continue;
// }
if (!abstract->m_gameType.MatchType(eGameIDSingle))
{
F_entity_Destroy (abstract);
continue;
}
CSE_ALifeObject *alife_object = smart_cast<CSE_ALifeObject*>(abstract);
if (!alife_object) {
F_entity_Destroy (abstract);
continue;
}
CSE_ALifeCreatureActor *actor = smart_cast<CSE_ALifeCreatureActor*>(alife_object);
if (actor) {
R_ASSERT3 (!m_actor,"Too many actors on the level ",*m_level.name());
m_actor = actor;
}
m_spawns.push_back (alife_object);
CSE_ALifeDynamicObject *dynamic_object = smart_cast<CSE_ALifeDynamicObject*>(alife_object);
if (dynamic_object) {
add_story_object (dynamic_object);
add_space_restrictor(dynamic_object);
}
if (smart_cast<CSE_ALifeLevelChanger*>(abstract))
add_level_changer (abstract);
// if (xr_strlen(alife_object->m_spawn_control))
// add_group_object (alife_object,alife_object->m_spawn_control);
add_free_object (alife_object);
}
FS.r_close (level_spawn);
R_ASSERT2 (!m_spawns.empty(),"There are no spawn-points!");
}
void CLevel::g_cl_Spawn (LPCSTR name, u8 rp, u16 flags, Fvector pos)
{
// Create
CSE_Abstract* E = F_entity_Create(name);
VERIFY (E);
// Fill
E->s_name = name;
E->set_name_replace ("");
//. E->s_gameid = u8(GameID());
E->s_RP = rp;
E->ID = 0xffff;
E->ID_Parent = 0xffff;
E->ID_Phantom = 0xffff;
E->s_flags.assign (flags);
E->RespawnTime = 0;
E->o_Position = pos;
// Send
NET_Packet P;
E->Spawn_Write (P,TRUE);
Send (P,net_flags(TRUE));
// Destroy
F_entity_Destroy (E);
}
/////////spawn object representing destroyed item//////////////////////////////////////////////////////////////////////////////////
void CPHDestroyable::GenSpawnReplace(u16 ref_id,LPCSTR section,shared_str visual_name)
{
CSE_Abstract *D = F_entity_Create(section);//*cNameSect()
VERIFY (D);
CSE_Visual *V =smart_cast<CSE_Visual*>(D);
V->set_visual (*visual_name);
CSE_PHSkeleton *l_tpPHSkeleton = smart_cast<CSE_PHSkeleton*>(D);
VERIFY (l_tpPHSkeleton);
l_tpPHSkeleton->source_id = ref_id;
//init
// Send
D->s_name = section;//*cNameSect()
D->ID_Parent = u16(-1);
InitServerObject (D);
if (OnServer())
{
NET_Packet P;
D->Spawn_Write (P,TRUE);
Level().Send (P,net_flags(TRUE));
// Destroy
F_entity_Destroy (D);
m_depended_objects++;
};
};
void xrServer::entity_Destroy (CSE_Abstract *&P)
{
// Msg ("xrServer::entity_Destroy : [%d][%s][%s]",P->ID,P->name(),P->name_replace());
R_ASSERT (P);
P->owner = NULL;
entities.erase (P->ID);
m_tID_Generator.vfFreeID (P->ID,Device.TimerAsync());
if (!ai().get_alife() || !P->m_bALifeControl)
F_entity_Destroy (P);
}
CLevelSpawnConstructor::~CLevelSpawnConstructor ()
{
GRAPH_POINT_STORAGE::iterator I = m_graph_points.begin();
GRAPH_POINT_STORAGE::iterator E = m_graph_points.end();
for ( ; I != E; ++I)
F_entity_Destroy ((CSE_Abstract*&)(*I));
VERIFY (!m_level_graph);
VERIFY (!m_cross_table);
VERIFY (!m_graph_engine);
}
CSE_Abstract* game_sv_GameState::spawn_end (CSE_Abstract* E, ClientID id)
{
NET_Packet P;
u16 skip_header;
E->Spawn_Write (P,TRUE);
P.r_begin (skip_header);
CSE_Abstract* N = m_server->Process_spawn (P,id);
F_entity_Destroy (E);
return N;
}
void CWeapon::SpawnAmmo(u32 boxCurr, LPCSTR ammoSect, u32 ParentID)
{
if(!m_ammoTypes.size()) return;
if (OnClient()) return;
m_bAmmoWasSpawned = true;
int l_type = 0;
l_type %= m_ammoTypes.size();
if(!ammoSect) ammoSect = m_ammoTypes[l_type].c_str();
++l_type;
l_type %= m_ammoTypes.size();
CSE_Abstract *D = F_entity_Create(ammoSect);
{
CSE_ALifeItemAmmo *l_pA = smart_cast<CSE_ALifeItemAmmo*>(D);
R_ASSERT (l_pA);
l_pA->m_boxSize = (u16)pSettings->r_s32(ammoSect, "box_size");
D->s_name = ammoSect;
D->set_name_replace ("");
//. D->s_gameid = u8(GameID());
D->s_RP = 0xff;
D->ID = 0xffff;
if (ParentID == 0xffffffff)
D->ID_Parent = (u16)H_Parent()->ID();
else
D->ID_Parent = (u16)ParentID;
D->ID_Phantom = 0xffff;
D->s_flags.assign (M_SPAWN_OBJECT_LOCAL);
D->RespawnTime = 0;
l_pA->m_tNodeID = g_dedicated_server ? u32(-1) : ai_location().level_vertex_id();
if(boxCurr == 0xffffffff)
boxCurr = l_pA->m_boxSize;
while(boxCurr)
{
l_pA->a_elapsed = (u16)(boxCurr > l_pA->m_boxSize ? l_pA->m_boxSize : boxCurr);
NET_Packet P;
D->Spawn_Write (P, TRUE);
Level().Send (P,net_flags(TRUE));
if(boxCurr > l_pA->m_boxSize)
boxCurr -= l_pA->m_boxSize;
else
boxCurr = 0;
}
}
F_entity_Destroy (D);
}
void CLevel::ProcessGameSpawns ()
{
while (!game_spawn_queue.empty())
{
CSE_Abstract* E = game_spawn_queue.front();
g_sv_Spawn (E);
F_entity_Destroy (E);
game_spawn_queue.pop_front ();
}
}
IC bool operator() (CSE_ALifeObject *object) const
{
SPAWN_STORAGE::const_iterator I = std::find(m_zones->begin(),m_zones->end(),object);
if (I == m_zones->end())
return (false);
VERIFY (!object->m_spawn_control);
VERIFY (object->m_story_id == INVALID_STORY_ID);
m_level_spawn_constructor->game_spawn_constructor().remove_object(object);
CSE_Abstract *abstract = object;
F_entity_Destroy (abstract);
return (true);
}
void CLevel::cl_Process_Spawn(NET_Packet& P)
{
// Begin analysis
shared_str s_name;
P.r_stringZ (s_name);
// Create DC (xrSE)
CSE_Abstract* E = F_entity_Create (*s_name);
R_ASSERT2(E, *s_name);
E->Spawn_Read (P);
if (E->s_flags.is(M_SPAWN_UPDATE))
E->UPDATE_Read (P);
if (!E->match_configuration())
{
F_entity_Destroy(E);
return;
}
//-------------------------------------------------
//. Msg ("M_SPAWN - %s[%d][%x] - %d %d", *s_name, E->ID, E,E->ID_Parent, Device.dwFrame);
//-------------------------------------------------
//force object to be local for server client
if (OnServer()) {
E->s_flags.set(M_SPAWN_OBJECT_LOCAL, TRUE);
};
/*
game_spawn_queue.push_back(E);
if (g_bDebugEvents) ProcessGameSpawns();
/*/
g_sv_Spawn (E);
F_entity_Destroy (E);
//*/
};
u16 GetSpawnInfo(NET_Packet &P, u16 &parent_id)
{
u16 dummy16, id;
P.r_begin(dummy16);
shared_str s_name;
P.r_stringZ(s_name);
CSE_Abstract* E = F_entity_Create(*s_name);
E->Spawn_Read(P);
if (E->s_flags.is(M_SPAWN_UPDATE))
E->UPDATE_Read(P);
id = E->ID;
parent_id = E->ID_Parent;
F_entity_Destroy(E);
P.r_pos = 0;
return id;
}
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 CInventoryItem::Detach(const char* item_section_name, bool b_spawn_item)
{
if (OnClient()) return true;
if(b_spawn_item)
{
CSE_Abstract* D = F_entity_Create(item_section_name);
R_ASSERT (D);
CSE_ALifeDynamicObject *l_tpALifeDynamicObject =
smart_cast<CSE_ALifeDynamicObject*>(D);
R_ASSERT (l_tpALifeDynamicObject);
l_tpALifeDynamicObject->m_tNodeID = object().ai_location().level_vertex_id();
// Fill
D->s_name = item_section_name;
D->set_name_replace ("");
D->s_gameid = u8(GameID());
D->s_RP = 0xff;
D->ID = 0xffff;
if (GameID() == GAME_SINGLE)
{
D->ID_Parent = u16(object().H_Parent()->ID());
}
else // i'm not sure this is right
{ // but it is simpliest way to avoid exception in MP BuyWnd... [Satan]
if (object().H_Parent())
D->ID_Parent = u16(object().H_Parent()->ID());
else
D->ID_Parent = NULL;
}
D->ID_Phantom = 0xffff;
D->o_Position = object().Position();
D->s_flags.assign (M_SPAWN_OBJECT_LOCAL);
D->RespawnTime = 0;
// Send
NET_Packet P;
D->Spawn_Write (P,TRUE);
Level().Send (P,net_flags(TRUE));
// Destroy
F_entity_Destroy (D);
}
return true;
}
void CPHSkeleton::SpawnCopy()
{
if(PPhysicsShellHolder()->Local()) {
CSE_Abstract* D = F_entity_Create("ph_skeleton_object");//*cNameSect()
R_ASSERT (D);
/////////////////////////////////////////////////////////////////////////////////////////////
CSE_ALifePHSkeletonObject *l_tpALifePhysicObject = smart_cast<CSE_ALifePHSkeletonObject*>(D);
R_ASSERT (l_tpALifePhysicObject);
l_tpALifePhysicObject->_flags.set (CSE_PHSkeleton::flSpawnCopy,1);
//SetNotNeedSave()
/////////////////////////////////////////////////////////////////////////////////////////////
InitServerObject (D);
// Send
NET_Packet P;
D->Spawn_Write (P,TRUE);
Level().Send (P,net_flags(TRUE));
// Destroy
F_entity_Destroy (D);
}
}
void CInventoryOwner::spawn_supplies ()
{
CGameObject *game_object = smart_cast<CGameObject*>(this);
VERIFY (game_object);
if (smart_cast<CBaseMonster*>(this)) return;
if (use_bolts())
Level().spawn_item ("bolt",game_object->Position(),game_object->ai_location().level_vertex_id(),game_object->ID());
if (!ai().get_alife() && GameID()==GAME_SINGLE) {
CSE_Abstract *abstract = Level().spawn_item("device_pda",game_object->Position(),game_object->ai_location().level_vertex_id(),game_object->ID(),true);
CSE_ALifeItemPDA *pda = smart_cast<CSE_ALifeItemPDA*>(abstract);
R_ASSERT (pda);
pda->m_original_owner = (u16)game_object->ID();
NET_Packet P;
abstract->Spawn_Write (P,TRUE);
Level().Send (P,net_flags(TRUE));
F_entity_Destroy (abstract);
}
}
CSE_Abstract *CLevel::spawn_item (LPCSTR section, const Fvector &position, u32 level_vertex_id, u16 parent_id, bool return_item)
{
CSE_Abstract *abstract = F_entity_Create(section);
R_ASSERT3 (abstract,"Cannot find item with section",section);
CSE_ALifeDynamicObject *dynamic_object = smart_cast<CSE_ALifeDynamicObject*>(abstract);
if (dynamic_object && ai().get_level_graph()) {
dynamic_object->m_tNodeID = level_vertex_id;
if (ai().level_graph().valid_vertex_id(level_vertex_id) && ai().get_game_graph() && ai().get_cross_table())
dynamic_object->m_tGraphID = ai().cross_table().vertex(level_vertex_id).game_vertex_id();
}
//оружие спавним с полным магазинои
CSE_ALifeItemWeapon* weapon = smart_cast<CSE_ALifeItemWeapon*>(abstract);
if(weapon)
weapon->a_elapsed = weapon->get_ammo_magsize();
// Fill
abstract->s_name = section;
abstract->set_name_replace (section);
//. abstract->s_gameid = u8(GameID());
abstract->o_Position = position;
abstract->s_RP = 0xff;
abstract->ID = 0xffff;
abstract->ID_Parent = parent_id;
abstract->ID_Phantom = 0xffff;
abstract->s_flags.assign(M_SPAWN_OBJECT_LOCAL);
abstract->RespawnTime = 0;
if (!return_item) {
NET_Packet P;
abstract->Spawn_Write (P,TRUE);
Send (P,net_flags(TRUE));
F_entity_Destroy (abstract);
return (0);
}
else
return (abstract);
}
void SArtefactActivation::SpawnAnomaly()
{
VERIFY(!ph_world->Processing());
string128 tmp;
LPCSTR str = pSettings->r_string("artefact_spawn_zones",*m_af->cNameSect());
VERIFY3(3==_GetItemCount(str),"Bad record format in artefact_spawn_zones",str);
float zone_radius = (float)atof(_GetItem(str,1,tmp));
float zone_power = (float)atof(_GetItem(str,2,tmp));
LPCSTR zone_sect = _GetItem(str,0,tmp); //must be last call of _GetItem... (LPCSTR !!!)
Fvector pos;
m_af->Center(pos);
CSE_Abstract *object = Level().spawn_item( zone_sect,
pos,
m_af->ai_location().level_vertex_id(),
0xffff,
true
);
CSE_ALifeAnomalousZone* AlifeZone = smart_cast<CSE_ALifeAnomalousZone*>(object);
VERIFY(AlifeZone);
CShapeData::shape_def _shape;
_shape.data.sphere.P.set (0.0f,0.0f,0.0f);
_shape.data.sphere.R = zone_radius;
_shape.type = CShapeData::cfSphere;
AlifeZone->assign_shapes (&_shape,1);
AlifeZone->m_maxPower = zone_power;
AlifeZone->m_owner_id = m_owner_id;
AlifeZone->m_space_restrictor_type = RestrictionSpace::eRestrictorTypeNone;
NET_Packet P;
object->Spawn_Write (P,TRUE);
Level().Send (P,net_flags(TRUE));
F_entity_Destroy (object);
#ifdef DEBUG
Msg("artefact [%s] spawned a zone [%s] at [%f]", *m_af->cName(), zone_sect, Device.fTimeGlobal);
#endif
}
FACTORY_API void __stdcall destroy_entity (ISE_Abstract *&abstract)
{
CSE_Abstract *object = smart_cast<CSE_Abstract*>(abstract);
F_entity_Destroy (object);
abstract = 0;
}
void CGameGraphBuilder::load_graph_point (NET_Packet &net_packet)
{
string256 section_id;
u16 id;
net_packet.r_begin (id);
R_ASSERT (M_SPAWN == id);
net_packet.r_stringZ (section_id);
// if (xr_strcmp("graph_point",section_id))
// return;
CSE_Abstract *entity = F_entity_Create(section_id);
if (!entity) {
Msg ("Cannot create entity from section %s, skipping",section_id);
return;
}
CSE_ALifeGraphPoint *graph_point = smart_cast<CSE_ALifeGraphPoint*>(entity);
if (!graph_point) {
F_entity_Destroy (entity);
return;
}
entity->Spawn_Read (net_packet);
vertex_type vertex;
vertex.tLocalPoint = graph_point->o_Position;
// check for duplicate graph point positions
{
graph_type::const_vertex_iterator I = graph().vertices().begin();
graph_type::const_vertex_iterator E = graph().vertices().end();
for ( ; I != E; ++I) {
if ((*I).second->data().tLocalPoint.distance_to_sqr(vertex.tLocalPoint) < EPS_L) {
Msg ("! removing graph point [%s][%f][%f][%f] because it is too close to the another graph point",entity->name_replace(),VPUSH(entity->o_Position));
return;
}
}
}
vertex.tGlobalPoint = graph_point->o_Position;
vertex.tNodeID = level_graph().valid_vertex_position(vertex.tLocalPoint) ? level_graph().vertex_id(vertex.tLocalPoint) : u32(-1);
if (!level_graph().valid_vertex_id(vertex.tNodeID)) {
Msg ("! removing graph point [%s][%f][%f][%f] because it is outside of the AI map",entity->name_replace(),VPUSH(entity->o_Position));
return;
}
{
graph_type::const_vertex_iterator I = graph().vertices().begin();
graph_type::const_vertex_iterator E = graph().vertices().end();
for ( ; I != E; ++I) {
if ((*I).second->data().tNodeID == vertex.tNodeID) {
Msg ("! removing graph point [%s][%f][%f][%f] because it has the same AI node as another graph point",entity->name_replace(),VPUSH(entity->o_Position));
return;
}
}
}
vertex.tNeighbourCount = 0;
Memory.mem_copy (vertex.tVertexTypes,graph_point->m_tLocations,GameGraph::LOCATION_TYPE_COUNT*sizeof(GameGraph::_LOCATION_ID));
vertex.tLevelID = 0;
vertex.tDeathPointCount = 0;
vertex.dwPointOffset = 0;
graph().add_vertex (vertex,graph().vertices().size());
F_entity_Destroy (entity);
}
void CGameObject::spawn_supplies()
{
if (!spawn_ini() || ai().get_alife())
return;
if (!spawn_ini()->section_exist("spawn"))
return;
LPCSTR N,V;
float p;
bool bScope = false;
bool bSilencer = false;
bool bLauncher = false;
for (u32 k = 0, j; spawn_ini()->r_line("spawn",k,&N,&V); k++) {
VERIFY (xr_strlen(N));
j = 1;
p = 1.f;
float f_cond = 1.0f;
if (V && xr_strlen(V)) {
int n = _GetItemCount(V);
string16 temp;
if (n > 0)
j = atoi(_GetItem(V,0,temp)); //count
if(NULL!=strstr(V,"prob="))
p =(float)atof(strstr(V,"prob=")+5);
if (fis_zero(p))p = 1.f;
if (!j) j = 1;
if(NULL!=strstr(V,"cond="))
f_cond = (float)atof(strstr(V,"cond=")+5);
bScope = (NULL!=strstr(V,"scope"));
bSilencer = (NULL!=strstr(V,"silencer"));
bLauncher = (NULL!=strstr(V,"launcher"));
}
for (u32 i=0; i<j; ++i)
if (::Random.randF(1.f) < p){
CSE_Abstract* A=Level().spawn_item (N,Position(),ai_location().level_vertex_id(),ID(),true);
CSE_ALifeInventoryItem* pSE_InventoryItem = smart_cast<CSE_ALifeInventoryItem*>(A);
if(pSE_InventoryItem)
pSE_InventoryItem->m_fCondition = f_cond;
CSE_ALifeItemWeapon* W = smart_cast<CSE_ALifeItemWeapon*>(A);
if (W) {
if (W->m_scope_status == ALife::eAddonAttachable)
W->m_addon_flags.set(CSE_ALifeItemWeapon::eWeaponAddonScope, bScope);
if (W->m_silencer_status == ALife::eAddonAttachable)
W->m_addon_flags.set(CSE_ALifeItemWeapon::eWeaponAddonSilencer, bSilencer);
if (W->m_grenade_launcher_status == ALife::eAddonAttachable)
W->m_addon_flags.set(CSE_ALifeItemWeapon::eWeaponAddonGrenadeLauncher, bLauncher);
}
NET_Packet P;
A->Spawn_Write (P,TRUE);
Level().Send (P,net_flags(TRUE));
F_entity_Destroy (A);
}
}
}