////////////////////////////////////////////////////////////////////////////
//    Module   : xrServer_Objects_ALife.cpp
//    Created  : 19.09.2002
//  Modified  : 04.06.2003
//    Author  : Oles Shyshkovtsov, Alexander Maksimchuk, Victor Reutskiy and Dmitriy Iassenev
//    Description : Server objects for ALife simulator
////////////////////////////////////////////////////////////////////////////
// CSE_ALifeLevelChanger
////////////////////////////////////////////////////////////////////////////
CSE_ALifeLevelChanger::CSE_ALifeLevelChanger(LPCSTR caSection) : CSE_ALifeSpaceRestrictor(caSection)
{
    m_tNextGraphID    = GameGraph::_GRAPH_ID(-1);
    m_dwNextNodeID    = u32(-1);
    m_tNextPosition.set   (0.f,0.f,0.f);
    m_tAngles.set    (0.f,0.f,0.f);
#ifdef XRSE_FACTORY_EXPORTS
    fp_data.inc     ();
#endif
    m_bSilentMode    = FALSE;
}

CSE_ALifeLevelChanger::~CSE_ALifeLevelChanger()
{
#ifdef XRSE_FACTORY_EXPORTS
    fp_data.dec     ();
#endif
}

void CSE_ALifeLevelChanger::STATE_Read  (NET_Packet    &tNetPacket, u16 size)
{
    inherited::STATE_Read  (tNetPacket,size);
    if (m_wVersion < 34) {
  tNetPacket.r_u32  ();
  tNetPacket.r_u32  ();
    }
    else {
  tNetPacket.r   (&m_tNextGraphID,sizeof(m_tNextGraphID));
  tNetPacket.r_u32  (m_dwNextNodeID);
  tNetPacket.r_float  (m_tNextPosition.x);
  tNetPacket.r_float  (m_tNextPosition.y);
  tNetPacket.r_float  (m_tNextPosition.z);
  if (m_wVersion <= 53)
   m_tAngles.set  (0.f,tNetPacket.r_float(),0.f);
  else
   tNetPacket.r_vec3    (m_tAngles);
    }
    tNetPacket.r_stringZ  (m_caLevelToChange);
    tNetPacket.r_stringZ  (m_caLevelPointToChange);

    if (m_wVersion > 116)
  m_bSilentMode   = !!tNetPacket.r_u8();

}

void CSE_ALifeLevelChanger::STATE_Write    (NET_Packet    &tNetPacket)
{
    inherited::STATE_Write  (tNetPacket);
    tNetPacket.w    (&m_tNextGraphID,sizeof(m_tNextGraphID));
    tNetPacket.w_u32   (m_dwNextNodeID);
    tNetPacket.w_float   (m_tNextPosition.x);
    tNetPacket.w_float   (m_tNextPosition.y);
    tNetPacket.w_float   (m_tNextPosition.z);
    tNetPacket.w_vec3   (m_tAngles);
    tNetPacket.w_stringZ  (m_caLevelToChange);
    tNetPacket.w_stringZ  (m_caLevelPointToChange);
    tNetPacket.w_u8    (m_bSilentMode?1:0);
}

void CSE_ALifeLevelChanger::UPDATE_Read    (NET_Packet    &tNetPacket)
{
    inherited::UPDATE_Read  (tNetPacket);
}

void CSE_ALifeLevelChanger::UPDATE_Write    (NET_Packet    &tNetPacket)
{
    inherited::UPDATE_Write  (tNetPacket);
}

void CSE_ALifeLevelChanger::FillProps  (LPCSTR pref, PropItemVec& items)
{
    inherited::FillProps  (pref,items);
    
#ifdef XRSE_FACTORY_EXPORTS
    PHelper().CreateRList  (items,PrepareKey(pref,*s_name,"Level to change"),  &m_caLevelToChange,  &*fp_data.level_ids.begin(), fp_data.level_ids.size());
#endif
    PHelper().CreateRText  (items,PrepareKey(pref,*s_name,"Level point to change"),    &m_caLevelPointToChange);

    PHelper().CreateBOOL  (items,PrepareKey(pref,*s_name,"Silent mode"),    &m_bSilentMode);
}
////////////////////////////////////////////////////////////////////////////
//    Module   : level_changer.cpp
//    Created  : 10.07.2003
//  Modified  : 10.07.2003
//    Author  : Dmitriy Iassenev
//    Description : Level change object
////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "level_changer.h"
#include "hit.h"
#include "actor.h"
#include "xrserver_objects_alife.h"
#include "level.h"
#include "ai_object_location.h"
#include "ai_space.h"
#include "level_graph.h"
#include "game_level_cross_table.h"
#include "HudManager.h"
#include "UIGameSP.h"
#include "../xr_collide_form.h"

xr_vector<CLevelChanger*>    g_lchangers;

CLevelChanger::~CLevelChanger    ()
{
}

void CLevelChanger::Center  (Fvector& C) const
{
    XFORM().transform_tiny  (C,CFORM()->getSphere().P);
}

float CLevelChanger::Radius  () const
{
    return CFORM()->getRadius    ();
}

void CLevelChanger::net_Destroy    ()
{
    inherited ::net_Destroy    ();
    xr_vector<CLevelChanger*>::iterator it = std::find(g_lchangers.begin(), g_lchangers.end(), this);
    if(it != g_lchangers.end())
  g_lchangers.erase(it);
}

BOOL CLevelChanger::net_Spawn    (CSE_Abstract* DC)
{
    m_entrance_time    = 0;
    CCF_Shape *l_pShape   = xr_new<CCF_Shape>(this);
    collidable.model   = l_pShape;
    
    CSE_Abstract    *l_tpAbstract = (CSE_Abstract*)(DC);
    CSE_ALifeLevelChanger  *l_tpALifeLevelChanger = smart_cast<CSE_ALifeLevelChanger*>(l_tpAbstract);
    R_ASSERT     (l_tpALifeLevelChanger);

    m_game_vertex_id   = l_tpALifeLevelChanger->m_tNextGraphID;
    m_level_vertex_id   = l_tpALifeLevelChanger->m_dwNextNodeID;
    m_position     = l_tpALifeLevelChanger->m_tNextPosition;
    m_angles     = l_tpALifeLevelChanger->m_tAngles;

    m_bSilentMode    = !!l_tpALifeLevelChanger->m_bSilentMode;
    if (ai().get_level_graph()) {
  //. this information should be computed in xrAI
  ai_location().level_vertex    (ai().level_graph().vertex(u32(-1),Position()));
  ai_location().game_vertex    (ai().cross_table().vertex(ai_location().level_vertex_id()).game_vertex_id());
    }

    feel_touch.clear   ();
    
    for (u32 i=0; i < l_tpALifeLevelChanger->shapes.size(); ++i) {
  CSE_Shape::shape_def    &S = l_tpALifeLevelChanger->shapes[i];
  switch (S.type) {
   case 0 : {
    l_pShape->add_sphere(S.data.sphere);
    break;
   }
   case 1 : {
    l_pShape->add_box(S.data.box);
    break;
   }
  }
    }

    BOOL      bOk = inherited::net_Spawn(DC);
    if (bOk) {
  l_pShape->ComputeBounds    ();
  Fvector     P;
  XFORM().transform_tiny    (P,CFORM()->getSphere().P);
  setEnabled    (TRUE);
    }
    g_lchangers.push_back  (this);
    return      (bOk);
}

void CLevelChanger::shedule_Update(u32 dt)
{
    inherited::shedule_Update    (dt);

    const Fsphere    &s = CFORM()->getSphere();
    Fvector      P;
    XFORM().transform_tiny  (P,s.P);
    feel_touch_update   (P,s.R);

    update_actor_invitation  ();
}
#include "patrol_path.h"
#include "patrol_path_storage.h"
void CLevelChanger::feel_touch_new    (CObject *tpObject)
{
    CActor*   l_tpActor = smart_cast<CActor*>(tpObject);
    VERIFY   (l_tpActor);
    if (!l_tpActor->g_Alive())
  return;

    if (m_bSilentMode) {
  NET_Packet    p;
  p.w_begin    (M_CHANGE_LEVEL);
  p.w   (&m_game_vertex_id,sizeof(m_game_vertex_id));
  p.w   (&m_level_vertex_id,sizeof(m_level_vertex_id));
  p.w_vec3    (m_position);
  p.w_vec3    (m_angles);
  Level().Send(p,net_flags(TRUE));
  return;
    }
    Fvector   p,r;
    bool   b = get_reject_pos(p,r);
    CUIGameSP  *pGameSP = smart_cast<CUIGameSP*>(CurrentGameUI());
    if (pGameSP)
        pGameSP->ChangeLevel    (m_game_vertex_id, m_level_vertex_id, m_position, m_angles, p, r, b);

    m_entrance_time    = Device.fTimeGlobal;
}

bool CLevelChanger::get_reject_pos(Fvector& p, Fvector& r)
{
  p.set(0,0,0);
  r.set(0,0,0);
//--  db.actor:set_actor_position(patrol("t_way"):point(0))
//--  local dir = patrol("t_look"):point(0):sub(patrol("t_way"):point(0))
//--  db.actor:set_actor_direction(-dir:getH())

  if(m_ini_file && m_ini_file->section_exist("pt_move_if_reject"))
  {
   LPCSTR p_name = m_ini_file->r_string("pt_move_if_reject", "path");
   const CPatrolPath*  patrol_path = ai().patrol_paths().path(p_name);
   VERIFY     (patrol_path);
   
   const CPatrolPoint*  pt;
   pt      = &patrol_path->vertex(0)->data();
   p      = pt->position();

   Fvector tmp;
   pt      = &patrol_path->vertex(1)->data();
   tmp.sub     (pt->position(),p);
   tmp.getHP    (r.y,r.x);
   return true;
  }
  return false;
}

BOOL CLevelChanger::feel_touch_contact    (CObject *object)
{
    BOOL bRes    = (((CCF_Shape*)CFORM())->Contact(object));
    bRes  = bRes && smart_cast<CActor*>(object) && smart_cast<CActor*>(object)->g_Alive();
    return  bRes;
}

void CLevelChanger::update_actor_invitation()
{
    if(m_bSilentMode)      return;
    xr_vector<CObject*>::iterator it  = feel_touch.begin();
    xr_vector<CObject*>::iterator it_e  = feel_touch.end();

    for(;it!=it_e;++it){
  CActor*   l_tpActor = smart_cast<CActor*>(*it);
  VERIFY   (l_tpActor);
  
  if(!l_tpActor->g_Alive())
   continue;

  if(m_entrance_time+5.0f < Device.fTimeGlobal){
   CUIGameSP* pGameSP = smart_cast<CUIGameSP*>(CurrentGameUI());
   Fvector p,r;
   bool b = get_reject_pos(p,r);
   
   if(pGameSP)
    pGameSP->ChangeLevel(m_game_vertex_id,m_level_vertex_id,m_position,m_angles,p,r,b);

   m_entrance_time  = Device.fTimeGlobal;
  }
    }
}
////////////////////////////////////////////////////////////////////////////
//    Module   : level_changer.h
//    Created  : 10.07.2003
//  Modified  : 10.07.2003
//    Author  : Dmitriy Iassenev
//    Description : Level change object
////////////////////////////////////////////////////////////////////////////

#pragma once

#include "GameObject.h"
#include "../feel_touch.h"
#include "game_graph_space.h"

class CLevelChanger : public CGameObject, public Feel::Touch {
private:
    typedef    CGameObject    inherited;

private:
    GameGraph::_GRAPH_ID    m_game_vertex_id;
    u32      m_level_vertex_id;
    Fvector     m_position;
    Fvector     m_angles;
    float     m_entrance_time;

    void     update_actor_invitation    ();
    bool     m_bSilentMode;
    bool     get_reject_pos(Fvector& p, Fvector& r);

public:
    virtual    ~CLevelChanger  ();
    virtual BOOL  net_Spawn   (CSE_Abstract* DC);
    virtual void  net_Destroy   ();
    virtual void  Center    (Fvector& C) const;
    virtual float  Radius    () const;
    virtual void  shedule_Update  (u32 dt);
    virtual void  feel_touch_new  (CObject* O);
    virtual BOOL  feel_touch_contact    (CObject* O);

    virtual bool  IsVisibleForZones() { return false;}
};