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; }