990 lines
28 KiB
Ucode
990 lines
28 KiB
Ucode
|
/**
|
||
|
|
* Copyright 1998-2013 Epic Games, Inc. All Rights Reserved.
|
||
|
|
*/
|
||
|
|
|
||
|
|
class CastlePC extends SimplePC;
|
||
|
|
|
||
|
|
/** Set to true to suppress the splash screen */
|
||
|
|
var config bool bSuppressSplash;
|
||
|
|
|
||
|
|
/** will be true once the splash screen has been shown */
|
||
|
|
var bool bSplashHasBeenShown;
|
||
|
|
|
||
|
|
/** If True then we are in attract mode */
|
||
|
|
var bool bIsInAttractMode;
|
||
|
|
|
||
|
|
/** If True then we are in benchmark mode */
|
||
|
|
var bool bIsInBenchmarkMode;
|
||
|
|
|
||
|
|
/** If True, then a full flythrough loop has been completed in benchmark mode */
|
||
|
|
var bool bBenchmarkLoopCompleted;
|
||
|
|
|
||
|
|
/** Track the number of frames and the elapsed time while in benchmark mode to get average frame rate */
|
||
|
|
var int BenchmarkNumFrames;
|
||
|
|
var float BenchmarkElapsedTime;
|
||
|
|
|
||
|
|
/** Have we triggered the initial fading out of the Controls Help Menu */
|
||
|
|
var bool bDoneInitialFade;
|
||
|
|
|
||
|
|
var MobileMenuPause PauseMenu; // The Pause menu
|
||
|
|
var MobileMenuDebug DebugMenu; // The Debug menu
|
||
|
|
|
||
|
|
var bool bPauseMenuOpen;
|
||
|
|
var bool bAutoSlide;
|
||
|
|
|
||
|
|
var float SliderStart, SliderEnd;
|
||
|
|
var float SliderTravelTime;
|
||
|
|
var float SliderTravelDuration;
|
||
|
|
|
||
|
|
var float AutoAttractTime;
|
||
|
|
|
||
|
|
var SoundCue OpenMenuSound;
|
||
|
|
var SoundCue CloseMenuSound;
|
||
|
|
|
||
|
|
var MobileMenuControls TutMenu;
|
||
|
|
|
||
|
|
|
||
|
|
/*************************************
|
||
|
|
Tap to Move
|
||
|
|
************************************/
|
||
|
|
|
||
|
|
/** How far the player must have moved within the last 0.5 seconds before we consider them 'stuck' and
|
||
|
|
abort automatic movement */
|
||
|
|
var float StuckThreshHold;
|
||
|
|
|
||
|
|
/** Scalar that sets how much the camera should pitch up and down to match the tap-to-move target */
|
||
|
|
var float TapToMoveAutoPitchAmount;
|
||
|
|
|
||
|
|
/** Mesh to use for 'tap to move' visual cue in the world */
|
||
|
|
var StaticMesh TapToMoveVisualMesh;
|
||
|
|
|
||
|
|
/** Minimum distance from destination before visual cue will vanish */
|
||
|
|
var float TapToMoveVisualMinDist;
|
||
|
|
|
||
|
|
/** How fast the visual cue should rotate every frame */
|
||
|
|
var float TapToMoveVisualRotateSpeed;
|
||
|
|
|
||
|
|
/** Length of visual cue animation effect */
|
||
|
|
var float TapToMoveVisualAnimDuration;
|
||
|
|
|
||
|
|
/** Holds the destination we are moving towards */
|
||
|
|
var vector TapToMoveDestination;
|
||
|
|
|
||
|
|
/** We use this to see if we are stuck */
|
||
|
|
var float LastDistToDestination;
|
||
|
|
|
||
|
|
/** Time that tap to move visual effect started */
|
||
|
|
var float TapToMoveVisualEffectStartTime;
|
||
|
|
|
||
|
|
/** Time that tap to move visual effect ended */
|
||
|
|
var float TapToMoveVisualEffectEndTime;
|
||
|
|
|
||
|
|
var SoundCue TapToMoveSound;
|
||
|
|
var SoundCue InvalidTapToMoveSound;
|
||
|
|
var SoundCue TapToMoveStopSound;
|
||
|
|
|
||
|
|
/** Spawned actor for 'tap to move' visual cue */
|
||
|
|
var KActorSpawnable TapToMoveVisualActor;
|
||
|
|
|
||
|
|
/*************************************
|
||
|
|
Tutorial
|
||
|
|
************************************/
|
||
|
|
|
||
|
|
enum ETutorialStage
|
||
|
|
{
|
||
|
|
ETS_None,
|
||
|
|
ETS_Tap,
|
||
|
|
ETS_Swipe,
|
||
|
|
ETS_Sticks,
|
||
|
|
ETS_Done,
|
||
|
|
};
|
||
|
|
|
||
|
|
var ETutorialStage TutorialStage;
|
||
|
|
|
||
|
|
/** Cached reference to the Tutorial Look Zone */
|
||
|
|
var MobileInputzone TutorialLookZone;
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Setup the in world indicator for tap to move and some other subsystems
|
||
|
|
*/
|
||
|
|
simulated function PostBeginPlay()
|
||
|
|
{
|
||
|
|
Super.PostBeginPlay();
|
||
|
|
|
||
|
|
// Kill existing 'tap to move' actor, if any
|
||
|
|
if( TapToMoveVisualActor != None )
|
||
|
|
{
|
||
|
|
TapToMoveVisualActor.Destroy();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Spawn our 'tap to move' visual cue actor
|
||
|
|
TapToMoveVisualActor = Spawn( class'KActorSpawnable',self,,,,,true);
|
||
|
|
TapToMoveVisualActor.SetCollision( false, false, true ); // Disable collision
|
||
|
|
TapToMoveVisualActor.SetHidden( true );
|
||
|
|
TapToMoveVisualActor.SetDrawScale3D( vect( 1, 1, 5 ) );
|
||
|
|
TapToMoveVisualActor.StaticMeshComponent.SetStaticMesh( TapToMoveVisualMesh );
|
||
|
|
TapToMoveVisualActor.SetPhysics( PHYS_None );
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Make sure we destory the visual tap actor
|
||
|
|
*/
|
||
|
|
event Destroyed()
|
||
|
|
{
|
||
|
|
// Kill existing 'tap to move' actor, if any
|
||
|
|
if( TapToMoveVisualActor != None )
|
||
|
|
{
|
||
|
|
TapToMoveVisualActor.Destroy();
|
||
|
|
}
|
||
|
|
|
||
|
|
super.Destroyed();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* An event that is called after the first tick of GEngine. We are going to hijack this for
|
||
|
|
* initialization purposes.
|
||
|
|
*/
|
||
|
|
event OnEngineInitialTick()
|
||
|
|
{
|
||
|
|
// If we are in preview mode, then skip the flyby, splash and tutorial
|
||
|
|
if (WorldInfo.IsPlayInPreview() || WorldInfo.IsPlayInEditor())
|
||
|
|
{
|
||
|
|
// Setup some of the default states
|
||
|
|
TutorialStage = ETS_Done;
|
||
|
|
ActivateControlGroup();
|
||
|
|
ResetMenu();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// trigger Epic Citadel map stuff (see Kismet in EpicCitadel map)
|
||
|
|
CauseEvent('IntroCam');
|
||
|
|
ConsoleCommand("mobile playsong town_render");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The main purpose of this function is to size and reset zones. There's a lot of specific code in
|
||
|
|
* here to reposition zones based on if it's an phone vs pad.
|
||
|
|
*/
|
||
|
|
function SetupZones()
|
||
|
|
{
|
||
|
|
local MobileInputZone Zone;
|
||
|
|
local float Ratio;
|
||
|
|
|
||
|
|
Super.SetupZones();
|
||
|
|
|
||
|
|
// If we have a game class, configure the zones
|
||
|
|
if (MPI != None && WorldInfo.GRI.GameClass != none)
|
||
|
|
{
|
||
|
|
// Find the button zone that exits attract mode.
|
||
|
|
Zone = MPI.FindZone("ExitAttractModeZone");
|
||
|
|
if (Zone != none)
|
||
|
|
{
|
||
|
|
Zone.OnTapDelegate = ExitAttractTap;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Find the tap to move zone and setup the tutorial
|
||
|
|
Zone = MPI.FindZone("TapTutorialZone");
|
||
|
|
if (Zone != none)
|
||
|
|
{
|
||
|
|
Zone.OnTapDelegate = TapToMoveTap;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
`log("!!!WARNING!!! Tutorial will be broken due to Tap");
|
||
|
|
}
|
||
|
|
|
||
|
|
// Find the look zone and setup the tutorial
|
||
|
|
TutorialLookZone = MPI.FindZone("SwipeTutorialZone");
|
||
|
|
if (TutorialLookZone == none)
|
||
|
|
{
|
||
|
|
`log("!!!WARNING!!! Tutorial will be broken due to Swipe");
|
||
|
|
}
|
||
|
|
|
||
|
|
// If we aren't supressing the splash screen, setup the pause menu
|
||
|
|
if (!bSuppressSplash)
|
||
|
|
{
|
||
|
|
PauseMenu = MobileMenuPause(MPI.OpenMenuScene(class'MobileMenuPause'));
|
||
|
|
SliderZone = MPI.FindZone("MenuSlider");
|
||
|
|
if (SliderZone != none)
|
||
|
|
{
|
||
|
|
SliderZone.OnTapDelegate = MenuSliderTap;
|
||
|
|
SliderZone.OnProcessSlide = ProcessMenuSlide;
|
||
|
|
SliderZone.SizeY = PauseMenu.Height;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
Ratio = ViewportSize.Y / ViewportSize.X;
|
||
|
|
|
||
|
|
// Find the zone and hook up the delegate so we can perform tap to move
|
||
|
|
Zone = MPI.FindZone("TapToMoveZone");
|
||
|
|
if (Zone != none)
|
||
|
|
{
|
||
|
|
Zone.OnTapDelegate = TapToMoveTap;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (FreeLookZone != none)
|
||
|
|
{
|
||
|
|
FreeLookZone.OnTapDelegate = TapToMoveTap;
|
||
|
|
if (Ratio == 0.75 || ViewportSize.X <= 480)
|
||
|
|
{
|
||
|
|
FreeLookZone.VertMultiplier *= 1.75;
|
||
|
|
FreeLookZone.HorizMultiplier *= 3.25;
|
||
|
|
FreeLookZone.Acceleration *= 0.5;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Setup the timer to check for inactivity / attract mode
|
||
|
|
//SetTimer(1.0,true,'CheckInactivity');
|
||
|
|
|
||
|
|
// Setup a timer that will write out controller stats every 60 seconds.
|
||
|
|
SetTimer(60.0,true,'SaveControllerStats');
|
||
|
|
|
||
|
|
// Activate the input group for the flyby (ie: no input)
|
||
|
|
if (MPI != none)
|
||
|
|
{
|
||
|
|
MPI.ActivateInputGroup("InitialFlybyGroup");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Saves out the controller stats for processing
|
||
|
|
*/
|
||
|
|
function SaveControllerStats()
|
||
|
|
{
|
||
|
|
if ((StickLookZone != none) && (StickMoveZone != none) && (FreeLookZone != none))
|
||
|
|
{
|
||
|
|
ConsoleCommand("mobile recordcontrolstats" @ StickMoveZone.TotalActiveTime @ StickLookZone.TotalActiveTime @ FreeLookZone.TotalActiveTime @ TotalTimeInTapToMove @ NoTapToMoves);
|
||
|
|
|
||
|
|
StickMoveZone.TotalActiveTime = 0;
|
||
|
|
StickLookZone.TotalActiveTime = 0;
|
||
|
|
FreeLookZone.TotalActiveTime = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
TotalTimeInTapToMove = 0;
|
||
|
|
NoTapToMoves = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Every second, we look at various metrics to see if the player has been active. If they haven't been, then
|
||
|
|
* we want switch to attract mode
|
||
|
|
*/
|
||
|
|
function CheckInactivity()
|
||
|
|
{
|
||
|
|
// Quick out if we don't allow attract mode
|
||
|
|
if (CastleGame(WorldInfo.Game) == none || CastleGame(WorldInfo.Game).bAllowAttractMode == false)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//if the pause menu is open, or a submenu is open
|
||
|
|
if ( LocalPlayer(Player).ViewportClient.bDisableWorldRendering || (PauseMenu != none && bPauseMenuOpen) || bIsInAttractMode || bCinematicMode || (MPI.MobileMenuStack.Length>1 && TutMenu == none))
|
||
|
|
{
|
||
|
|
MPI.MobileInactiveTime = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Make the call...
|
||
|
|
if (MPI.MobileInactiveTime > AutoAttractTime && !bIsInAttractMode && !bCinematicMode)
|
||
|
|
{
|
||
|
|
EnterAttractMode();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Trace, but ignore volumes and triggers unless they are blockers (i.e. BlockingVolume)
|
||
|
|
*
|
||
|
|
* @param TraceOwner is the player's pawn
|
||
|
|
* @param HitLocation holds the location were the trace ends
|
||
|
|
* @param HitNormal holds the orientation of the surface normal where it hit
|
||
|
|
* @param End is where we would like the trace to end
|
||
|
|
* @param Start is where the trace is starting from
|
||
|
|
*/
|
||
|
|
simulated function Actor TraceForTapToMove(Pawn TraceOwner, out vector HitLocation, out vector HitNormal, vector End, vector Start)
|
||
|
|
{
|
||
|
|
local Actor HitActor;
|
||
|
|
local vector HitLoc, HitNorm;
|
||
|
|
local TraceHitInfo HitInfo;
|
||
|
|
|
||
|
|
// Iterate over each actor along trace...
|
||
|
|
foreach TraceOwner.TraceActors(class'Actor', HitActor, HitLoc, HitNorm, End, Start, , HitInfo,TRACEFLAG_Bullet)
|
||
|
|
{
|
||
|
|
// if it's not a trigger or a volume, use it!
|
||
|
|
if ( (HitActor.bBlockActors || HitActor.bWorldGeometry) && (Volume(HitActor) == None && Trigger(HitActor)==None))
|
||
|
|
{
|
||
|
|
HitLocation = HitLoc;
|
||
|
|
HitNormal =HitNorm;
|
||
|
|
return HitActor;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Found nothing non-volume or -trigger like :(
|
||
|
|
return None;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This is our event handler for taps.
|
||
|
|
*
|
||
|
|
* @param Zone The Zone we are managing
|
||
|
|
* @param EventType The type of event that occurred
|
||
|
|
* @param TouchLocation Where was the touch
|
||
|
|
*/
|
||
|
|
function bool TapToMoveTap(MobileInputZone Zone, ETouchType EventType, Vector2D TouchLocation)
|
||
|
|
{
|
||
|
|
local Vector2D RelLocation;
|
||
|
|
local Vector Origin, Direction, Destination;
|
||
|
|
local Vector HitLocation, HitNormal;
|
||
|
|
local Actor HitActor;
|
||
|
|
local bool bWantReverse;
|
||
|
|
local bool bValidDestination;
|
||
|
|
|
||
|
|
// Don't perform these traces if if are in attract mode, playing a cinematic or if the movement stick is
|
||
|
|
// currently active.
|
||
|
|
if( !bIsInAttractMode && !bCinematicMode && StickMoveZone.State == ZoneState_Inactive )
|
||
|
|
{
|
||
|
|
// Figure out the location relative to the current viewport
|
||
|
|
RelLocation.X = TouchLocation.X / ViewportSize.X;
|
||
|
|
RelLocation.Y = TouchLocation.Y / ViewportSize.Y;
|
||
|
|
|
||
|
|
// Check to see if the user touched near the very bottom of the viewport
|
||
|
|
bWantReverse = false; //( RelLocation.Y >= 0.85 );
|
||
|
|
|
||
|
|
// If the user clicked near the bottom of the viewport and is already moving toward a destination,
|
||
|
|
// then cancel the movement in progress. Basically, clicking near the bottom of the viewport is
|
||
|
|
// used to stop moving.
|
||
|
|
if( bWantReverse && IsInState('PlayerTapToMove') )
|
||
|
|
{
|
||
|
|
// Draw an effect on the HUD
|
||
|
|
MobileHudExt( MyHud ).StartTapToMoveEffect( TouchLocation.X, TouchLocation.Y );
|
||
|
|
|
||
|
|
// Play a 'move stopped' sound effect
|
||
|
|
PlaySound( TapToMoveStopSound );
|
||
|
|
|
||
|
|
// Cancel touch to move
|
||
|
|
GotoState('PlayerWalking');
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
NoTapToMoves++;
|
||
|
|
|
||
|
|
// If we're reversing then flip the touch point along the horizontal axis so we'll walk backwards
|
||
|
|
// in the expected direction
|
||
|
|
if( bWantReverse )
|
||
|
|
{
|
||
|
|
RelLocation.x = 1.0 - RelLocation.x;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Deproject and get the world location
|
||
|
|
LocalPlayer(Player).Deproject(RelLocation, Origin, Direction);
|
||
|
|
|
||
|
|
// If we're reversing then choose a location behind the player a little bit
|
||
|
|
if( bWantReverse )
|
||
|
|
{
|
||
|
|
Direction.Z = 0.0f;
|
||
|
|
Destination = Origin - Direction * 512;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Moving forward, so cast a way straight out far into the scene
|
||
|
|
Destination = Origin + (Direction * 10240);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Now trace in to the world and get where to go.
|
||
|
|
HitActor = TraceForTapToMove(Pawn, HitLocation, HitNormal, Destination, Origin);
|
||
|
|
if (HitActor != none)
|
||
|
|
{
|
||
|
|
Destination = HitLocation + (HitNormal * Pawn.GetCollisionHeight() * 2);
|
||
|
|
}
|
||
|
|
if (!PointReachable(Destination))
|
||
|
|
{
|
||
|
|
// Still not reachable. Then find the ground and see if we can move there.
|
||
|
|
Origin = Destination;
|
||
|
|
Destination.Z = -65535;
|
||
|
|
|
||
|
|
HitActor = TraceForTapToMove(Pawn, HitLocation, HitNormal, Destination, Origin);
|
||
|
|
if (HitActor != none)
|
||
|
|
{
|
||
|
|
// We hit the ground, step back the collision Height;
|
||
|
|
Destination = HitLocation;
|
||
|
|
Destination.Z += Pawn.GetCollisionHeight();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unless we're reversing, if the desired location is somehow behind the player then fail the movement
|
||
|
|
if( bWantReverse )
|
||
|
|
{
|
||
|
|
bValidDestination = true;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
bValidDestination = ( ( Normal( Destination - Pawn.Location ) dot Vector( Pawn.Rotation ) ) > 0.25 );
|
||
|
|
}
|
||
|
|
|
||
|
|
// If the desired location is very close to the player then fail the movement
|
||
|
|
if( ( VSize2D( Destination - Pawn.Location ) < 128.0 ) )
|
||
|
|
{
|
||
|
|
bValidDestination = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
if( bValidDestination )
|
||
|
|
{
|
||
|
|
// Play a 'move succeeded' sound effect
|
||
|
|
PlaySound( TapToMoveSound );
|
||
|
|
|
||
|
|
// Draw an effect on the HUD
|
||
|
|
MobileHudExt( MyHud ).StartTapToMoveEffect( TouchLocation.X, TouchLocation.Y );
|
||
|
|
|
||
|
|
// Start moving to the new destination!
|
||
|
|
DoTapToMove( Destination, !bWantReverse ); // Don't auto-look at destination when reversing
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Play a 'move failed' sound effect
|
||
|
|
PlaySound( InvalidTapToMoveSound );
|
||
|
|
|
||
|
|
// Cancel an existing tap-to-move action, if there is one in progress
|
||
|
|
if( IsInState('PlayerTapToMove') )
|
||
|
|
{
|
||
|
|
GotoState('PlayerWalking');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The player has clicked on a spot. Start the move
|
||
|
|
*
|
||
|
|
* @param NewDestination Where do we want to move to
|
||
|
|
* @param bShouldLookAtDestination True if we should also automatically look toward the destination
|
||
|
|
*/
|
||
|
|
function DoTapToMove( vector NewDestination, bool bShouldLookAtDestination )
|
||
|
|
{
|
||
|
|
// Update position of tap to move visual cue
|
||
|
|
TapToMoveVisualActor.SetLocation( NewDestination + vect( 0, 0, 6 ) ); // Raise up a bit
|
||
|
|
TapToMoveVisualActor.SetHidden( false );
|
||
|
|
TapToMoveVisualEffectStartTime = WorldInfo.RealTimeSeconds;
|
||
|
|
|
||
|
|
TapToMoveDestination = NewDestination;
|
||
|
|
LastDistToDestination = VSize(Pawn.Location - TapToMoveDestination);
|
||
|
|
|
||
|
|
if( bShouldLookAtDestination )
|
||
|
|
{
|
||
|
|
// Start automatically orientating toward the target point
|
||
|
|
PlayerLookAtDestination();
|
||
|
|
}
|
||
|
|
|
||
|
|
GotoState('PlayerTapToMove');
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Initialize the look at system to point to the destination.
|
||
|
|
*/
|
||
|
|
function PlayerLookAtDestination()
|
||
|
|
{
|
||
|
|
if( !bLookAtDestination )
|
||
|
|
{
|
||
|
|
// Start rotating!
|
||
|
|
bLookAtDestination = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Reset the time of last view change so that we're guaranteed to start looking toward the destination,
|
||
|
|
// even if the user dragged the view right before touching to move
|
||
|
|
TimeOfLastUserViewChange = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Tap to Move requires it's own special state for the player controller
|
||
|
|
*/
|
||
|
|
state PlayerTapToMove
|
||
|
|
{
|
||
|
|
/**
|
||
|
|
* Setup the auto-rotate towards the destination
|
||
|
|
*/
|
||
|
|
event BeginState(Name PreviousStateName)
|
||
|
|
{
|
||
|
|
Super.BeginState(PreviousStateName);
|
||
|
|
LastEnteredTapToMove = WorldInfo.RealTimeSeconds;
|
||
|
|
|
||
|
|
// If we are in the tutorial, skip to the next step
|
||
|
|
if (TutorialStage == ETS_Tap)
|
||
|
|
{
|
||
|
|
TutMenu.FadeOut();
|
||
|
|
TutMenu = MobileMenuControls(MPI.OpenMenuScene(class'UDKBase.MobileMenuControls'));
|
||
|
|
TutMenu.Setup(false);
|
||
|
|
MPI.ActivateInputGroup("SwipeTutorialGroup");
|
||
|
|
TutorialStage = ETS_Swipe;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Close everything down.
|
||
|
|
*/
|
||
|
|
event EndState(Name NextStateName)
|
||
|
|
{
|
||
|
|
// Track Stats
|
||
|
|
TotalTimeInTapToMove += WorldInfo.RealTimeSeconds - LastEnteredTapToMove;
|
||
|
|
|
||
|
|
Super.EndState(NextStateName);
|
||
|
|
|
||
|
|
// Turn off the check to see if we are stuck
|
||
|
|
Cleartimer('CheckIfStuck');
|
||
|
|
|
||
|
|
// Stop automatically orientating toward the target point
|
||
|
|
bLookAtDestination = false;
|
||
|
|
|
||
|
|
// Start hiding the visual cue if we haven't already
|
||
|
|
if( TapToMoveVisualEffectEndTime < TapToMoveVisualEffectStartTime )
|
||
|
|
{
|
||
|
|
TapToMoveVisualEffectEndTime = WorldInfo.RealTimeSeconds;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Check to see if the player is stuck. This is called every 1/2 second. It just looks to see if you have most past a threshold since
|
||
|
|
* the last check and if not, considers you stuck.
|
||
|
|
*
|
||
|
|
* We also use this event to determine if enough time has passed that we should start auto-rotating again
|
||
|
|
*/
|
||
|
|
event CheckIfStuck()
|
||
|
|
{
|
||
|
|
local Float DistToDestination;
|
||
|
|
|
||
|
|
DistToDestination = VSize(Pawn.Location - TapToMoveDestination);
|
||
|
|
if (LastDistToDestination - DistToDestination < StuckThreshHold)
|
||
|
|
{
|
||
|
|
GotoState('PlayerWalking');
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
LastDistToDestination = DistToDestination;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Each frame, look to see if the player has decided to use the virtual stick to move. If they have,
|
||
|
|
* we want to abort tap to move.
|
||
|
|
*/
|
||
|
|
function PlayerTick(float DeltaTime)
|
||
|
|
{
|
||
|
|
|
||
|
|
if (IsStickMoveActive())
|
||
|
|
{
|
||
|
|
GotoState('PlayerWalking');
|
||
|
|
}
|
||
|
|
Global.PlayerTick(DeltaTime);
|
||
|
|
}
|
||
|
|
|
||
|
|
Begin:
|
||
|
|
// Check to see if we're not making progress every so often
|
||
|
|
SetTimer( 0.5, true, 'CheckIfStuck' );
|
||
|
|
|
||
|
|
// while we have a valid pawn and move target, and
|
||
|
|
// we haven't reached the target yet
|
||
|
|
while (Pawn != None && !Pawn.ReachedPoint(TapToMoveDestination,none))
|
||
|
|
{
|
||
|
|
MoveToDirectNonPathPos(TapToMoveDestination,,1,true);
|
||
|
|
}
|
||
|
|
|
||
|
|
GotoState('PlayerWalking');
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Called from PlayerMove, it's here that we adjust the viewport
|
||
|
|
*/
|
||
|
|
function ProcessViewRotation( float DeltaTime, out Rotator out_ViewRotation, Rotator DeltaRot )
|
||
|
|
{
|
||
|
|
local float AnimProgress;
|
||
|
|
local vector NewDrawScale;
|
||
|
|
|
||
|
|
// If we are looking at a desintation, preset it for the super to manage
|
||
|
|
if( bLookAtDestination )
|
||
|
|
{
|
||
|
|
LookAtDestination = TapToMoveDestination - Pawn.Location;
|
||
|
|
LookAtDestAutoPitchAmount = TapToMoveAutoPitchAmount;
|
||
|
|
}
|
||
|
|
|
||
|
|
Super.ProcessViewRotation( DeltaTime, out_ViewRotation, DeltaRot);
|
||
|
|
|
||
|
|
// Animate the tap-to-move visual cue
|
||
|
|
if( TapToMoveVisualEffectEndTime < TapToMoveVisualEffectStartTime )
|
||
|
|
{
|
||
|
|
// We're fading in!
|
||
|
|
AnimProgress = 1.0 - FMin( ( WorldInfo.RealTimeSeconds - TapToMoveVisualEffectStartTime ) / TapToMoveVisualAnimDuration, 1.0 );
|
||
|
|
AnimProgress = FInterpEaseInOut( 0.0, 1.0, AnimProgress, 1.5 );
|
||
|
|
|
||
|
|
TapToMoveVisualActor.SetRotation( TapToMoveVisualActor.Rotation + MakeRotator( 0, DeltaTime * ( TapToMoveVisualRotateSpeed + 8.0 * AnimProgress * TapToMoveVisualRotateSpeed ), 0 ) );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// We're fading out!
|
||
|
|
AnimProgress = FMin( ( WorldInfo.RealTimeSeconds - TapToMoveVisualEffectEndTime ) / TapToMoveVisualAnimDuration, 1.0 );
|
||
|
|
AnimProgress = FInterpEaseInOut( 0.0, 1.0, AnimProgress, 1.5 );
|
||
|
|
|
||
|
|
TapToMoveVisualActor.SetRotation( TapToMoveVisualActor.Rotation + MakeRotator( 0, DeltaTime * ( 1.0 - AnimProgress ) * TapToMoveVisualRotateSpeed, 0 ) );
|
||
|
|
|
||
|
|
if( AnimProgress >= 1.0 )
|
||
|
|
{
|
||
|
|
// Hide the actor now that we're finished transitioning
|
||
|
|
TapToMoveVisualActor.SetHidden( true );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
NewDrawScale.X = 1.0 - AnimProgress * 1.0; // Squash to zero from normal size
|
||
|
|
NewDrawScale.Y = 1.0 + AnimProgress * 0.5; // Grow to slightly bigger size
|
||
|
|
NewDrawScale.Z = 1.25 - AnimProgress * 1.25; // Squash to zero from bigger size
|
||
|
|
TapToMoveVisualActor.SetDrawScale3D( NewDrawScale );
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* If we're very close to the target, then go ahead and hide the visual cue
|
||
|
|
*/
|
||
|
|
simulated function CheckDistanceToDestination(float DistToDestination)
|
||
|
|
{
|
||
|
|
|
||
|
|
if( DistToDestination < TapToMoveVisualMinDist )
|
||
|
|
{
|
||
|
|
if( TapToMoveVisualEffectEndTime < TapToMoveVisualEffectStartTime )
|
||
|
|
{
|
||
|
|
TapToMoveVisualEffectEndTime = WorldInfo.RealTimeSeconds;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* notification when a matinee director track starts or stops controlling the ViewTarget of this PlayerController
|
||
|
|
*
|
||
|
|
* @param bNowControlling will be true if we are back in control
|
||
|
|
*/
|
||
|
|
event NotifyDirectorControl(bool bNowControlling, SeqAct_Interp CurrentMatinee)
|
||
|
|
{
|
||
|
|
super.NotifyDirectorControl(bNowControlling, CurrentMatinee);
|
||
|
|
if( bNowControlling )
|
||
|
|
{
|
||
|
|
// Make sure our tap-to-move actor is hidden
|
||
|
|
TapToMoveVisualActor.SetHidden( true );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Enter attrack mode. We need to make sure we kill any active menus/etc.
|
||
|
|
*/
|
||
|
|
exec function EnterAttractMode( bool BeginBenchmarking = false )
|
||
|
|
{
|
||
|
|
// Make sure we're not currently auto-moving to a destination
|
||
|
|
if( IsInState('PlayerTapToMove') )
|
||
|
|
{
|
||
|
|
GotoState('PlayerWalking');
|
||
|
|
}
|
||
|
|
|
||
|
|
// Kill the tutorial menu
|
||
|
|
if (TutMenu != none)
|
||
|
|
{
|
||
|
|
TutMenu.FadeOut();
|
||
|
|
TutMenu = none;
|
||
|
|
MPI.ActivateInputGroup("UberGroup");
|
||
|
|
MobileHudExt(myHUD).FlashSticks();
|
||
|
|
TutorialStage = ETS_Done;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Hide the on screen help if it's there
|
||
|
|
if (PauseMenu != none)
|
||
|
|
{
|
||
|
|
PauseMenu.ReleaseHelp();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Go in to attract mode
|
||
|
|
CauseEvent('PlayMatinee');
|
||
|
|
bIsInAttractMode = true;
|
||
|
|
|
||
|
|
bIsInBenchmarkMode = BeginBenchmarking;
|
||
|
|
bBenchmarkLoopCompleted = false;
|
||
|
|
BenchmarkNumFrames = 0;
|
||
|
|
BenchmarkElapsedTime = 0.0;
|
||
|
|
|
||
|
|
ResetMenu();
|
||
|
|
MPI.ActivateInputGroup("AttractGroup");
|
||
|
|
}
|
||
|
|
|
||
|
|
exec function OnFlyThroughLoopCompleted()
|
||
|
|
{
|
||
|
|
// Set the benchmark loop completed flag so that we can calculate and display the results of the benchmark fly through
|
||
|
|
bBenchmarkLoopCompleted = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Leave attract mode
|
||
|
|
*/
|
||
|
|
exec function ExitAttractMode()
|
||
|
|
{
|
||
|
|
if (bIsInBenchmarkMode)
|
||
|
|
{
|
||
|
|
PauseMenu.InputOwner.Outer.ConsoleCommand("mobile benchmark end");
|
||
|
|
}
|
||
|
|
bIsInAttractMode = false;
|
||
|
|
bIsInBenchmarkMode = false;
|
||
|
|
bBenchmarkLoopCompleted = false;
|
||
|
|
MPI.MobileInactiveTime = 0;
|
||
|
|
CauseEvent('StopMatinee');
|
||
|
|
ActivateControlGroup();
|
||
|
|
ResetMenu();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Delegate that gets called when the exit attact mode button is tapped
|
||
|
|
*/
|
||
|
|
function bool ExitAttractTap(MobileInputZone Zone, ETouchType EventType, Vector2D TouchLocation)
|
||
|
|
{
|
||
|
|
ExitAttractMode();
|
||
|
|
PauseMenu.SetDefaultUI(); // set the correct UI
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Automatically slide to a new location
|
||
|
|
*/
|
||
|
|
function AutoSlide(float Destination)
|
||
|
|
{
|
||
|
|
SliderStart = SliderZone.CurrentLocation.Y;
|
||
|
|
SliderEnd = Destination;
|
||
|
|
SliderTravelTime = 0;
|
||
|
|
bAutoSlide = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Reset the pause menu
|
||
|
|
*/
|
||
|
|
function ResetMenu()
|
||
|
|
{
|
||
|
|
if (bPauseMenuOpen)
|
||
|
|
{
|
||
|
|
PauseMenu.OnResetMenu();
|
||
|
|
AutoSlide(SliderZone.Y);
|
||
|
|
bPauseMenuOpen = false;
|
||
|
|
PlaySound( CloseMenuSound );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Force the Pause Menu to open
|
||
|
|
*/
|
||
|
|
function OpenMenu()
|
||
|
|
{
|
||
|
|
if (!bPauseMenuOpen)
|
||
|
|
{
|
||
|
|
bPauseMenuOpen = true;
|
||
|
|
AutoSlide(PauseMenu.ShownSize);
|
||
|
|
PlaySound( OpenMenuSound );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Depending on the state of the pause menu, a tap on it's nub will either auto-open or auto-close it.
|
||
|
|
* This delegate manages the tap.
|
||
|
|
*/
|
||
|
|
function bool MenuSliderTap(MobileInputZone Zone, ETouchType EventType, Vector2D TouchLocation)
|
||
|
|
{
|
||
|
|
if (bPauseMenuOpen)
|
||
|
|
{
|
||
|
|
ResetMenu();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
OpenMenu();
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* When you touch and drag on the nub, this code determines what to do.
|
||
|
|
*/
|
||
|
|
function bool ProcessMenuSlide(MobileInputZone Zone, ETouchType EventType, int SlideValue, Vector2D ViewportSizes)
|
||
|
|
{
|
||
|
|
// Align the menu to the touch.
|
||
|
|
PauseMenu.Top = Zone.CurrentLocation.Y - PauseMenu.Height;
|
||
|
|
// somehow the zone size is being reset (on device, but not PC), so this just fixes it. mildly hacky, but no real penalty.
|
||
|
|
Zone.SizeY = PauseMenu.Height;
|
||
|
|
|
||
|
|
// If we are releasing the menu, see if we need to reset, or if we need to open
|
||
|
|
if (EventType == Touch_Ended && !bPauseMenuOpen)
|
||
|
|
{
|
||
|
|
if (Zone.CurrentLocation.Y >= PauseMenu.ShownSize)
|
||
|
|
{
|
||
|
|
OpenMenu();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
AutoSlide(SliderZone.Y);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Handle any animations and time criticl code
|
||
|
|
*/
|
||
|
|
function PlayerTick(float DeltaTime)
|
||
|
|
{
|
||
|
|
local int SettingsLocationX;
|
||
|
|
|
||
|
|
Super.PlayerTick(DeltaTime);
|
||
|
|
|
||
|
|
if (TutorialStage == ETS_Swipe)
|
||
|
|
{
|
||
|
|
if (TutorialLookZone.State != ZoneState_Inactive)
|
||
|
|
{
|
||
|
|
TutMenu.FadeOut();
|
||
|
|
TutMenu = none;
|
||
|
|
MPI.ActivateInputGroup("UberGroup");
|
||
|
|
MobileHudExt(myHUD).FlashSticks();
|
||
|
|
TutorialStage = ETS_Done;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Trigger the fading of the Controls Help screen that we bring up on map load
|
||
|
|
if ( !bDoneInitialFade )
|
||
|
|
{
|
||
|
|
// @todo: Disabled this for intermediate demo; Consider re-enabling later.
|
||
|
|
// PauseMenu.FadeOutControlsMenu();
|
||
|
|
bDoneInitialFade = TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Handle the menu sliding back in to place
|
||
|
|
if (bAutoSlide)
|
||
|
|
{
|
||
|
|
SliderZone.CurrentLocation.Y = FInterpEaseInOut(SliderStart,SliderEnd, SliderTravelTime/SliderTravelDuration,3.0);
|
||
|
|
SliderTravelTime += DeltaTime;
|
||
|
|
if (SliderTravelTime >= SliderTravelDuration)
|
||
|
|
{
|
||
|
|
SliderZone.CurrentLocation.Y = SliderEnd;
|
||
|
|
bAutoSlide = false;
|
||
|
|
|
||
|
|
if (!bPauseMenuOpen)
|
||
|
|
{
|
||
|
|
if (bIsInAttractMode)
|
||
|
|
{
|
||
|
|
PauseMenu.SetAttractModeUI(bIsInBenchmarkMode);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
PauseMenu.SetDefaultUI();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
PauseMenu.Top = SliderZone.CurrentLocation.Y - PauseMenu.Height;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Only pull out the settings menu if it's available (only Android)
|
||
|
|
if (PauseMenu.MenuObjects.length >= 5)
|
||
|
|
{
|
||
|
|
SettingsLocationX = FInterpEaseInOut(MyHUD.SizeX, PauseMenu.Width - PauseMenu.MenuObjects[4].Width + 2, FClamp(SliderZone.CurrentLocation.Y / (PauseMenu.ShownSize - SliderZone.Y), 0.0, 1.0), 3.0);
|
||
|
|
PauseMenu.MenuObjects[4].Left = SettingsLocationX;
|
||
|
|
}
|
||
|
|
|
||
|
|
// If we are currently benchmarking, track the number of frames and elapsed time.
|
||
|
|
// Note that this assumes a TimeDilation of 1.0 and doesn't properly handle the cases where DeltaTime is clamped because it was super long or super short, but in EpicCitadel benchmark mode these shouldn't be problems in practice.
|
||
|
|
if( bIsInBenchmarkMode && !bBenchmarkLoopCompleted )
|
||
|
|
{
|
||
|
|
BenchmarkNumFrames += 1;
|
||
|
|
BenchmarkElapsedTime += DeltaTime;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Show the splash screen
|
||
|
|
*/
|
||
|
|
exec function ShowSplash()
|
||
|
|
{
|
||
|
|
// Activate the tutorial input group then show the splash
|
||
|
|
MPI.ActivateInputGroup("TapTutorialGroup");
|
||
|
|
if (!bSplashHasBeenShown && !bSuppressSplash && MPI != none)
|
||
|
|
{
|
||
|
|
bSplashHasBeenShown = true;
|
||
|
|
MPI.OpenMenuScene(class'UDKBase.MobileMenuSplash');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Display the control help on the screen
|
||
|
|
*/
|
||
|
|
exec function FlashHelp(float Duration)
|
||
|
|
{
|
||
|
|
if (!bPauseMenuOpen)
|
||
|
|
{
|
||
|
|
PauseMenu.FlashHelp(Duration);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Start the tutorials
|
||
|
|
*/
|
||
|
|
function StartTutorials()
|
||
|
|
{
|
||
|
|
TutMenu = MobileMenuControls(MPI.OpenMenuScene(class'UDKBase.MobileMenuControls'));
|
||
|
|
TutMenu.Setup(true);
|
||
|
|
TutorialStage = ETS_Tap;
|
||
|
|
}
|
||
|
|
|
||
|
|
exec function SetFootstepsToStone()
|
||
|
|
{
|
||
|
|
FootstepSounds[0]=SoundCue'CastleAudio.Player.Footstep_Walk_01_Cue';
|
||
|
|
FootstepSounds[1]=SoundCue'CastleAudio.Player.Footstep_Walk_02_Cue';
|
||
|
|
FootstepSounds[2]=SoundCue'CastleAudio.Player.Footstep_Walk_03_Cue';
|
||
|
|
FootstepSounds[3]=SoundCue'CastleAudio.Player.Footstep_Walk_04_Cue';
|
||
|
|
FootstepSounds[4]=SoundCue'CastleAudio.Player.Footstep_Walk_05_Cue';
|
||
|
|
FootstepSounds[5]=SoundCue'CastleAudio.Player.Footstep_Walk_06_Cue';
|
||
|
|
}
|
||
|
|
|
||
|
|
exec function SetFootstepsToSnow()
|
||
|
|
{
|
||
|
|
FootstepSounds[0]=SoundCue'CastleAudio.Player.Footstep_Snow01_Cue';
|
||
|
|
FootstepSounds[1]=SoundCue'CastleAudio.Player.Footstep_Snow02_Cue';
|
||
|
|
FootstepSounds[2]=SoundCue'CastleAudio.Player.Footstep_Snow03_Cue';
|
||
|
|
FootstepSounds[3]=SoundCue'CastleAudio.Player.Footstep_Snow04_Cue';
|
||
|
|
FootstepSounds[4]=SoundCue'CastleAudio.Player.Footstep_Snow05_Cue';
|
||
|
|
FootstepSounds[5]=SoundCue'CastleAudio.Player.Footstep_Snow06_Cue';
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
defaultproperties
|
||
|
|
{
|
||
|
|
StuckThreshHold=25
|
||
|
|
TapToMoveAutoPitchAmount=0.25
|
||
|
|
TapToMoveVisualMesh=StaticMesh'CastleEffects.TouchToMoveArrow'
|
||
|
|
TapToMoveVisualMinDist=230
|
||
|
|
TapToMoveVisualRotateSpeed=100000
|
||
|
|
TapToMoveVisualAnimDuration=0.3
|
||
|
|
|
||
|
|
AutoAttractTime=45
|
||
|
|
TapToMoveSound=SoundCue'CastleAudio.UI.UI_TouchToMove_Cue'
|
||
|
|
InvalidTapToMoveSound=SoundCue'CastleAudio.UI.UI_InvalidTouchToMove_Cue'
|
||
|
|
TapToMoveStopSound=SoundCue'CastleAudio.UI.UI_StopTouchToMove_Cue'
|
||
|
|
OpenMenuSound=SoundCue'CastleAudio.UI.UI_MainMenu_Cue'
|
||
|
|
CloseMenuSound=SoundCue'CastleAudio.UI.UI_OK_Cue'
|
||
|
|
bSplashHasBeenShown=false
|
||
|
|
|
||
|
|
SliderTravelDuration=0.3
|
||
|
|
TutorialStage=ETS_None
|
||
|
|
|
||
|
|
FootstepSounds(0)=SoundCue'CastleAudio.Player.Footstep_Walk_01_Cue'
|
||
|
|
FootstepSounds(1)=SoundCue'CastleAudio.Player.Footstep_Walk_02_Cue'
|
||
|
|
FootstepSounds(2)=SoundCue'CastleAudio.Player.Footstep_Walk_03_Cue'
|
||
|
|
FootstepSounds(3)=SoundCue'CastleAudio.Player.Footstep_Walk_04_Cue'
|
||
|
|
FootstepSounds(4)=SoundCue'CastleAudio.Player.Footstep_Walk_05_Cue'
|
||
|
|
FootstepSounds(5)=SoundCue'CastleAudio.Player.Footstep_Walk_06_Cue'
|
||
|
|
}
|