void GCastle::ReceveAttack(gint32 iDamage) { if( mCastleStateFlag == eDestroy ) return; mCurrentHP -= iDamage; if( GetCurrentHP() <= 0 ) { mCastleStateFlag = eDestroy; SetCurrentState(); return; } else if( GetCurrentHP() < GetHP() / 2 ) { mCastleStateFlag = eBreak; SetCurrentState(); } GetCastleGege()->SetProgressPercent( (float)GetCurrentHP() / (float)GetHP() * 100.0f ); if( mIsDamage == false ) { mIsDamage = true; mpTopDamageEffect->SetVisible( true ); mpBottomDamageEffect->SetVisible( true ); GnTimeController::StartTimeControllers( mpTopDamageEffect ); GnTimeController::StartTimeControllers( mpBottomDamageEffect ); } }
void FCrashUpload::PostReportComplete() { if (PauseState == EUploadState::PostingReportComplete) { // Wait for confirmation SetCurrentState(EUploadState::WaitingToPostReportComplete); return; } AssignReportIdToPostDataBuffer(); auto Request = CreateHttpRequest(); Request->SetVerb( TEXT( "POST" ) ); Request->SetURL(UrlPrefix / TEXT("UploadComplete")); Request->SetHeader( TEXT( "Content-Type" ), TEXT( "text/plain; charset=us-ascii" ) ); Request->SetContent(PostData); UE_LOG( CrashReportClientLog, Log, TEXT( "Sending HTTP request: %s" ), *Request->GetURL() ); if (Request->ProcessRequest()) { SetCurrentState(EUploadState::PostingReportComplete); } else { CheckPendingReportsForFilesToUpload(); } }
//----------------------------------------------------------------------------- // Purpose: updates the building postion and checks the new postion //----------------------------------------------------------------------------- void CTFWeaponBuilder::UpdatePlacementState( void ) { // This updates the building position bool bValidPos = IsValidPlacement(); // If we're in placement mode, update the placement model switch( m_iBuildState ) { case BS_PLACING: case BS_PLACING_INVALID: { if ( bValidPos ) { SetCurrentState( BS_PLACING ); } else { SetCurrentState( BS_PLACING_INVALID ); } } break; default: break; } }
bool RoomLayoutCtrller::OnPostEvent( const irr::SEvent& evt ) { if ( evt.EventType == irr::EET_USER_EVENT ) { if ( evt.UserEvent.UserData1 == EUT_ROOMLAYOUT_DRAWLINE_FINISH ) { ::PostMessage((HWND)GetRenderContextSPtr()->GetHandle(), WM_IRR_DLG_MSG, WM_USER_ROOMLAYOUT_DRAWWALL_FINISH, 0); SetCurrentState(ERoomLayoutSatate::ERS_BROWSE); return true; } if ( evt.UserEvent.UserData1 == EUT_ROOMLAYOUT_PICTURE_FINISH ) { SetCurrentState(ERoomLayoutSatate::ERS_BROWSE); return true; } if ( evt.UserEvent.UserData1 == EUT_ROOMLAYOUT_DRAWWALL ) { SetCurrentState(ERoomLayoutSatate::ERS_DRAWING); } if ( evt.UserEvent.UserData1 == EUT_ROOMLAYOUT_PICTURE_ALPHA || evt.UserEvent.UserData1 == EUT_ROOMLAYOUT_PICTURE_VISIBLE || evt.UserEvent.UserData1 == EUT_ROOMLAYOUT_PICTURE_SETTING || evt.UserEvent.UserData1 == EUT_ROOMLAYOUT_PICTUREREFLINE_SIZE || evt.UserEvent.UserData1 == EUT_ROOMLAYOUT_PICTUREREFLINE_DRAW || evt.UserEvent.UserData1 == EUT_ROOMLAYOUT_PICTURE_POSITION) { SetCurrentState(ERoomLayoutSatate::ERS_PICTURE); } } return StatesController::OnPostEvent(evt); }
//----------------------------------------------------------------------------- // Purpose: Idle updates the position of the build placement model //----------------------------------------------------------------------------- void CWeaponBuilder::WeaponIdle( void ) { CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() ); if ( !pOwner ) return; // If we're in placement mode, update the placement model switch( m_iBuildState ) { case BS_PLACING: case BS_PLACING_INVALID: { if ( UpdatePlacement() ) { SetCurrentState( BS_PLACING ); } else { SetCurrentState( BS_PLACING_INVALID ); } } break; default: break; } if ( HasWeaponIdleTimeElapsed() ) { SendWeaponAnim( ACT_VM_IDLE ); } }
void AAssignment_1GameMode::Tick(float DeltaTime) { Super::Tick(DeltaTime); // Check that we using the Character AAssignment_1Character * MyCharacter = Cast<AAssignment_1Character>(UGameplayStatics::GetPlayerPawn(this, 0)); if (MyCharacter) { // If our power is greater than needed to win, Set the games state to won if (MyCharacter->GetCurrentPower() > PowerToWin) { SetCurrentState(EBatteryPlayState::EWon); } // If the character's power is positive else if (MyCharacter->GetCurrentPower() > 0.f) { // Decrease the Character's power using the decay rate MyCharacter->UpdatePower(-DeltaTime * DecayRate*(MyCharacter->GetInitialPower())); } else { SetCurrentState(EBatteryPlayState::EGameOver); } } }
void BallsManager::Update(float dt) { ClearDeadBalls(); timer.Update(dt); if (focus != nullptr) { attackHitbox.pos.x = focus->box.pos.x - 45; attackHitbox.pos.y = focus->box.pos.y - 70; attackHitbox.dim = Vec2(0, 0); if (currentState == BallsState::RESTING && timer.Get() >= REST_TIME) { currentState = BallsState::WARNING; timer.Restart(); SetCurrentState(WARNING); } else if (currentState == BallsState::WARNING && timer.Get() >= WARN_TIME) { currentState = BallsState::ATTACKING; timer.Restart(); SetCurrentState(ATTACKING); for (size_t i = 0; (i < ballArray.size()) && (focus != nullptr); i++) { Game::GetInstance()->GetCurrentState().AddObject(new Animation( ballArray[i]->box.pos, 0, "sprites/monsters/ball/BOLOTA_BLINK.png", 6, 0.02, true)); } } else if (currentState == BallsState::ATTACKING) { attackHitbox.dim = Vec2(220, 180); for (size_t i = 0; (i < ballArray.size()) && (focus != nullptr); i++) { float angle = 2 * M_PI * (i + 1) / ballArray.size(); Vec2 pos = Vec2(BALL_EVA_DISTANCE, 60); ballArray[i]->box.pos = Vec2(pos.x * cos(angle) - pos.y * sin(angle), pos.y * cos(angle) + pos.x * sin(angle)); Vec2 evaPos = focus->box.pos + Vec2(0, 70); evaPos.y -= focus->box.dim.y / 2; ballArray[i]->box.pos += evaPos; focus->TakeDamage(ballArray.size() * 1.5); } if (timer.Get() >= ATTACK_TIME) { currentState = BallsState::RESTING; RandTeleport(); timer.Restart(); SetCurrentState(RESTING); } } } else { currentState = BallsState::RESTING; SetCurrentState(RESTING); } }
AWeapon::AWeapon(const FObjectInitializer& ObjectInitializer) :Super(ObjectInitializer){ weaponMesh = ObjectInitializer.CreateDefaultSubobject<USkeletalMeshComponent>(this, TEXT("WeaponMesh")); weaponMesh->MeshComponentUpdateFlag = EMeshComponentUpdateFlag::OnlyTickPoseWhenRendered; weaponMesh->bChartDistanceFactor = true; weaponMesh->bReceivesDecals = false; weaponMesh->CastShadow = true; weaponMesh->SetCollisionObjectType(ECC_WorldDynamic); weaponMesh->SetCollisionEnabled(ECollisionEnabled::NoCollision); weaponMesh->SetCollisionResponseToAllChannels(ECR_Ignore); RootComponent = weaponMesh; bPlayingAttackAnim = false; SetEquiped(false); bWantsToAttack = false; bPendingEquip = false; SetCurrentState(EWeaponState::Idle); LastAttackTime = 0.0f; PrimaryActorTick.bCanEverTick = true; PrimaryActorTick.TickGroup = TG_PrePhysics; SetRemoteRoleForBackwardsCompat(ROLE_SimulatedProxy); bReplicates = true; //bReplicateInstigator = true; bNetUseOwnerRelevancy = true; }
void FCrashUpload::LocalDiagnosisComplete(const FString& DiagnosticsFile) { if (State >= EUploadState::FirstCompletedState) { // Must be a failure/cancelled state, or the report was a rejected by the server return; } bool SendDiagnosticsFile = !bDiagnosticsFileSent && !DiagnosticsFile.IsEmpty(); CRASHREPORTCLIENT_CHECK(PauseState == EUploadState::PostingReportComplete); PauseState = EUploadState::Finished; if (State == EUploadState::WaitingToPostReportComplete) { if (SendDiagnosticsFile) { PendingFiles.Push(DiagnosticsFile); SetCurrentState(EUploadState::SendingFiles); UploadNextFile(); } else { PostReportComplete(); } } else if (SendDiagnosticsFile) { PendingFiles.Push(DiagnosticsFile); } }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool CWeaponBuilder::CanDeploy( void ) { if ( m_iCurrentObject != BUILDER_INVALID_OBJECT ) { SetCurrentState( BS_PLACING ); StartPlacement(); m_flNextPrimaryAttack = gpGlobals->curtime + 0.35f; } else { m_hObjectBeingBuilt = NULL; SetCurrentState( BS_IDLE ); SetCurrentObject( m_iCurrentObject ); } return BaseClass::CanDeploy(); }
void Game::PauseGame() { if (m_pauseState) { SetCurrentState(m_pauseState); } }
static inline void enter_go_off_one_mode(void){ SetCurrentState(ECUM_STATE_GO_OFF_ONE); EcuM_OnGoOffOne(); /* @req EcuMf0008 Only set LIN to false when not going to sleep. * Kind a strange that COMM is deini on the next line. */ /* @req EcuMf0019 */ SetComMCommunicationAllowed(ONLY_LIN, FALSE); #if defined(USE_COMM) ComM_DeInit(); #endif #if defined(USE_BSWM) /* @req EcuMf0017 */ BswM_Deinit(); #endif #if defined(USE_NVM) // Start NvM_WriteAll and timeout timer NvM_WriteAll(); EcuM_World_go_off_one_state_timeout = EcuM_World.config->EcuMNvramWriteAllTimeout / ECUM_MAIN_FUNCTION_PERIOD; #endif }
cPlayerFSM::cPlayerFSM(cGameObject* _pOwner, cIState* _pState) { m_pOwner = _pOwner; SetGlobalState(new cPlayerState(_pState)); SetCurrentState(cIdleState::GetInstance()); m_pOwner->GetAction()->SetOwner(_pOwner); }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool CTFWeaponBuilder::Deploy( void ) { bool bDeploy = BaseClass::Deploy(); if ( bDeploy ) { SetCurrentState( BS_PLACING ); StartPlacement(); m_flNextPrimaryAttack = gpGlobals->curtime + 0.35f; m_flNextSecondaryAttack = gpGlobals->curtime; // asap CTFPlayer *pPlayer = ToTFPlayer( GetOwner() ); if (!pPlayer) return false; pPlayer->SetNextAttack( gpGlobals->curtime ); m_iWorldModelIndex = modelinfo->GetModelIndex( GetWorldModel() ); m_flNextDenySound = 0; // Set off the hint here, because we don't know until now if our building // is rotate-able or not. if ( m_hObjectBeingBuilt && !m_hObjectBeingBuilt->MustBeBuiltOnAttachmentPoint() ) { // set the alt-fire hint so it gets removed when we holster m_iAltFireHint = HINT_ALTFIRE_ROTATE_BUILDING; pPlayer->StartHintTimer( m_iAltFireHint ); } } return bDeploy; }
void CNetServiceBase::SerRun() { if (m_ListenPort == 0) { throw std::exception("port must be set"); } mIOCPMgr = new CIOCPManager(); mSerList = new CIOCPBaseList(mIOCPMgr); DOnIOCPBaseEvent iocp_event(this, reinterpret_cast<EOnIOCPBaseEvent>(&CNetServiceBase::IOCPEvent)); mSerList->SetIOCPEvent(iocp_event); mExitEvent = CreateEvent(NULL, TRUE, FALSE, NULL); mSockLst = new CSocketLst(); // 启动监听 if (mSockLst->StartListen(mSerList, m_ListenPort)) { // SetCurrentState(SERVICE_RUNNING); // 等待退出 WaitForSingleObject(mExitEvent, INFINITE); mSockLst->Close(); } else { OutputDebugStr(_T("启动监听失败!\n")); delete mSockLst; mSockLst = NULL; } CloseHandle(mExitEvent); delete mSerList; delete mIOCPMgr; mSerList = NULL; mIOCPMgr = NULL; }
DWORD CNetServiceBase::SerHandler(DWORD dwControl, DWORD dwEventType, LPVOID lpEventData) { // Handle the requested control code. switch (dwControl){ case SERVICE_CONTROL_STOP: case SERVICE_CONTROL_SHUTDOWN: // 关闭服务 OutputDebugStr(_T("服务端接收到关闭命令\n")); SetExitEvent(); break; case SERVICE_CONTROL_INTERROGATE: break; case SERVICE_CONTROL_PAUSE: break; case SERVICE_CONTROL_CONTINUE: break; // invalid control code default: // update the service status. SetCurrentState(GetCurrentState()); return ERROR_CALL_NOT_IMPLEMENTED; break; } return NO_ERROR; }
void ABatteryCollectorGameMode::BeginPlay() { Super::BeginPlay(); // find all spawn volume Actors TArray<AActor*> FoundActors; UGameplayStatics::GetAllActorsOfClass(GetWorld(), ASpawnVolume::StaticClass(), FoundActors); for (auto Actor : FoundActors) { ASpawnVolume* SpawnVolumeActor = Cast<ASpawnVolume>(Actor); if (SpawnVolumeActor) { SpawnVolumeActors.AddUnique(SpawnVolumeActor); } } SetCurrentState(EBatteryPlayState::EPlaying); ABatteryCollectorCharacter* MyCharacter = Cast<ABatteryCollectorCharacter>(UGameplayStatics::GetPlayerPawn(this, 0)); if (MyCharacter) { PowerToWin = (MyCharacter->GetInitialPower()) * 1.25f; } if (HUDWidgetClass != nullptr) { CurrentWidget = CreateWidget<UUserWidget>(GetWorld(), HUDWidgetClass); if (CurrentWidget != nullptr) { CurrentWidget->AddToViewport(); } } }
/** * RUN II entry * - Called from EcuM_StartupTwo() * - Called from * * */ void EcuM_enter_run_mode(void){ EcuM_OnEnterRun(); /** @req EcuMf2308 */ /* @req EcuMf0019 */ /* @req EcuMf0008 */ SetComMCommunicationAllowed(ALL, TRUE); /* * time we could leave the state before it has been completed. */ SetCurrentState(ECUM_STATE_APP_RUN); #if defined(USE_COMM) && (ECUM_AR_VERSION < 40000) /* !req EcuMf0027 * ECU in RUN state shall also perform wake up validation of sleeping busses */ { uint32 cMask = EcuM_World.run_comm_requests; uint8 channel; for (; cMask; cMask &= ~(1ul << channel)) { channel = ilog2(cMask); DEBUG_ECUM_CALLOUT_W_ARG("ComM_EcuM_RunModeIndication","%ld",(uint32)channel); ComM_EcuM_RunModeIndication(channel); } } #endif }
//----------------------------------------------------------------------------- // Purpose: Player holding this weapon has started building something //----------------------------------------------------------------------------- void CWeaponBuilder::StartBuilding( void ) { if ( m_hObjectBeingBuilt.Get() && UpdatePlacement() ) { SetCurrentState( BS_BUILDING ); m_hObjectBeingBuilt->StartBuilding( GetOwner() ); } }
void updateStatisticsFrame() { UIParent()->HideChildren(); if (GetGame().GetLevel().IsFailed() == true) { app()>SetCurrentState(AppState::Menu); } else if (GetGame().GetLevel().IsCompleted() = true) { if (GetGame().GetLevel().HasNext() == true) { GetGame().LoadLevel(GetGame().GetLevel().GetNext()); RestoreGameWindows(); } else { app()>SetCurrentState(AppState::Menu); } } else { GetGame().SetState(GameState::Level); RestoreGameWindows(); } }
void ABatteryCollectorGameMode::Tick(float DeltaTime) { Super::Tick(DeltaTime); ABatteryCollectorCharacter* MyCharacter = Cast<ABatteryCollectorCharacter>(UGameplayStatics::GetPlayerPawn(this, 0)); if (MyCharacter) { // If our power is greater than needed to win, set the game's state to Won if (MyCharacter->GetCurrentPower() > PowerToWin) { SetCurrentState(EBatteryPlayState::EWon); } else if (MyCharacter->GetCurrentPower() > 0) { MyCharacter->UpdatePower(-DeltaTime * DecayRate * (MyCharacter->GetInitialPower())); } else { SetCurrentState(EBatteryPlayState::EGameOver); } } }
void ABatteryCollectorGameMode::Tick(float DeltaTime) { Super::Tick(DeltaTime); ABatteryCollectorCharacter* myCharacter = Cast<ABatteryCollectorCharacter>(UGameplayStatics::GetPlayerPawn(this, 0)); if (myCharacter) { if ((myCharacter->GetCurrentPower()) > powerToWin) { SetCurrentState(EBatteryPlayState::EWon); } else if ((myCharacter->GetCurrentPower()) > 0) { myCharacter->UpdatePower(-DeltaTime * decayRate * (myCharacter->GetInitialPower())); } else { SetCurrentState(EBatteryPlayState::EGameOver); } } }
void FCrashUpload::CheckPendingReportsForFilesToUpload() { SetCurrentState(EUploadState::CheckingReport); do { if (PendingReportDirectories.Num() == 0) { // Nothing to upload UE_LOG(CrashReportClientLog, Log, TEXT("All uploads done")); SetCurrentState(EUploadState::Finished); return; } ErrorReport = FPlatformErrorReport(PendingReportDirectories.Pop()); PendingFiles = ErrorReport.GetFilesToUpload(); } while (PendingFiles.Num() == 0 || !SendCheckReportRequest()); }
//----------------------------------------------------------------------------- // Purpose: Stop placement when holstering //----------------------------------------------------------------------------- bool CTFWeaponBuilder::Holster( CBaseCombatWeapon *pSwitchingTo ) { if ( m_iBuildState == BS_PLACING || m_iBuildState == BS_PLACING_INVALID ) { SetCurrentState( BS_IDLE ); } StopPlacement(); return BaseClass::Holster(pSwitchingTo); }
void FCrashUpload::OnPingSuccess() { if (PauseState > EUploadState::Ready) { BeginUploadImpl(); } else { // Await instructions SetCurrentState(EUploadState::Ready); } }
//----------------------------------------------------------------------------- // Purpose: Player holding this weapon has aborted the build of an object //----------------------------------------------------------------------------- void CWeaponBuilder::StoppedBuilding( int iObjectType ) { CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() ); if ( pPlayer ) { // Force a recalculation of the state for this object SetCurrentObject( m_iCurrentObject ); SetCurrentState( BS_IDLE ); WeaponSound( SPECIAL2 ); } }
void AMaximumTopSpinGameState::PlayerDied(AMaximumTopSpinBall* DeadPlayer) { DeadPlayer->stats.Lives--; /** check remaining lives and respawn or remove */ if (DeadPlayer->stats.Lives == 0) ActivePlayerPawns.Remove(DeadPlayer); else DeadPlayer->Respawn(); //let the ball handle resetting its vars to respawn if (ActivePlayerPawns.Num() == 1) SetCurrentState(EMaximumTopSpinPlayState::EGameOver); }
//----------------------------------------------------------------------------- // Purpose: The player holding this weapon has just finished building an object //----------------------------------------------------------------------------- void CWeaponBuilder::FinishedObject( void ) { CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() ); if ( pPlayer ) { // We're no longer building anything... m_hObjectBeingBuilt = NULL; // Force a recalculation of the state for this object SetCurrentObject( m_iCurrentObject ); SetCurrentState( BS_IDLE ); } }
void RoomLayoutCtrller::Init() { //ÁÙġͼ AddController(ERoomLayoutSatate::ERS_PICTURE, std::make_shared<RoomLayoutPictureCtrller>(GraphODL_, GetRenderContextSPtr())); //»æÖÆ AddController(ERoomLayoutSatate::ERS_DRAWING, std::make_shared<RoomLayoutDrawingCtrller>(GraphODL_, GetRenderContextSPtr())); //ä¯ÀÀ AddController(ERoomLayoutSatate::ERS_BROWSE, std::make_shared<RoomLayoutBrowserCtrller>(GraphODL_, GetRenderContextSPtr())); //ĬÈÏ״̬ SetCurrentState(ERoomLayoutSatate::ERS_BROWSE); }
void AUETutorialGameMode::Tick(float DeltaSeconds) { AUETutorialCharacter * MyCharacter = Cast<AUETutorialCharacter>(UGameplayStatics::GetPlayerPawn(this, 0)); if (MyCharacter->PowerLevel > 1.0) { MyCharacter->PowerLevel = FMath::FInterpTo(MyCharacter->PowerLevel, 0.f, DeltaSeconds, DecayRate); } else { MyCharacter->PowerLevel = 0.0; SetCurrentState(EUETutorialGameModeState::EGameOver); } }