void study::Handle()
{
item* Literature = game::SearchItem(LiteratureID);
if(!Literature || !Literature->Exists() || !Actor->IsOver(Literature))
{
Terminate(false);
return;
}
if(GetActor()->GetLSquareUnder()->IsDark() && !game::GetSeeWholeMapCheatMode())
{
ADD_MESSAGE("It is too dark to read now.");
Terminate(false);
return;
}
if(game::CompareLightToInt(GetActor()->GetLSquareUnder()->GetLuminance(), 115) < 0)
GetActor()->EditExperience(PERCEPTION, -50, 1 << 1);
if(!Counter)
{
Terminate(true);
return;
}
if(GetActor()->GetAttribute(INTELLIGENCE) >= Counter)
Counter = 0;
else
Counter -= GetActor()->GetAttribute(INTELLIGENCE);
}
//------------------------------------------------------------------------
int CScriptBind_Item::OnUsed(IFunctionHandler *pH, ScriptHandle userId)
{
CItem *pItem = GetItem(pH);
if (!pItem)
return pH->EndFunction();
if (pItem->CanUse((EntityId)userId.n))
{
CActor *pActor=GetActor((EntityId)userId.n);
if (pActor)
{
pActor->UseItem(pItem->GetEntityId());
return pH->EndFunction(true);
}
}
else if (pItem->CanPickUp((EntityId)userId.n))
{
CActor *pActor=GetActor((EntityId)userId.n);
if (pActor)
{
pActor->PickUpItem(pItem->GetEntityId(), true);
return pH->EndFunction(true);
}
}
return pH->EndFunction();
}
//------------------------------------------------------------------------
void CInventory::HolsterItem(bool holster)
{
//CryLogAlways("%s::HolsterItem(%s)", GetEntity()->GetName(), holster?"true":"false");
if (!holster)
{
if (m_stats.holsteredItemId)
{
IItem* pItem = m_pGameFrameWork->GetIItemSystem()->GetItem(m_stats.holsteredItemId);
if(pItem && pItem->CanSelect())
{
m_pGameFrameWork->GetIItemSystem()->SetActorItem(GetActor(), m_stats.holsteredItemId, false);
}
else
{
m_pGameFrameWork->GetIItemSystem()->SetActorItem(GetActor(), GetLastItem(), false);
}
}
m_stats.holsteredItemId = 0;
}
else if (m_stats.currentItemId && (!m_stats.holsteredItemId || m_stats.holsteredItemId == m_stats.currentItemId))
{
m_stats.holsteredItemId = m_stats.currentItemId;
m_pGameFrameWork->GetIItemSystem()->SetActorItem(GetActor(), (EntityId)0, false);
}
}
bool Client::Disconnect()
{
// Make sure the advisor system knows this client is gone.
if ( isAdvisor )
{
psserver->GetAdviceManager()->RemoveAdvisor( this->GetClientNum(), 0);
}
if (GetActor() && GetActor()->InGroup())
{
GetActor()->RemoveFromGroup();
}
// Only save if an account has been found for this client.
if (accountID.IsValid())
{
SaveAccountData();
}
/*we have to clear the challenges else the other players will be stuck
in challenge mode */
if(GetDuelClientCount())
{
ClearAllDuelClients();
}
return true;
}
void AIBrain::Update(float dt)
{
if( _brainStateTable.size() == 0 )
{
GetActor()->InitializeBrain();
GetActor()->StartBrain();
}
if( _current == _brainStateTable.end() )
return;
(*_current).second->Update(dt);
}
void unconsciousness::Terminate(bool Finished)
{
if(Flags & TERMINATING)
return;
Flags |= TERMINATING;
if(GetActor()->IsPlayer())
ADD_MESSAGE("You wake up.");
else if(GetActor()->CanBeSeenByPlayer())
ADD_MESSAGE("%s wakes up.", GetActor()->CHAR_NAME(DEFINITE));
action::Terminate(Finished);
}
void AIBrain::Render()
{
if( !_drawMe )
return;
if( _current != _brainStateTable.end() )
{
Vector2 screenCenter = MathUtil::WorldToScreen( GetActor()->GetPosition().X, GetActor()->GetPosition().Y );
//Print some vals
glColor3f(0,0.f,1.f);
DrawGameText( (*_current).first, "ConsoleSmall", (int)screenCenter.X, (int)screenCenter.Y );
}
}
//------------------------------------------------------------------
void CLam::PickUp(EntityId pickerId, bool sound, bool select, bool keepHistory, const char *setup)
{
if(gEnv->bServer && m_lamparams.giveExtraAccessory)
{
CActor *pActor=GetActor(pickerId);
if (pActor && pActor->IsPlayer())
{
IInventory *pInventory=GetActorInventory(pActor);
if (pInventory)
{
if (!m_lamparams.isLamRifle && !pInventory->HasAccessory(CItem::sLAMFlashLight) && gEnv->bMultiplayer)
m_pItemSystem->GiveItem(pActor, m_lamparams.extraAccessoryName.c_str(), false, false, false);
else if(m_lamparams.isLamRifle && !pInventory->HasAccessory(CItem::sLAMRifleFlashLight) && gEnv->bMultiplayer)
m_pItemSystem->GiveItem(pActor, m_lamparams.extraAccessoryName.c_str(), false, false, false);
}
}
}
//FIX-ME!!
//Scout beam needs to go into the inventory like a normal item, not accessory
static IEntityClass* pBeamClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass("ScoutSearchBeam");
if(GetEntity()->GetClass()==pBeamClass)
CItem::PickUp(pickerId,sound,select,keepHistory,setup);
else
CAccessory::PickUp(pickerId,sound,select,keepHistory,setup);
}
//------------------------------------------------------------------------
int CScriptBind_Actor::SetInventoryAmmo(IFunctionHandler *pH, const char *ammo, int amount)
{
CActor * pActor = GetActor(pH);
if (!pActor)
return pH->EndFunction();
IInventory *pInventory=pActor->GetInventory();
if (!pInventory)
return pH->EndFunction();
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ammo);
assert(pClass);
int capacity = pInventory->GetAmmoCapacity(pClass);
int current = pInventory->GetAmmoCount(pClass);
if((!gEnv->IsEditor()) && (amount > capacity))
{
//If still there's some place, full inventory to maximum...
if(current<capacity)
{
pInventory->SetAmmoCount(pClass,capacity);
if (gEnv->bServer)
pActor->GetGameObject()->InvokeRMI(CActor::ClSetAmmo(), CActor::AmmoParams(ammo, amount), eRMI_ToRemoteClients);
}
}
else
{
pInventory->SetAmmoCount(pClass, amount);
if (gEnv->bServer)
pActor->GetGameObject()->InvokeRMI(CActor::ClSetAmmo(), CActor::AmmoParams(ammo, amount), eRMI_ToRemoteClients);
}
return pH->EndFunction();
}
//------------------------------------------------------------------------
bool CGunTurret::IsTargetShootable(IEntity *pTarget)
{
// raycast shootability check
Vec3 pos = m_fireHelper.empty() ? GetWeaponPos() : GetSlotHelperPos(eIGS_ThirdPerson, m_fireHelper.c_str(), true);
Vec3 tpos = GetTargetPos(pTarget);
Vec3 dir = tpos - pos;
bool shootable = RayCheck(pTarget, pos, dir);
if(!shootable)
{
// fallback for actors
// todo: also use this for shooting pos!
CActor *pActor = GetActor(pTarget->GetId());
if(pActor && pActor->GetMovementController())
{
SMovementState state;
pActor->GetMovementController()->GetMovementState(state);
dir = state.eyePosition - pos;
shootable = RayCheck(pTarget, pos, dir);
}
}
return shootable;
}
bool CHeavyWeapon::CanUse(EntityId userId) const
{
#if USE_PC_PREMATCH
if(CGameRules * pGameRules = g_pGame->GetGameRules())
{
if(pGameRules->GetPrematchState() != CGameRules::ePS_Match)
{
return false;
}
}
#endif //USE_PC_PREMATCH
EntityId ownerId = m_owner.GetId();
if (ownerId == 0)
{
CActor* pActor = GetActor(userId);
if (pActor && pActor->IsSwimming())
return false;
if (pActor && pActor->IsPlayer() && !pActor->IsSwimming())
{
bool alreadyCarringHeavyWeapon = static_cast<CPlayer*>(pActor)->HasHeavyWeaponEquipped();
if (alreadyCarringHeavyWeapon)
return false;
}
}
return m_sharedparams->params.usable && m_properties.usable;
}
int CScriptBind_Actor::GetClosestAttachment(IFunctionHandler *pH, int characterSlot, Vec3 testPos, float maxDistance, const char* suffix)
{
CActor *pActor = GetActor(pH);
if (!pActor)
return pH->EndFunction();
IEntity* pEntity = pActor->GetEntity();
ICharacterInstance* pChar = pEntity->GetCharacter(characterSlot);
if (!pChar)
return pH->EndFunction();
//fallback: use nearest attachment
float minDiff = maxDistance*maxDistance;
IAttachment* pClosestAtt = 0;
IAttachmentManager* pMan = pChar->GetIAttachmentManager();
int count = pMan->GetAttachmentCount();
for (int i=0; i<count; ++i)
{
IAttachment* pAtt = pMan->GetInterfaceByIndex(i);
if (pAtt->IsAttachmentHidden() || !pAtt->GetIAttachmentObject())
continue;
AABB bbox(AABB::CreateTransformedAABB(Matrix34(pAtt->GetAttWorldAbsolute()),pAtt->GetIAttachmentObject()->GetAABB()));
//gEnv->pRenderer->GetIRenderAuxGeom()->DrawAABB(bbox,false,ColorB(255,0,0,100),eBBD_Faceted);
//float diff = (testPos - pAtt->GetWMatrix().GetTranslation()).len2();
float diff((testPos - bbox.GetCenter()).len2());
if (diff < minDiff)
{
//CryLogAlways("%s distance: %.1f", pAtt->GetName(), sqrt(diff));
if (suffix[0] && !strstr(pAtt->GetName(), suffix))
continue;
minDiff = diff;
pClosestAtt = pAtt;
}
}
if (!pClosestAtt)
return pH->EndFunction();
//FIXME FIXME: E3 workaround
char attachmentName[64];
strncpy(attachmentName,pClosestAtt->GetName(),63);
attachmentName[63] = 0;
char *pDotChar = strstr(attachmentName,".");
if (pDotChar)
*pDotChar = 0;
strlwr(attachmentName);
//
return pH->EndFunction(attachmentName);
}
//------------------------------------------------------------------------
CGunTurret::ETargetClass CGunTurret::GetTargetClass(IEntity *pTarget)const
{
IActor *pActor=GetActor(pTarget->GetId());
if(!pActor)
{
if(IsTACBullet(pTarget))
return eTC_TACProjectile;
return eTC_NotATarget;
}
if(IsTargetDead(pActor))
return eTC_NotATarget;
if(!IsTargetHostile(pActor))
return eTC_NotATarget;
if(IsTargetSpectating(pActor))
return eTC_NotATarget;
bool vehicle = pActor->GetLinkedVehicle()!=0;
//Vehicles only check
if(m_turretparams.vehicles_only && !vehicle)
return eTC_NotATarget;
if(vehicle)
return eTC_Vehicle;
if(IsTargetCloaked(pActor))
return eTC_NotATarget;
return eTC_Player;
}
void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
{
if(eFE_Activate == event)
{
const bool bAttach = IsPortActive(pActInfo, EIP_ATTACH);
const bool bDetach = IsPortActive(pActInfo, EIP_DETACH);
if (!bAttach && !bDetach)
return;
IActor* pActor = GetActor(pActInfo);
if (pActor == 0)
return;
const string& className = GetPortString(pActInfo, EIP_WEAPON);
CWeapon* pWeapon = static_cast<CWeapon*> ( className.empty() ? GetWeapon(pActor) : GetWeapon(pActor, className.c_str()) );
if (pWeapon != 0)
{
ItemString acc = ItemString(GetPortString(pActInfo, EIP_ACCESSORY));
if (bAttach && pWeapon->GetAccessory(acc) == 0)
{
pWeapon->SwitchAccessory(acc);
ActivateOutput(pActInfo, EOP_ATTACHED, true);
}
else if (bDetach && pWeapon->GetAccessory(acc) != 0)
{
pWeapon->SwitchAccessory(acc);
ActivateOutput(pActInfo, EOP_DETACHED, true);
}
}
}
}
//------------------------------------------------------------------------
bool CGunTurret::RayCheck(IEntity *pTarget, const Vec3 &pos, const Vec3 &dir) const
{
ray_hit rayhit;
IPhysicalEntity *pSkipEnts[1];
pSkipEnts[0] = GetEntity()->GetPhysics();
int nSkip = 1;
//make sure you are not inside geometry when casting
Vec3 newPos = pos + 0.3f*dir;
if(gEnv->pPhysicalWorld->RayWorldIntersection(newPos, dir, ent_all, rwi_stop_at_pierceable|rwi_colltype_any, &rayhit, 1, pSkipEnts, nSkip))
{
if(rayhit.pCollider)
{
IEntity *pEntity = (IEntity *)rayhit.pCollider->GetForeignData(PHYS_FOREIGN_ID_ENTITY);
if(pEntity==pTarget)
return true;
else if(CActor *pActor = GetActor(pTarget->GetId()))
{
IVehicle *pLinkedVehicle=pActor->GetLinkedVehicle();
if(pLinkedVehicle && pLinkedVehicle->GetEntity()==pEntity)
return true;
}
}
return false;
}
return true;
}
bool CJaw::CanPickUp(EntityId userId) const
{
CActor *pActor = GetActor(userId);
IInventory *pInventory=GetActorInventory(pActor);
if (m_sharedparams->params.pickable && m_stats.pickable && !m_stats.flying && (!m_owner.GetId() || m_owner.GetId()==userId) && !m_stats.selected && !GetEntity()->IsHidden())
{
if (pInventory && pInventory->FindItem(GetEntityId())!=-1)
return false;
}
else
return false;
if(GetAmmoCount(m_fm->GetAmmoType())<=0)
{
return false;
}
uint8 uniqueId = m_pItemSystem->GetItemUniqueId(GetEntity()->GetClass()->GetName());
int maxNumRockets = GetWeaponSharedParams()->ammoParams.capacityAmmo[0].count;
if(pInventory && (pInventory->GetCountOfUniqueId(uniqueId)>=maxNumRockets))
{
if(pActor->IsClient())
{
SHUDEventWrapper::DisplayInfo(eInfo_Warning, 0.5f, "@mp_CannotCarryMoreLAW");
}
return false;
}
return true;
}
//------------------------------------------------------------------------
int CScriptBind_Actor::CheckVirtualInventoryRestrictions(IFunctionHandler *pH, SmartScriptTable inventory, const char *itemClassName)
{
CActor *pActor = GetActor(pH);
if (!pActor)
return pH->EndFunction();
static std::vector<string> virtualInventory;
virtualInventory.reserve(inventory->Count());
IScriptTable::Iterator it=inventory->BeginIteration();
while(inventory->MoveNext(it))
{
const char *itemClass=0;
it.value.CopyTo(itemClass);
if (itemClass && itemClass[0])
virtualInventory.push_back(itemClass);
}
inventory->EndIteration(it);
bool result=pActor->CheckVirtualInventoryRestrictions(virtualInventory, itemClassName);
virtualInventory.resize(0);
if (result)
return pH->EndFunction(1);
return pH->EndFunction();
}
//------------------------------------------------------------------------
int CScriptBind_Actor::SetPhysicalizationProfile(IFunctionHandler *pH, const char *profile)
{
CActor *pActor = GetActor(pH);
if (!pActor)
return pH->EndFunction();
uint p = 0;
if (!stricmp(profile, "alive"))
p = eAP_Alive;
else if (!stricmp(profile, "unragdoll"))
p = eAP_NotPhysicalized;
else if (!stricmp(profile, "ragdoll"))
{
if (!pActor->GetLinkedVehicle())
p = eAP_Ragdoll;
else
p = eAP_Alive;
}
else if (!stricmp(profile, "spectator"))
p = eAP_Spectator;
else if (!stricmp(profile, "sleep"))
p = eAP_Sleep;
else if (!stricmp(profile, "frozen"))
p = eAP_Frozen;
else
return pH->EndFunction();
//Don't turn ragdoll while grabbed
if(p==eAP_Ragdoll && !pActor->CanRagDollize())
return pH->EndFunction();
pActor->GetGameObject()->SetAspectProfile(eEA_Physics, p);
return pH->EndFunction();
}
//------------------------------------------------------------------------
int CScriptBind_Actor::Fall(IFunctionHandler *pH, Vec3 hitPos)
{
CActor *pActor = GetActor(pH);
if (!pActor)
return pH->EndFunction();
// [Mikko] 11.10.2007 - Moved the check here, since it was causing too much trouble in CActor.Fall().
// The point of this filtering is to mostly mask out self-induced collision damage on friendly NPCs
// which are playing special animations.
if(!g_pGameCVars->g_enableFriendlyFallAndPlay)
{
if (IAnimatedCharacter* pAC = pActor->GetAnimatedCharacter())
{
if ((pAC->GetPhysicalColliderMode() == eColliderMode_NonPushable) ||
(pAC->GetPhysicalColliderMode() == eColliderMode_PushesPlayersOnly))
{
// Only mask for player friendly NPCs.
if (pActor->GetEntity() && pActor->GetEntity()->GetAI())
{
IAIObject* pAI = pActor->GetEntity()->GetAI();
IAIActor* pAIActor = pAI->CastToIAIActor();
if (pAIActor && pAIActor->GetParameters().m_nSpecies == 0)
{
return pH->EndFunction();
}
}
}
}
}
pActor->Fall(hitPos);
return pH->EndFunction();
}
//------------------------------------------------------------------------
int CScriptBind_Actor::GetSpectatorMode(IFunctionHandler *pH)
{
CActor *pActor = GetActor(pH);
if (!pActor)
return pH->EndFunction();
return pH->EndFunction(pActor->GetSpectatorMode());
}
int NFCAsyMysqlClusterModule::ApplyRequest(NF_SHARE_PTR<SMysqlParam> pParam)
{
NFIActorManager* pActorManager = pPluginManager->GetActorManager();
if (NULL == pActorManager)
{
return -1;
}
int nAcotrID = GetActor();
if (nAcotrID <= 0)
{
return -2;
}
std::string arg;
const int nEvetID = ACOTERMYSQLEVENT_USEDB;
if (!pParam->PackParam(arg))
{
return -3;
}
if (!mReqList.AddElement(pParam->nReqID, pParam))
{
return -4;
}
if (!pActorManager->SendMsgToActor(nAcotrID, pParam->self, nEvetID, arg))
{
mReqList.RemoveElement(pParam->nReqID);
return -5;
}
return 0;
}
//=========================================
bool CRocketLauncher::CanPickUp(EntityId userId) const
{
CActor *pActor = GetActor(userId);
IInventory *pInventory=GetActorInventory(pActor);
if (m_sharedparams->params.pickable && m_stats.pickable && !m_stats.flying && !m_frozen &&(!m_ownerId || m_ownerId==userId) && !m_stats.selected && !GetEntity()->IsHidden())
{
if (pInventory && pInventory->FindItem(GetEntityId())!=-1)
return false;
}
else
return false;
uint8 uniqueId = m_pItemSystem->GetItemUniqueId(GetEntity()->GetClass()->GetName());
//Can not pick up a LAW while I have one already
if(pInventory && (pInventory->GetCountOfUniqueId(uniqueId)>0))
{
if(pActor->IsClient())
g_pGame->GetGameRules()->OnTextMessage(eTextMessageCenter, "@mp_CannotCarryMoreLAW");
return false;
}
return true;
}
// RMI receiver in the server to remove all items from the inventory. changes are automatically propagated to the clients
IMPLEMENT_RMI(CInventory, SvReq_RemoveAllItems)
{
IItemSystem* pItemSystem = CCryAction::GetCryAction()->GetIItemSystem();
IItem* pItem = pItemSystem->GetItem( GetCurrentItem() );
if (pItem)
{
pItem->Select(false);
pItemSystem->SetActorItem( GetActor(), (EntityId)0, false );
}
Destroy();
if (gEnv->bMultiplayer)
{
TRMIInventory_Dummy Info;
GetGameObject()->InvokeRMI( Cl_RemoveAllAmmo(), Info, eRMI_ToAllClients);
}
else
{
ResetAmmo();
}
return true;
}
bool CHeavyMountedWeapon::CanUse(EntityId userId) const
{
EntityId ownerId = m_owner.GetId();
if (m_rippedOff)
{
CActor* pActor = GetActor(userId);
if (pActor && pActor->IsSwimming())
return false;
if (ownerId == 0 || ownerId == userId)
return true;
}
else if(IActor* pActor = gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(userId))
{
IItem* pItem = pActor->GetCurrentItem(false);
if(pItem)
{
if(pItem->IsBusy())
{
return false;
}
if(IWeapon* pWeapon = pItem->GetIWeapon())
{
if(pWeapon->IsReloading())
{
return false;
}
}
}
}
return BaseClass::CanUse(userId);
}
void WindowGlobalChild::HandleAsyncMessage(const nsString& aActorName,
const nsString& aMessageName,
StructuredCloneData& aData) {
if (NS_WARN_IF(mIPCClosed)) {
return;
}
// Force creation of the actor if it hasn't been created yet.
IgnoredErrorResult rv;
RefPtr<JSWindowActorChild> actor = GetActor(aActorName, rv);
if (NS_WARN_IF(rv.Failed())) {
return;
}
// Get the JSObject for the named actor.
JS::RootedObject obj(RootingCx(), actor->GetWrapper());
if (NS_WARN_IF(!obj)) {
// If we don't have a preserved wrapper, there won't be any receiver
// method to call.
return;
}
RefPtr<JSWindowActorService> actorSvc = JSWindowActorService::GetSingleton();
if (NS_WARN_IF(!actorSvc)) {
return;
}
actorSvc->ReceiveMessage(actor, obj, aMessageName, aData);
}
void consume::Terminate(bool Finished)
{
if(Flags & TERMINATING)
return;
Flags |= TERMINATING;
item* Consuming = game::SearchItem(ConsumingID);
character* Actor = GetActor();
if(Actor->IsPlayer())
ADD_MESSAGE("You %s %s.", Finished ? "finish" : "stop", Description.CStr());
else if(Actor->CanBeSeenByPlayer())
ADD_MESSAGE("%s %s %s.", Actor->CHAR_NAME(DEFINITE), Finished ? "finishes" : "stops", Description.CStr());
if(Finished)
{
if(Consuming->Exists() && !game::IsInWilderness() && (!Actor->IsPlayer() || ivanconfig::GetAutoDropLeftOvers()))
{
Consuming->RemoveFromSlot();
Actor->GetStackUnder()->AddItem(Consuming);
Actor->DexterityAction(2);
}
}
else if(Consuming && Consuming->Exists())
{
material* ConsumeMaterial = Consuming->GetConsumeMaterial(Actor);
if(ConsumeMaterial)
ConsumeMaterial->FinishConsuming(Actor);
}
action::Terminate(Finished);
}
void RemoteNetworkView::GenerateNewPositionActor(IEventDataPtr pEventData) {
char response[4];
std::string httpinmsg;
IEventDataPtr pResponseHttpEvent(CREATE_EVENT(EventData_ResponseHTTP::sk_EventType));
std::shared_ptr<EventData_GetNewPositionActor> pCastEventData = std::static_pointer_cast<EventData_GetNewPositionActor>(pEventData);
std::string name = pCastEventData->VGetActorName();
unsigned int ip = pCastEventData->VGetIp();
//look for actor data in actor manager by ip / actor name
StrongActorPtr pActor = m_ActorManager->GetActorByName(ip, name);
if (pActor == NULL) {
_itoa_s(http_response_code_t::NOTFOUND, response, 10);
httpinmsg.append(response);
std::istrstream in(httpinmsg.c_str(), httpinmsg.size());
pResponseHttpEvent->VDeserialize(in);
IEventManager::Get()->VTriggerEvent(pResponseHttpEvent);
return;
}
// calculate new coord random (great AI !)
int random = rand();
Vec3 newPosition;
newPosition.x = random % 512;
newPosition.y = random % 480;
newPosition.z = 0;
pActor->SetPosition(newPosition);
// send back all data
GetActor(pEventData);
}
int Game_Actor::GetBattleAnimationId() const {
if (Player::IsRPG2k()) {
return 0;
}
int anim = 0;
if (GetData().battler_animation <= 0) {
// Earlier versions of EasyRPG didn't save this value correctly
// The battle animation of the class only matters when the class was
// changed by event "Change Class"
if ((GetData().class_id > 0) && GetClass()) {
anim = GetClass()->battler_animation;
} else {
const RPG::BattlerAnimation* anima = ReaderUtil::GetElement(Data::battleranimations, GetActor().battler_animation);
if (!anima) {
Output::Warning("Actor %d: Invalid battle animation ID %d", GetId(), GetActor().battler_animation);
return 0;
}
anim = anima->ID;
}
} else {
anim = GetData().battler_animation;
}
if (anim == 0) {
// Chunk was missing, set to proper default
return 1;
}
return anim;
}
void AddAsActor2Listener()
{
CActor2* pActor = GetActor( m_smartObjectId );
if (pActor)
{
pActor->RegisterListener( this );
}
}
// RMI receiver in the server to add an item to the inventory. change is automatically propagated to the clients
IMPLEMENT_RMI(CInventory, SvReq_AddItem)
{
TRMIInventory_Item Info(params);
gEnv->pGame->GetIGameFramework()->GetIItemSystem()->GiveItem( GetActor(), Info.m_ItemClass.c_str(), false, true, true );
return true;
}
