void CWeaponKnife::OnAnimationEnd(u32 state)
{
switch (state)
{
case eHiding: SwitchState(eHidden); break;
case eFire:
case eFire2:
{
if(m_attackStart)
{
m_attackStart = false;
if(GetState()==eFire)
m_pHUD->animPlay(random_anim(mhud_attack_e), TRUE, this, GetState());
else
m_pHUD->animPlay(random_anim(mhud_attack2_e), TRUE, this, GetState());
Fvector p1, d;
p1.set(get_LastFP());
d.set(get_LastFD());
if(H_Parent())
smart_cast<CEntity*>(H_Parent())->g_fireParams(this, p1,d);
else break;
KnifeStrike(p1,d);
}
else
SwitchState(eIdle);
}break;
case eShowing:
case eIdle:
SwitchState(eIdle); break;
}
}
void CElevatorState::UpdateStNone()
{
VERIFY(m_ladder&&m_character);
Fvector d;m_ladder->DToPlain(m_character,d);
if(m_ladder->BeforeLadder(m_character)&&m_ladder->InTouch(m_character)&&dXZDotNormalized(d,m_character->CamDir())>look_angle_cosine)
{
if(ClimbDirection()>0.f)
{
SwitchState(clbClimbingUp);
}
else
{
SwitchState(clbClimbingDown);
}
}
else
{
Fvector temp;
float d_to_lower=m_ladder->DDLowerP(m_character,temp),d_to_upper=m_ladder->DDUpperP(m_character,temp);
if(d_to_lower<d_to_upper)
{
if(getting_on_dist+m_character->FootRadius() > d_to_lower)
SwitchState(clbNearDown);
}
else
{
if(getting_on_dist+m_character->FootRadius() > d_to_upper)
SwitchState(clbNearUp);
}
}
}
void CElevatorState::UpdateStClimbingDown()
{
VERIFY(m_ladder&&m_character);
Fvector d;
if(ClimbDirection()>0.f&&m_ladder->BeforeLadder(m_character))
SwitchState(clbClimbingUp);
float to_ax=m_ladder->DDToAxis(m_character,d);
Fvector ca;ca.set(m_character->ControlAccel());
float control_a=to_mag_and_dir(ca);
if(!fis_zero(to_ax)&&!fis_zero(control_a)&&abs(-ca.dotproduct(Fvector(m_ladder->Norm()).normalize()))<M_SQRT1_2)SwitchState(clbDepart);
if(m_ladder->AxDistToLowerP(m_character)-m_character->FootRadius()<stop_climbing_dist)
SwitchState(clbNearDown);
UpdateClimbingCommon(d,to_ax,ca,control_a);
if(m_ladder->AxDistToUpperP(m_character)<-m_character->FootRadius())SwitchState(clbNoLadder);
Fvector vel;
m_character->GetVelocity(vel);
if(vel.y>EPS_S)
{
m_character->ApplyForce(0.f,-m_character->Mass()*ph_world->Gravity(),0.f);
}
//if(to_ax-m_character->FootRadius()>out_dist)
// SwitchState((clbNone));
//if(fis_zero(control_a))
// m_character->ApplyForce(d,m_character->Mass());
}
bool CWeaponMagazined::TryReload()
{
if (m_pCurrentInventory)
{
if (TryToGetAmmo(m_ammoType) || unlimited_ammo() || (IsMisfire() && iAmmoElapsed))
{
m_bPending = true;
SwitchState(eReload);
return true;
}
for (u32 i = 0; i < m_ammoTypes.size(); ++i)
{
if (TryToGetAmmo(i))
{
m_ammoType = i;
m_bPending = true;
SwitchState(eReload);
return true;
}
}
}
SwitchState(eIdle);
return false;
}
void CArtefact::OnAnimationEnd(u32 state)
{
switch (state)
{
case eHiding:
{
SwitchState(eHidden);
}break;
case eShowing:
{
SwitchState(eIdle);
}break;
case eActivating:
{
if(Local())
{
SwitchState (eHiding);
NET_Packet P;
u_EventGen (P, GEG_PLAYER_ACTIVATEARTEFACT, H_Parent()->ID());
P.w_u16 (ID());
u_EventSend (P);
}
}break;
};
}
void CArtefact::OnAnimationEnd (u32 state)
{
switch (state)
{
case eHiding:
{
SwitchState(eHidden);
//. if(m_pInventory->GetNextActiveSlot()!=NO_ACTIVE_SLOT)
//. m_pInventory->Activate(m_pInventory->GetPrevActiveSlot());
}break;
case eShowing:
{
SwitchState(eIdle);
}break;
case eActivating:
{
if(Local()){
SwitchState (eHiding);
NET_Packet P;
u_EventGen (P, GEG_PLAYER_ACTIVATEARTEFACT, H_Parent()->ID());
P.w_u16 (ID());
u_EventSend (P);
}
}break;
};
}
void CWeaponMagazined::OnAnimationEnd(u32 state)
{
switch (state)
{
case eReload: ReloadMagazine(); SwitchState(eIdle); break; // End of reload animation
case eHiding: SwitchState(eHidden); break; // End of Hide
case eShowing: SwitchState(eIdle); break; // End of Show
case eIdle: switch2_Idle(); break; // Keep showing idle
}
}
void CArtefact::OnHiddenItem ()
{
if(IsGameTypeSingle())
SwitchState(eHiding);
else
SwitchState(eHidden);
inherited::OnHiddenItem ();
SetState (eHidden);
SetNextState (eHidden);
}
void CElevatorState::UpdateStNearDown()
{
VERIFY(m_ladder&&m_character);
Fvector d;
float dist=m_ladder->DDLowerP(m_character,d);
if( m_ladder->InTouch(m_character)&&
dXZDotNormalized(d,m_character->CamDir())>look_angle_cosine&&
d.dotproduct(m_character->ControlAccel())>0.f&&
ClimbDirection()>0.f&&
m_ladder->BeforeLadder(m_character)
)SwitchState(clbClimbingUp);
if(dist-m_character->FootRadius()>out_dist)SwitchState((clbNoLadder));
}
void CWeapon::OnHiddenItem ()
{
m_BriefInfo_CalcFrame = 0;
if(IsGameTypeSingle())
SwitchState(eHiding);
else
SwitchState(eHidden);
OnZoomOut();
inherited::OnHiddenItem ();
m_set_next_ammoType_on_reload = undefined_ammo_type;
}
void ButtonWidget::OnMouseUnfocusEvent(MouseEvent me)
{
if (m_currentState == UI_STATE_DISABLED)
return;
if (me.m_mouseEventType == LEFT_BUTTON_UP) { // Not on the button, released
SwitchState(UI_STATE_DEFAULT);
}
if (me.m_mouseEventType == MOVED && m_currentState != UI_STATE_PRESSED) { //Not on the button, moved
SwitchState(UI_STATE_DEFAULT);
}
WidgetBase::OnMouseUnfocusEvent(me);
}
void CWeaponKnife::OnAnimationEnd(u32 state)
{
switch (state)
{
case eHiding: SwitchState(eHidden); break;
case eFire:
case eFire2: SwitchState(eIdle); break;
case eShowing:
case eIdle: SwitchState(eIdle); break;
default: inherited::OnAnimationEnd(state);
}
}
//-------------------------------------------------------------------
void StateManager::Update (Engine& engine, uint millisecond)
{
if( m_isJustSwitch )
{
m_isJustSwitch = false;
millisecond = 17;
}
if( m_isLoadResouce )
{
m_isLoadResouce = false;
m_isJustSwitch = true;
m_lStateList.begin()->m_pStatePtr->LoadResource(engine);
m_lStateList.begin()->m_pStatePtr->OnEnter(engine, m_ePreviousState );
m_isShowLoading = false;
m_pLoading->SetShow(false);
engine.GetActionManager()->SetResponse(true);//开始保存按键buffer
}
if ( !m_lStateList.empty() )
{
m_lStateList.begin()->m_pStatePtr->Update(*this,engine, millisecond);
}
if( true == m_isSwitchState)
{
SwitchState(engine);
}
}
void CElevatorState::Deactivate()
{
SwitchState(clbNoLadder);
m_state=clbNoLadder;
m_ladder=NULL;
m_character=NULL;
}
void CElevatorState::UpdateStNearUp()
{
VERIFY(m_ladder&&m_character);
Fvector d;
if( m_ladder->InTouch(m_character) &&
m_character->CamDir().y<-M_PI/20.f &&
//d.dotproduct(m_character->ControlAccel())<0.f&&
//ClimbDirection()<0.f&&
m_ladder->DDToPlain(m_character,d)>m_character->FootRadius()/3.f&&
m_ladder->BeforeLadder(m_character,0.1f)
)
SwitchState(clbClimbingDown);
float dist=m_ladder->DDUpperP(m_character,d);
if(dist-m_character->FootRadius()>out_dist)SwitchState((clbNoLadder));
}
void GameApplication::OnStartLevel(std::shared_ptr<IEventData> eventData)
{
std::shared_ptr<Event_StartLevel> pEvent = std::dynamic_pointer_cast<Event_StartLevel>(eventData);
if (pEvent)
{
// remove current list of actors
for (auto it = m_Actors.begin(); it != m_Actors.end(); ++it)
{
m_Physics->RemoveActor(it->second->GetID());
m_Scene->RemoveChild(it->second->GetID());
it->second->Destroy();
}
m_Actors.clear();
m_ImportantActors.clear();
m_Physics->RemoveQueuedItems();
m_Physics->Reset();
m_Audio->StopAll();
m_Scene->Clear();
m_EventManager->Clear();
ResourceManager::GetInstance()->LoadLevel(m_Scene, pEvent->GetLevelPath().c_str());
m_Scene->Initialize();
m_GameTime = 0.0f;
m_PhysicsTime = 0.0f;
SwitchState(GameState::GAME_INTRO);
}
}
bool CWeaponMagazinedWGrenade::Action(s32 cmd, u32 flags)
{
if(m_bGrenadeMode && cmd==kWPN_FIRE)
{
if(IsPending())
return false;
if(flags&CMD_START)
{
if(iAmmoElapsed)
LaunchGrenade ();
else
Reload ();
if(GetState() == eIdle)
OnEmptyClick ();
}
return true;
}
if(inherited::Action(cmd, flags))
return true;
switch(cmd)
{
case kWPN_FUNC:
{
if(flags&CMD_START && !IsPending())
SwitchState(eSwitch);
return true;
}
}
return false;
}
void CArtefact::OnActiveItem ()
{
SwitchState (eShowing);
inherited::OnActiveItem ();
SetState (eIdle);
SetNextState (eIdle);
}
void CGrenade::OnAnimationEnd(u32 state)
{
switch(state)
{
case eThrowEnd: SwitchState(eHidden); break;
default : inherited::OnAnimationEnd(state);
}
}
void CCustomDetector::OnAnimationEnd(u32 state)
{
inherited::OnAnimationEnd (state);
switch(state)
{
case eShowing:
{
SwitchState (eIdle);
} break;
case eHiding:
{
SwitchState (eHidden);
TurnDetectorInternal (false);
g_player_hud->detach_item (this);
} break;
}
}
void Do()
{
Proc();
bool ok = Completed();
if (!ok ) return;
SwitchState( m_pNextState );
}
void CGrenade::OnAnimationEnd(u32 state)
{
switch(state){
case MS_END: SwitchState(MS_HIDDEN); break;
//. case MS_END: SwitchState(MS_RESTORE); break;
default : inherited::OnAnimationEnd(state);
}
}
//! called during the update of the entity
void DefenderManager::Update()
{
auto coolDown = GSETTINGS->m_DefenderManagerSettings->m_Cooldown;
// update cool down
if (m_CooldownTimer > 0.0f)
{
float angle = ((coolDown - m_CooldownTimer) / coolDown) * Math::PITimes2;
m_CooldownTimer -= g_fDeltaTime;
if (m_CooldownTimer <= 0.0f)
{
angle = Math::PITimes2 + .1f;
m_CooldownTimer = -1.0f;
m_CallDownButton->SetUIEnabled(true);
m_CallDownButton->GetChildByName("Halo")->SetVisibleAndEnabled(true);
}
m_CooldownShader->GetConstant("uCurrentAngle")->Set(&angle, 1);
}
switch(m_State)
{
case S_Spawning:
UpdateSpawning();
break;
case S_Defending:
if (m_CooldownTimer < (coolDown - GSETTINGS->m_DefenderManagerSettings->m_PullBackTreshold))
SwitchState(S_PullBack);
break;
case S_PullBack:
m_DiseappearTimer -= g_fDeltaTime;
if (m_CooldownTimer < 0.0f || m_DiseappearTimer < 0.0f)
{
for (auto defender : m_lDefenders)
{
if (defender.IsValid())
defender->GetParent()->RemoveChild(defender);
}
m_lDefenders.clear();
SwitchState(S_Ready);
}
break;
}
}
void CWeapon::UpdateCL ()
{
inherited::UpdateCL ();
UpdateHUDAddonsVisibility();
//подсветка от выстрела
UpdateLight ();
//нарисовать партиклы
UpdateFlameParticles ();
UpdateFlameParticles2 ();
if(!IsGameTypeSingle())
make_Interpolation ();
if( (GetNextState()==GetState()) && IsGameTypeSingle() && H_Parent()==Level().CurrentEntity())
{
CActor* pActor = smart_cast<CActor*>(H_Parent());
if(pActor && !pActor->AnyMove() && this==pActor->inventory().ActiveItem())
{
if (hud_adj_mode==0 &&
GetState()==eIdle &&
(Device.dwTimeGlobal-m_dw_curr_substate_time>20000) &&
!IsZoomed()&&
g_player_hud->attached_item(1)==NULL)
{
if(AllowBore())
SwitchState (eBore);
ResetSubStateTime ();
}
}
}
if(m_zoom_params.m_pNight_vision && !need_renderable())
{
if(!m_zoom_params.m_pNight_vision->IsActive())
{
CActor *pA = smart_cast<CActor *>(H_Parent());
R_ASSERT(pA);
CTorch* pTorch = smart_cast<CTorch*>( pA->inventory().ItemFromSlot(TORCH_SLOT) );
if ( pTorch && pTorch->GetNightVisionStatus() )
{
m_bRememberActorNVisnStatus = pTorch->GetNightVisionStatus();
pTorch->SwitchNightVision(false, false);
}
m_zoom_params.m_pNight_vision->Start(m_zoom_params.m_sUseZoomPostprocess, pA, false);
}
}
else if(m_bRememberActorNVisnStatus)
{
m_bRememberActorNVisnStatus = false;
EnableActorNVisnAfterZoom();
}
if(m_zoom_params.m_pVision)
m_zoom_params.m_pVision->Update();
}
void DefenderManager::UpdateSpawning()
{
if(m_WaveTimer < 0.0f)
{
auto angleStep = 90.0f / (GSETTINGS->m_DefenderManagerSettings->m_SpotsPerQuarter + 1);
for(int i=0; i<4; ++i)
{
auto angleStart = 90.0f*i;
auto angleEnd = 90.0f*(i+1);
for (int j = 0; j < GSETTINGS->m_DefenderManagerSettings->m_CountPerWavePerQuarter; ++j)
{
auto spawnAngle = angleStart + angleStep*(m_RandomSpots.GetNext()+1);
auto spawnDir = Vector3::Create(Math::Cos(spawnAngle*Math::DegToRadFactor), Math::Sin(spawnAngle*Math::DegToRadFactor), 0.0f);
auto pos = spawnDir * GSETTINGS->m_DefenderManagerSettings->m_Radius;
auto range = GSETTINGS->m_DefenderManagerSettings->m_AngleRange;
auto angle = Random::GetFloat(-range, range);
auto dir = (-spawnDir).Rotate(Vector3::Up, angle * Math::DegToRadFactor);
// Spawn actor
auto newActor = static_cast<Defender*>(m_PreloadedActor->Copy());
AddChild(newActor);
newActor->SetPosition(pos);
newActor->LookAt(dir);
newActor->SwitchState(Defender::S_Hover);
newActor->InitActor(GSETTINGS->m_DefenderSettings);
m_lDefenders.push_back(newActor);
}
}
m_WaveTimer = GSETTINGS->m_DefenderManagerSettings->m_WaveFrequency;
}
else
m_WaveTimer -= g_fDeltaTime;
if (m_SpawnTimer < 0.0f)
{
SwitchState(S_Defending);
auto camera = EntityRenderer::Instance()->Get3DCamera();
if (camera == FOLLOWCAM)
FOLLOWCAM->OnDefendersSpawned();
}
else
m_SpawnTimer -= g_fDeltaTime;
}
//! Initializes the state table
void MarioFSM::Init()
{
AddState(new MarioStateIdle(), State_Idle);
AddState(new MarioStateRunning(), State_Running);
AddState(new MarioStatePrepareJump(), State_PrepareJump);
AddState(new MarioStateFlying(), State_Flying);
SwitchState(State_Idle);
}
void CWeaponMagazined::state_Misfire(float /**dt/**/)
{
OnEmptyClick();
SwitchState(eIdle);
bMisfire = true;
UpdateSounds();
}
//------------------------------------------------------------------------------------------------------------------------
bool CCustomAction::AbortAction()
{
if (m_currentState == CAS_Started) // Can only abort when starting, not in succeeded state
{
return SwitchState(CAS_Aborted, CAE_Aborted, "CustomAction:Abort", "OnCustomActionAbort");
}
return false;
}
void CElevatorState::SetElevator(CClimableObject* climable)
{
Fvector d;
float dist=climable->DDToAxis(m_character,d);
if(m_ladder==climable||dist>out_dist) return;
if(m_ladder && m_ladder->DDToAxis(m_character,d)<dist) return;
SwitchState(clbNone);
m_ladder=climable;
}
//------------------------------------------------------------------------------------------------------------------------
bool CCustomAction::EndActionFailure()
{
bool bSwitched = SwitchState(CAS_Ended, CAE_EndedFailure, NULL, "OnCustomActionEndFailure"); // NULL since not firing up another custom action node
if (bSwitched)
{
m_listeners.Clear();
}
return bSwitched;
}
