/// <summary>
/// Sets the transition to the specified state, using ScreenShaderTransition.TransitionState.VALUE
/// </summary>
/// <param name="newState">New state.</param>
public void SetTransitionState(TransitionState newState)
{
transitionState = newState;
switch (newState)
{
case TransitionState.FADE_IN:
curFade = 1;
m_transitionInProgress = true;
break;
case TransitionState.ON:
curFade = 1;
m_transitionInProgress = false;
break;
case TransitionState.FADE_OUT:
curFade = 0;
m_transitionInProgress = true;
break;
case TransitionState.OFF:
curFade = 0;
m_transitionInProgress = false;
break;
}
}
public void Update(GameTime gameTime)
{
float elapsedSeconds = (float)gameTime.ElapsedGameTime.TotalSeconds;
switch (State)
{
case TransitionState.Out:
_currentSeconds += elapsedSeconds;
if (_currentSeconds >= _halfDuration)
{
State = TransitionState.In;
StateChanged?.Invoke(this, EventArgs.Empty);
}
break;
case TransitionState.In:
_currentSeconds -= elapsedSeconds;
if (_currentSeconds <= 0.0f)
{
Completed?.Invoke(this, EventArgs.Empty);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private void Start()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(gameObject);
}
MovementSM = new StateMachine();
Standing = new StandingState(this, MovementSM);
Fly = new FlyState(this, MovementSM);
Swing = new SwingState(this, MovementSM);
Create = new CreateState(this, MovementSM);
Transition = new TransitionState(this, MovementSM);
ActivCube = CubePrefabs[0];
MovementSM.Initialize(Create);
Platform = GameObject.FindGameObjectWithTag("Platform");
LastBlock = Platform;
}
public void ShouldExitTimeout()
{
var cut = RenderComponent <Component.Transition>(parameters =>
parameters
.Add(c => c.In, true)
.Add(c => c.Timeout, 100)
.Add(c => c.ChildContent, (RenderFragment <ITransitionContext>)((context) => (__builder) =>
{
__builder.OpenElement(1, "div");
__builder.CloseElement();
}))
);
IElement div = cut.Find("div");
TransitionState state = cut.Instance.Current;
Assert.Equal(TransitionState.Entered, state);
Assert.NotNull(div);
bool onExitCalled = false;
bool onExitingCalled = false;
bool onExitedCalled = false;
List <string> ordereds = new List <string>();
cut.SetParametersAndRender(parameters => parameters
.Add(c => c.In, false)
.Add(c => c.OnExit, (f) => {
onExitCalled = true;
ordereds.Add("OnExit");
})
.Add(c => c.OnExiting, (f) => {
onExitingCalled = true;
ordereds.Add("OnExiting");
})
.Add(c => c.OnExited, (f) => {
onExitedCalled = true;
ordereds.Add("OnExited");
})
);
cut.WaitForState(() => onExitedCalled, TimeSpan.FromMilliseconds(311));
Assert.True(onExitCalled);
Assert.True(onExitingCalled);
Assert.True(onExitedCalled);
Assert.Equal(3, ordereds.Count);
Assert.Equal("OnExit", ordereds[0]);
Assert.Equal("OnExiting", ordereds[1]);
Assert.Equal("OnExited", ordereds[2]);
TransitionState newstate = cut.Instance.Current;
Assert.Equal(TransitionState.Exited, newstate);
}
/// <summary>
/// Updates any transition logic of the current transition.
/// </summary>
/// <param name="state">The current transition state.</param>
public void updateTransitions(TransitionState state)
{
switch (state)
{
case TransitionState.intro:
if (intro != null)
{
intro.update(this as IMenuComponent);
}
break;
case TransitionState.revert:
if (revert != null)
{
revert.update(this as IMenuComponent);
}
break;
case TransitionState.select:
if (select != null)
{
select.update(this as IMenuComponent);
}
break;
case TransitionState.exit:
if (exit != null)
{
exit.update(this as IMenuComponent);
}
break;
}
}
/// <summary>
/// Initialize the transition, setting any initial values that it needs to have to run.
/// </summary>
/// <param name="transition">The transition that needs to be run</param>
public void setTransition(TransitionState transition)
{
switch (transition)
{
case TransitionState.intro:
if (intro != null)
{
intro.setTransition(this as IMenuComponent);
}
break;
case TransitionState.revert:
if (revert != null)
{
revert.setTransition(this as IMenuComponent);
}
break;
case TransitionState.select:
if (select != null)
{
select.setTransition(this as IMenuComponent);
}
break;
case TransitionState.exit:
if (exit != null)
{
exit.setTransition(this as IMenuComponent);
}
break;
}
}
public TransitionState ValidatePlacementTransition(TransitionState transitionState, ref int redo)
{
redo = 0;
if (SpherePath.CheckCell == null)
{
return(TransitionState.Collided);
}
switch (transitionState)
{
case TransitionState.OK:
SpherePath.CurPos = SpherePath.CheckPos;
SpherePath.CurCell = SpherePath.CheckCell;
SpherePath.CacheGlobalCurrCenter();
break;
case TransitionState.Collided:
case TransitionState.Adjusted:
case TransitionState.Slid:
// added target id
if (SpherePath.PlacementAllowsSliding && ObjectInfo.TargetID == 0)
{
CollisionInfo.Init();
}
break;
}
return(transitionState);
}
// Update is called once per frame
void Update()
{
//Updating based on our state
switch (this.currentState)
{
//If we're staying hidden, nothing happens
case TransitionState.Hide:
return;
//Moving into position
case TransitionState.TransitionIn:
//Increasing the current time
this.currentTime += Time.deltaTime;
//If the current time has reached the total transition time, we need to switch states to "Show"
if (this.currentTime >= this.transitionTime)
{
this.currentState = TransitionState.Show;
this.currentTime = 0;
this.transform.localPosition = this.transitionStayPos;
}
//Otherwise, we're still transitioning
else
{
//Setting our position between the start pos and the stay pos based on the percent of time passed
float transInPercent = this.currentTime / this.transitionTime;
this.transform.localPosition = ((this.transitionStayPos - this.transitionStartPos) * transInPercent) + this.transitionStartPos;
}
break;
case TransitionState.Show:
//Increasing the current time
this.currentTime += Time.deltaTime;
//If the current time has reached the total time to display, we need to switch states to "Transition Out"
if (this.currentTime >= this.timeToDisplay)
{
this.currentState = TransitionState.TransitionOut;
this.currentTime = 0;
}
break;
case TransitionState.TransitionOut:
//Increasing the current time
this.currentTime += Time.deltaTime;
//If the current time has reached the total transition time, we need to switch states to "Hide"
if (this.currentTime >= this.transitionTime)
{
this.currentState = TransitionState.Hide;
this.currentTime = 0;
this.transform.localPosition = this.transitionOutPos;
}
//Otherwise, we're still transitioning
else
{
//Setting our position between the stay pos and the out pos based on the percent of time passed
float transInPercent = this.currentTime / this.transitionTime;
this.transform.localPosition = ((this.transitionOutPos - this.transitionStayPos) * transInPercent) + this.transitionStayPos;
}
break;
}
}
public MenuType(string current)
{
components = new Dictionary <string, IComponent>();
state = current;
transitionState = TransitionState.menu;
queue = true;
}
protected virtual void InitEnding()
{
if (string.IsNullOrEmpty(this.nextImageId) == false)
{
if (this.parentLayer.TryGetTarget(out ALayer2D parentLayer))
{
Texture nextTexture = parentLayer.GetLayerTextureFromId(this.nextImageId);
this.ObjectSprite.Texture = nextTexture;
this.ObjectSprite.Origin = new Vector2f(this.Canevas.Width / 2, this.Canevas.Height / 2);
if (this.ObjectSprite.Texture != null)
{
this.SpriteColor = new Color(255, 255, 255, 0);
IAnimation endingAnimation = new ColorAnimation(this.SpriteColor, new Color(255, 255, 255), Time.FromSeconds(0.5f), AnimationType.ONETIME, InterpolationMethod.LINEAR);
this.PlayAnimation(endingAnimation);
}
}
this.nextImageId = null;
this.ImageTransitionState = TransitionState.ENDING;
}
else
{
this.InitFinished();
}
}
protected override void OnQuestUpdate()
{
base.OnQuestUpdate();
switch (_questState)
{
case TransitionState.Started:
if (_activationTimer.CanTick)
{
foreach (Transform t in gameObject.transform)
{
t.gameObject.SetActive(true);
}
_questState = TransitionState.Waiting;
}
break;
case TransitionState.Completed:
if (_deactivationTimer.CanTick)
{
foreach (Transform t in gameObject.transform)
{
t.gameObject.SetActive(false);
}
_questState = TransitionState.Waiting;
}
break;
}
}
/// <summary>
/// Updates the duration position based upon the game time.
/// </summary>
/// <param name="gameTime">The game time.</param>
/// <returns>The state of the transition.</returns>
public TransitionState Update(GameTime gameTime)
{
// How much should we move by?
float transitionDelta;
if (this.Time == TimeSpan.Zero)
{
transitionDelta = 1.0f;
}
else
{
transitionDelta = (float)(gameTime.ElapsedGameTime.TotalMilliseconds / this.Time.TotalMilliseconds);
}
// Update the transition position.
this.Position += transitionDelta * this._numericDirection;
// Did we reach the end of the transition?
if (((this._numericDirection < 0) && (this.Position <= 0)) ||
((this._numericDirection > 0) && (this.Position >= 1)))
{
this.Position = MathHelper.Clamp(this.Position, 0, 1);
this.State = TransitionState.Complete;
}
else
{
this.State = TransitionState.InProgress;
}
// Return the state
return(this.State);
}
private void onOffPosition()
{
//Debug.Log("onOffPosition");
m_currentTransitionState = TransitionState.OFF;
m_lastLockedState = TransitionState.OFF;
m_from = m_wipeOutPosition;
m_to = m_startPosition;
if (m_imageRetriever != null)
{
foreach (LeapImageRetriever image in m_imageRetriever)
{
image.enabled = false;
}
}
else
{
//Debug.LogError("No image retreiver on: " + gameObject.name);
}
if (m_handController != null)
{
m_handController.gameObject.SetActive(true);
}
if (m_cameraAlignment != null)
{
m_cameraAlignment.enabled = false;
}
}
void Update()
{
if (state == TransitionState.Flight || state == TransitionState.Platformer || state == TransitionState.Menu)
{
return;
}
if (state == TransitionState.ToMenu)
{
t += Time.deltaTime;
camera.transform.position = Vector3.Lerp(FlightPosition, MenuPosition,
curve.Evaluate(Mathf.Min(1, t / TransitionTime)));
if (t > TransitionTime)
{
state = TransitionState.Platformer;
callback?.Invoke();
callback = null;
t = 0;
}
}
if (state == TransitionState.FromMenu)
{
t += Time.deltaTime;
camera.transform.position = Vector3.Lerp(MenuPosition, PlatformerPosition,
curve.Evaluate(Mathf.Min(1, t / TransitionTime)));
if (t > TransitionTime)
{
state = TransitionState.Platformer;
callback?.Invoke();
callback = null;
t = 0;
}
}
if (state == TransitionState.FromPlatformer)
{
t += Time.deltaTime;
camera.transform.position = Vector3.Lerp(PlatformerPosition, FlightPosition,
curve.Evaluate(Mathf.Min(1, t / TransitionTime)));
if (t > TransitionTime)
{
state = TransitionState.Flight;
callback?.Invoke();
callback = null;
t = 0;
}
}
if (state == TransitionState.FromFlight)
{
t += Time.deltaTime;
camera.transform.position = Vector3.Lerp(FlightPosition, MenuPosition,
curve.Evaluate(Mathf.Min(1, t / TransitionTime)));
if (t > TransitionTime)
{
state = TransitionState.Menu;
callback?.Invoke();
callback = null;
t = 0;
}
}
}
public void updateTransitions(TransitionState state)
{
switch (state)
{
case TransitionState.intro:
if (intro != null)
{
intro.update(this);
}
break;
case TransitionState.selected:
if (select != null)
{
select.update(this);
}
break;
case TransitionState.exit:
if (exit != null)
{
exit.update(this);
}
break;
}
}
public TransitionState ValidatePlacement(TransitionState transitionState, bool adjust)
{
if (SpherePath.CheckCell == null)
{
return(TransitionState.Collided);
}
switch (transitionState)
{
case TransitionState.OK:
SpherePath.CurPos = SpherePath.CheckPos;
SpherePath.CurCell = SpherePath.CheckCell;
SpherePath.CacheGlobalCurrCenter();
break;
case TransitionState.Adjusted:
case TransitionState.Slid:
if (adjust)
{
return(ValidatePlacement(PlacementInsert(), false));
}
break;
}
return(transitionState);
}
void Footer_OnSpeedChanged(object sender, EventArgs e)
{
try
{
if (tran != null)
{
TransitionState oldState = tran.State;
tran.pause();
Point originalLabelPos = label.Location;
int time = (MAX_SLIDER_VALUE - speed + (MIN_SLIDER_VALUE == 0 ? 1 : 0)) * CalculateTransitionTime(BASE_TIME_TRANSITION, label.Width + originalLabelPos.X);
tran = new Transition(new TransitionType_Linear(time));
tran.add(label, "Left", -label.Size.Width);
tran.TransitionCompletedEvent += tran_TransitionCompletedEvent;
if (oldState == TransitionState.Running)
{
tran.run();
}
CurrentTextIndex++;
}
}
catch (Exception ex)
{
#if DEBUG
MessageBox.Show("Footer_OnSpeedChanged" + Environment.NewLine + ex.Message);
#endif
}
}
protected async Task UpdateState(bool mounting, TransitionState next)
{
// var next = Next;
if (next != TransitionState.None)
{
DisposeCallback();
// Next will always be ENTERING or EXITING.
if (next == TransitionState.Entering)
{
await PerformEnter(mounting);
}
else
{
await PerformExit();
}
}
else if (UnmountOnExit && Current == TransitionState.Exited)
{
Current = TransitionState.Unmounted;
await InvokeAsync(StateHasChanged);
}
}
/// <summary>
/// Essentially triggers the animation to play again in reverse
/// </summary>
public virtual void TriggerFadeOut()
{
if (state == TransitionState.AnyState) //this is for brand new items, it show we don't know what state it is in. However since we are calling fade out first...
{
state = TransitionState.Waiting; //then it must be displaying and waiting to fade out
currentTime = fadeOutTime;
}
if (fadeOutDelay != 0)
{
if (state == TransitionState.Waiting)//if finished, then restart
{
currentTime = 0;
state = TransitionState.FadeOutDelay;
}
else//Otherwise continue the animation where this left off
{
state = TransitionState.FadingOut;
}
}
else
{
if (state == TransitionState.Waiting)//if finished, then restart. Otherwise continue the animation were this left off
{
currentTime = fadeOutTime;
}
state = TransitionState.FadingOut;
}
CheckMessage();
}
public static TransitionState DoTransition([NotNull] StateContext nextState, [CanBeNull] StateContext previousState, [CanBeNull] StateContext parentState = null)
{
TransitionState transitionState = new TransitionState(nextState, previousState);
(parentState ?? ((object)((previousState != null) ? previousState.get_parent() : null)) ?? ((object)StateManager.GetDefaultLayer())).SetChildState(transitionState, 0);
return(transitionState);
}
public void JumpToEnd()
{
currentTime = transitionInTime;
Transition();
state = BaseTransition.TransitionState.Waiting;
CheckMessage();
}
public virtual void Initialise()
{
#region Send Instantly
TransitionState temp = state;
state = TransitionState.Delay;
CheckMessage();//check to see if a message needs sent instantly
state = temp;
#endregion
#if (UNITY_EDITOR)
//if(transitionInTime <= 0 || fadeOutTime <= 0)
// Debug.LogError("Transition and Fade time has to be greater than 0!!");
if (transitionInCurve.length == 0 || fadeOutCurve.length == 0)
{
Debug.LogError("No animation curve set for: " + parent.gameObject +
".\nIf you have upgraded this framework then selecting the straight diagonal line will reproduce the exact result from previous versions. However you can now get nicer results using more natural curves intstead of lines" +
"\nTo set these click the empty box labelled 'Animation Curve'");
}
#endif
state = BaseTransition.TransitionState.AnyState;//used to show this is the first run
if (triggerInstantly)
{
TriggerTransition(false);
}
}
internal void TransitionStateChanged(TransitionState state)
{
if (state == TransitionState.Left)
{
Closed?.Invoke(this);
}
}
/// <summary>
/// Update transitions
/// </summary>
/// <param name="gameTime">GameTime</param>
public override void Update(GameTime gameTime)
{
if (_transitionState == TransitionState.FadeIn)
{
if (UpdateTransition(gameTime, _timeTransitionOn, -1))
{
_transitionState = TransitionState.On;
OnTransitionFinished(EventArgs.Empty, true);
}
else
{
OnTransitionActive(EventArgs.Empty, true);
}
}
else if (_transitionState == TransitionState.FadeOut)
{
if (UpdateTransition(gameTime, _timeTransitionOff, 1))
{
_transitionState = TransitionState.Off;
OnTransitionFinished(EventArgs.Empty, false);
}
else
{
OnTransitionActive(EventArgs.Empty, true);
}
}
}
private IEnumerator collapse(Vector2 pTargetSize, float pTransitionDuration)
{
if (_subElements.Length > 0)
{
for (int i = _subElements.Length - 1; i >= 0; i--)
{
//This can be graetly improved, perhaps implement an interface to support different types of collapsing
IEnumerator foldin = _subElements[i].GetComponent <ARHintFoldout>().Foldin();
yield return(foldin);
}
}
_dummyRect.gameObject.SetActive(true);
gameObject.SetActive(false);
_state = TransitionState.Collapsing;
Vector2 startSize = _dummyRect.sizeDelta;
float timeElapsed = 0;
float closeTime = pTransitionDuration * (Vector2.Distance(pTargetSize, startSize) / Vector2.Distance(pTargetSize, _rect.sizeDelta));
while (Vector2.Distance(pTargetSize, _dummyRect.sizeDelta) > 0.01f)
{
_dummyRect.sizeDelta = Vector2.Lerp(startSize, pTargetSize, timeElapsed / closeTime);
timeElapsed += Time.deltaTime;
yield return(new WaitForEndOfFrame());
}
_dummyRect.sizeDelta = pTargetSize;
_transforming = null;
_state = TransitionState.Collapsed;
}
void SetTutorial(TutorialType type)
{
// Clean up old tutorial.
Destroy(m_TutorialObject);
m_TutorialObject = null;
// Find the appropriate prefab.
GameObject prefab = TutorialManager.m_Instance.GetTutorialPrefab(type);
if (prefab)
{
m_TutorialObject = (GameObject)Instantiate(prefab, transform.position, transform.rotation);
m_TutorialObject.transform.parent = transform;
m_TutorialObject.transform.localScale = Vector3.zero;
}
else
{
// Nothing mapped. Jump straight to standard.
m_TipTransitionState = TransitionState.None;
}
m_CurrentTutorialType = m_DesiredTutorialType;
int iNumTypes = (int)TutorialType.Num;
int iCurrentType = (int)m_CurrentTutorialType + 1;
m_TipNumber.text = iCurrentType.ToString() + " of " + iNumTypes.ToString();
}
private void Transition()
{
if (Vector3.Distance(LevelDestination[0].transform.position, transform.position) <= 0.1f)
{
transform.position = LevelDestination[0].transform.position;
transitionPosOk = true;
}
else
{
offset = Vector3.Lerp(offset, offsetLevel2, Time.deltaTime * transitionSpeed);
transform.position = transform.position + dirNormalized * transitionSpeed * Time.deltaTime;
}
if (Quaternion.Angle(transform.rotation, LevelDestination[0].transform.rotation) <= 0)
{
transform.rotation = LevelDestination[0].transform.rotation;
transitionRotOk = true;
}
if (transitionPosOk && transitionRotOk)
{
transitionState = TransitionState.TRANSITION_OFF;
target.GetComponent <PlayerBehavior>().SetLevel((int)levelState);
}
else
{
Vector3 angleTarget = new Vector3(
Mathf.LerpAngle(transform.rotation.eulerAngles.x, LevelDestination[(int)levelState - 1].transform.rotation.eulerAngles.x, Time.deltaTime * rotationSpeed),
Mathf.LerpAngle(transform.rotation.eulerAngles.y, LevelDestination[(int)levelState - 1].transform.rotation.eulerAngles.y, Time.deltaTime * rotationSpeed),
Mathf.LerpAngle(transform.rotation.eulerAngles.z, LevelDestination[(int)levelState - 1].transform.rotation.eulerAngles.z, Time.deltaTime * rotationSpeed));
transform.eulerAngles = angleTarget;
}
}
private void ProcessTransition()
{
float deltaTime = Time.unscaledDeltaTime;
switch (_currentTransitionState)
{
case TransitionState.TS_NONE:
if (_fader.gameObject.activeSelf)
{
_fader.gameObject.SetActive(false);
}
break;
case TransitionState.TS_OUT:
_transitionTimer += deltaTime;
if (_transitionTimer > _transitionLength)
{
_transitionTimer = _transitionLength;
SetPanelActive(_currentGameState, false);
SetPanelActive(_targetGameState, true);
_currentGameState = _targetGameState;
_targetGameState = AppState.AS_NONE;
_currentTransitionState = TransitionState.TS_IN;
}
else
{
if (!_fader.gameObject.activeSelf)
{
_fader.gameObject.SetActive(true);
}
Color faderColor = _fader.color;
faderColor.a = Mathf.Clamp01(_transitionTimer / _transitionLength);
_fader.color = faderColor;
}
break;
case TransitionState.TS_IN:
_transitionTimer -= deltaTime;
if (_transitionTimer < 0.0f)
{
_transitionTimer = 0.0f;
_currentTransitionState = TransitionState.TS_NONE;
NotifyOnGameStateChanged();
}
else
{
if (!_fader.gameObject.activeSelf)
{
_fader.gameObject.SetActive(true);
}
Color faderColor = _fader.color;
faderColor.a = Mathf.Clamp01(_transitionTimer / _transitionLength);
_fader.color = faderColor;
}
break;
}
}
// Update is called once per frame
void Update()
{
if (update)
{
if (tsState == TransitionState.Evap)
{
transitionTimer += Time.deltaTime / transitionTime;
float magnitude = Mathf.Lerp(minMagnitude, maxMagnitude, transitionTimer);
evaporateMat.SetFloat("_Magnitude", magnitude);
if (transitionTimer >= 1)
{
//De-evaporate
evaporateMat.SetFloat("_Magnitude", minMagnitude);
halluMat.SetFloat("_yPercentage", 1f);
tsState = TransitionState.Invert;
}
}
else if (tsState == TransitionState.Invert)
{
inversionTimer += Time.deltaTime;
if (inversionTimer > inversionTime)
{
halluMat.SetFloat("_yPercentage", 0f);
SoundEffector.Instance.Stop();
tsState = TransitionState.Done;
}
}
}
}
void Update() {
BaseUpdate();
switch (m_TipTransitionState) {
case TransitionState.Out:
// Shrink our current tutorial until 0, then spawn the desired next.
m_TipTransitionValue -= Time.deltaTime * m_TipTransitionSpeed;
if (m_TipTransitionValue <= 0.0f) {
SetTutorial(m_DesiredTutorialType);
m_TipTransitionValue = 0.0f;
m_TipTransitionState = TransitionState.In;
} else {
m_TutorialObject.transform.localScale = Vector3.one * m_TipTransitionValue;
}
break;
case TransitionState.In:
// Grow our current tutorial until 1.
m_TipTransitionValue += Time.deltaTime * m_TipTransitionSpeed;
if (m_TipTransitionValue >= 1.0f) {
m_TipTransitionValue = 1.0f;
m_TipTransitionState = TransitionState.None;
}
if (m_TutorialObject) {
m_TutorialObject.transform.localScale = Vector3.one * m_TipTransitionValue;
}
break;
}
}
public void drawTransitions(SpriteBatch spriteBatch, TransitionState state)
{
switch (state)
{
case TransitionState.intro:
if (intro != null)
{
intro.draw(spriteBatch, this);
}
break;
case TransitionState.selected:
if (select != null)
{
select.draw(spriteBatch, this);
}
break;
case TransitionState.exit:
if (exit != null)
{
exit.draw(spriteBatch, this);
}
break;
}
}
/// <summary>
/// Constructs a Transitionable with the given transition times and screen directions.
/// </summary>
/// <param name="transitionOnTime"></param>
/// <param name="transitionOffTime"></param>
public Transition(double transitionOnTime, double transitionOffTime)
{
elapsedTransition = TimeSpan.Zero;
state = TransitionState.Off;
transitionOn = TimeSpan.FromSeconds(transitionOnTime);
transitionOff = TimeSpan.FromSeconds(transitionOffTime);
}
// Use this for initialization
void Start () {
m_startPosition = transform.localPosition;
m_from = m_startPosition;
m_to = m_wipeOutPosition;
m_lastLockedState = TransitionState.ON;
SystemWipeRecognizerListener.Instance.SystemWipeUpdate += onWipeUpdate;
TweenToOffPosition();
}
public TransitionState Transitioning( TransitionState currentState, Node scene, GameTime gameTime )
{
if ( currentState == TransitionState.Begin )
return TransitionState.PretransitionEnd;
else if ( currentState == TransitionState.PretransitionEnd )
return TransitionState.End;
else throw new ArgumentException ();
}
private IEnumerator FadeIn()
{
_fadeStartTime = Time.time;
_transitionState = TransitionState.Showing;
yield return new WaitForSeconds( FADE_DURATION );
_transitionState = TransitionState.Idle;
}
public override void OnDeactivate()
{
if(State == TransitionState.InTransitForward || State == TransitionState.InTransitReverse)
StartTime = Time.time - (TransitionTime * CurrentProgress);
else
StartTime = Time.time;
State = TransitionState.InTransitReverse;
}
private IEnumerator FadeOut()
{
_fadeStartTime = Time.time;
_transitionState = TransitionState.Hiding;
yield return new WaitForSeconds( FADE_DURATION );
SaveManager.ChangeLevel( nextLevelName );
}
public override void Draw( GameTime gameTime )
{
if ( currentNode != null )
currentNode.Draw ( gameTime );
if ( TransitionState != TransitionState.None )
{
TransitionState = SceneTransitor.Transitioning ( TransitionState, sceneList.Peek (), gameTime );
if ( TransitionState == Scenes.TransitionState.PretransitionEnd )
{
switch ( ContainMethod )
{
case SceneContainMethod.Flat:
spinlock.Enter ();
sceneList.Pop ().Outro ();
nextNode.Intro ( nextNodeArgs );
nextNode.Parent = this;
sceneList.Push ( currentNode = nextNode );
nextNode = null;
nextNodeArgs = null;
spinlock.Exit ();
break;
case SceneContainMethod.Stack:
if ( nextNode == null )
{
spinlock.Enter ();
Node nn = sceneList.Pop ();
nn.Parent = null;
nn.Outro ();
currentNode = null;
nextNode = null;
nextNodeArgs = null;
spinlock.Exit ();
}
else
{
spinlock.Enter ();
nextNode.Intro ( nextNodeArgs );
sceneList.Push ( currentNode = nextNode );
nextNode = null;
nextNodeArgs = null;
spinlock.Exit ();
}
break;
}
gameTime.Reset ();
}
else if ( TransitionState == Scenes.TransitionState.End )
{
TransitionState = TransitionState.None;
nextNode = null;
}
}
base.Draw ( gameTime );
}
protected override void OnQuestAdded()
{
base.OnQuestAdded();
_activationTimer = new Timer(_activationTime);
_questState = TransitionState.Started;
// Ensure all the transforms start off disabled
foreach(Transform t in gameObject.transform)
{
t.gameObject.SetActive(false);
}
}
public void ChangeRoom(int id)
{
if(dia)
dia.Hide(); // hides dialogue box messages
im.SetMode(InteractMode.gMode.GM_NONE);
NextRoom = id;
Transitioning = true;
TransitionTimeRemaining = 1.0f;
TransitionStateCurrent = TransitionState.TO_BLACK;
}
public void StartTransition (Color fromColor, Color toColor, float duration, TransitionType type) {
if (transitState == TransitionState.TransitedIn || transitState == TransitionState.TransitedOut) {
// Change the state to transiting in/out (according to the previous state)
transitState = transitState == TransitionState.TransitedIn ? TransitionState.TransitingOut : TransitionState.TransitingIn;
// Enable the transiter's Image
transiters[type].EnableImage ();
// Call the transition animation according to the given TransitionType
transiters[type].StartTransition (fromColor, toColor, duration);
}
}
void Awake()
{
// Access button component
button = GetComponent<Button>();
// Starting state
transitionState = TransitionState.Down;
// Get colour
baseColor = button.colors.normalColor;
highlightedColor = button.colors.highlightedColor;
}
public Screen(Game game)
: base(game)
{
game.Components.Add(this);
this.Enabled = false;
this.Visible = false;
killFlag = false;
transState = TransitionState.None;
spriteBatch = (SpriteBatch)game.Services.GetService(typeof(SpriteBatch));
spriteFont = (SpriteFont)game.Services.GetService(typeof(SpriteFont));
inputHelper = (InputHelper)game.Services.GetService(typeof(InputHelper));
shadeTexture = Game.Content.Load<Texture2D>("Media\\GUI\\Shade");
fadeLevel = 0;
}
void Awake () {
transitState = TransitionState.TransitedIn;
UITransiterFadeInOut fadeInOut = GetComponentInChildren<UITransiterFadeInOut> ();
transiters.Add (TransitionType.FadeInOut, fadeInOut);
try {
transiters[TransitionType.FadeInOut].TransiterActionCompleted += this.OnTransiterActionCompleted;
} catch {
Debug.LogError ("No UIFadeInOut was found in the children of the object " + gameObject.name);
Debug.Break ();
}
transiters.Add (TransitionType.None, null);
}
private void onWipeUpdate(object sender, SystemWipeArgs eventArgs) {
if ( !m_enabled ) { return; }
string debugLine = "Debug";
if ( eventArgs.WipeInfo.Status == Leap.Util.Status.SwipeAbort ) {
debugLine += " | Abort";
// If the user aborts, tween back to original location
if ( m_lastLockedState == TransitionState.ON ) {
TweenToOnPosition();
}
else {
TweenToOffPosition();
}
}
if ( m_currentTransitionState == TransitionState.MANUAL ) {
debugLine += " | Manual Control";
float fraction = Mathf.Clamp01(eventArgs.WipeInfo.Progress);
debugLine += ": " + fraction;
transform.localPosition = Vector3.Lerp(m_from, m_to, fraction);
// If we're sure of the gesture, just go make the transition
if ( fraction >= m_fractionToLockTransition ) {
debugLine += " | Transition Cofirmed";
if ( m_lastLockedState == TransitionState.OFF ) {
TweenToOnPosition();
}
else {
TweenToOffPosition();
}
}
}
else if ( m_currentTransitionState == TransitionState.TWEENING ) {
debugLine += " | Currently Tweening";
//Debug.Log(debugLine);
return;
}
else { // We're either on or off
debugLine += " | Locked";
if ( eventArgs.WipeInfo.Progress >= m_minProgressToStartTransition ) {
debugLine += " | Go To Manual";
m_currentTransitionState = TransitionState.MANUAL;
}
}
//Debug.Log(debugLine);
}
public StateHandler()
{
_score = 0;
_gamestate = GameState.Menu;
_menustate = MenuState.MainMenu;
_levelstate = LevelState.Level1;
_transitionstate = TransitionState.LevelStart;
_characterstate = CharacterState.Standing;
_characterskin = Skins.Mario;
_nextgamestate = GameState.Menu;
_nextmenustate = MenuState.MainMenu;
_nextlevelstate = LevelState.Level1;
_nexttransitionstate = TransitionState.LevelStart;
_nextcharacterstate = CharacterState.Standing;
_nextcharacterskin = Skins.Mario;
_cursor = MenuCursor.PlayGame;
_keyscursor = 1;
_skinscursor = 1;
}
public TransitionState Transitioning( TransitionState currentState, Node scene, GameTime gameTime )
{
switch ( currentState )
{
case TransitionState.Begin:
fadeAlpha += ( float ) gameTime.ElapsedGameTime.TotalMilliseconds / 1000.0f * FadeUnit;
if ( fadeAlpha >= 255 ) fadeAlpha = 255;
DrawFade ();
if ( fadeAlpha >= 255 ) return TransitionState.PretransitionEnd;
return TransitionState.Begin;
case TransitionState.Posttransition:
case TransitionState.PretransitionEnd:
fadeAlpha -= ( float ) gameTime.ElapsedGameTime.TotalMilliseconds / 1000.0f * FadeUnit;
DrawFade ();
if ( fadeAlpha <= 0 ) { fadeAlpha = 0; return TransitionState.End; }
return TransitionState.Posttransition;
default:
throw new ArgumentException ();
}
}
void Update()
{
if(State == TransitionState.InTransitForward || State == TransitionState.InTransitReverse)
{
CurrentProgress = (Time.time - StartTime) / TransitionTime;
CurrentProgress = Mathf.Clamp(CurrentProgress, 0.0f, 1.0f);
if(State == TransitionState.InTransitForward)
{
TargetObject.transform.position = Vector3.Lerp(OriginalLocation, ActualEndLocation, CurrentProgress);
TargetObject.transform.rotation = Quaternion.Lerp(OriginalOrientation, ActualEndRotation, CurrentProgress);
}
else if(State == TransitionState.InTransitReverse)
{
TargetObject.transform.position = Vector3.Lerp(ActualEndLocation, OriginalLocation, CurrentProgress);
TargetObject.transform.rotation = Quaternion.Lerp(ActualEndRotation, OriginalOrientation, CurrentProgress);
}
if(Time.time - StartTime > TransitionTime)
State = TransitionState.Waiting;
}
}
private IEnumerator Flash()
{
while(isSelected)
{
// Increase alpha
animationFrame += Time.deltaTime;
// Get colour
ColorBlock block = button.colors;
// Update structs
if(transitionState.Equals(TransitionState.Down))
{
// Lerp towards base
block.highlightedColor = Color.Lerp(highlightedColor, baseColor, animationFrame / flashSpeed);
if(block.highlightedColor.Equals(baseColor))
{
transitionState = TransitionState.Up;
animationFrame = 0;
}
}
else
{
// Lerp towards highlighted
block.highlightedColor = Color.Lerp(baseColor, highlightedColor, animationFrame / flashSpeed);
if(block.highlightedColor.Equals(highlightedColor))
{
transitionState = TransitionState.Down;
animationFrame = 0;
}
}
// Apply to button
button.colors = block;
yield return null;
}
}
public override void LoadContent(ContentManager content)
{
Engine.ClearColor = Color.Black;
_state = TransitionState.Beginning;
_transitionTween = new Tween(0, 100, 2000)
{
OnComplete = t =>
{
if (_state == TransitionState.Beginning)
{
_state = TransitionState.Running;
}
else if (_state == TransitionState.Running)
{
_state = TransitionState.End;
}
else if (_state == TransitionState.End)
{
_state = TransitionState.Stopped;
}
if (_state != TransitionState.Stopped)
{
t.Reset();
t.Start();
}
else
{
Engine.Scenes.ChangeScene(SceneNames.Title);
}
}
};
_logoTexture = Textures.Load(TextureNames.CarpMuffinLogo);
_whitePixel = Engine.CreateWhitePixel();
}
private void onOffPosition()
{
//Debug.Log("onOffPosition");
m_currentTransitionState = TransitionState.OFF;
m_lastLockedState = TransitionState.OFF;
m_from = m_wipeOutPosition;
m_to = m_startPosition;
}
protected new void FixedUpdate()
{
base.FixedUpdate();
if (throwDelayCountdown > 0.0f && throwDelayCountdown - Time.deltaTime < 0)
{
Throw(delayedDirection, delayedCamera, delayedOtherCamera, 0);
}
throwDelayCountdown -= Time.deltaTime;
if (floatDirection != null)
{
Vector3 moveDelta = new Vector3(floatDirection.Value.x * Time.deltaTime, floatDirection.Value.y * Time.deltaTime, floatDirection.Value.z * Time.deltaTime);
transform.Translate(moveDelta.x, moveDelta.y, moveDelta.z);
if(GameManager.isSingleScreen()) return;
if (originCamera != null && destinationCamera != null)
{
// move up or down until we're not longer in view of the origin camera
Plane[] plane = GeometryUtility.CalculateFrustumPlanes(destinationCamera);
Vector3 cameraSpacePosition = originCamera.WorldToScreenPoint(transform.position);
bool goingUp = (floatDirection.Value.y > 0);
float pixelHeight = originCamera.pixelHeight * 0.5f;
//Debug.Log("cameraSpacePosition " + cameraSpacePosition + ": " + originCamera.pixelWidth);
//Debug.Log("pixelHeight " + pixelHeight + " " + originCamera.pixelWidth);
if ((goingUp && cameraSpacePosition.y > pixelHeight) || (!goingUp && cameraSpacePosition.y < pixelHeight))
{
//Debug.Log("cameraSpacePosition.x " + cameraSpacePosition.x);
Vector3 position = destinationCamera.ScreenToWorldPoint(new Vector3(cameraSpacePosition.x, goingUp ? pixelHeight : pixelHeight, 0.0f));
position.x = Mathf.Round(position.x);
position.z = 0.0f;
if (shouldStopInFirstEmptySpace)
{
if (goingUp) transitionState = TransitionState.TRANSITIONING_FROM_BOTTOM;
else transitionState = TransitionState.TRANSITIONING_FROM_TOP;
}
else
{
transitionState = TransitionState.FLOATING_AWAY;
}
transform.position = position;
originCamera = null;
return;
}
}
else
{
switch(transitionState)
{
case TransitionState.TRANSITIONING_FROM_BOTTOM:
{
Vector3 bottom = transform.position;
bottom.y -= collider.bounds.size.y * 0.5f;
if (pointIsInCamera(bottom, destinationCamera))
transitionState = TransitionState.LOOKING_FOR_FREE_SPACE_GOING_UP;
}
break;
case TransitionState.TRANSITIONING_FROM_TOP:
{
Vector3 top = transform.position;
top.y += collider.bounds.size.y * 1.0f;
if (pointIsInCamera(top, destinationCamera))
transitionState = TransitionState.LOOKING_FOR_FREE_SPACE_GOING_DOWN;
}
break;
case TransitionState.LOOKING_FOR_FREE_SPACE_GOING_UP:
{
Collider collidedWith = collidedWithSomething();
if (collidedWith == null || collidedWith.GetComponent<PlayerControls2>())
{
if (collidedWith != null)
{
PlayerControls2 hitPlayer = collidedWith.GetComponent<PlayerControls2>();
if (hitPlayer != null)
hitPlayer.knockBackByBlock(true, damageMultiplier);
}
floatDirection = null;
collider.isTrigger = false;
//if(passedThroughSomething) // keep it suspected in air if it didn't pass through a floor
jumpState = JUMP_STATE.ON_GROUND;
onHitGround();
}
else
passedThroughSomething = true;
}
break;
case TransitionState.LOOKING_FOR_FREE_SPACE_GOING_DOWN:
{
//transform.Translate(moveDelta.x, moveDelta.y, moveDelta.z);
/*int count = 0;
Ray ray = new Ray(new Vector3(transform.position.x, 0.0f, 0.0f), new Vector3(0.0f, -1.0f, 0.0f));
RaycastHit lastHit = new RaycastHit();
while(count++ < 50)
{
RaycastHit hit;
bool didHit = collider.Raycast(ray, out hit, Mathf.Infinity);
Debug.DrawLine(ray.origin, ray.origin + ray.direction, Color.blue, 10);
if (didHit && lastHit.collider != null && hit.collider == lastHit.collider)
{
break;
}
lastHit = hit;
ray.origin = new Vector3(ray.origin.x, ray.origin.y + 1.0f);
}
if (count >= 50.0f)
Debug.Log("failed " + count);
Collider collidedWith = collidedWithSomething();
if(collider.gameObject != null)
Debug.Log("collidedWith", collider.gameObject);
if(lastHit.collider.gameObject != null)
Debug.Log("lastHit ", lastHit.collider.gameObject);
if (collidedWith == lastHit.collider)*/
Collider collidedWith = collidedWithSomething();
if(collidedWith != null)
{
if (collidedWith != null)
{
PlayerControls2 hitPlayer = collidedWith.GetComponent<PlayerControls2>();
if (hitPlayer != null)
hitPlayer.knockBackByBlock(true, damageMultiplier);
}
transform.Translate(-moveDelta.x, -moveDelta.y, -moveDelta.z);
floatDirection = null;
collider.isTrigger = false;
passedThroughSomething = true;
jumpState = JUMP_STATE.ON_GROUND;
onHitGround();
}
}
break;
case TransitionState.FLOATING_AWAY:
if (!renderer.isVisible)
{
Destroy(this);
}
break;
}
}
}
}
public void StartClose()
{
tState = TransitionState.TransitionOff;
}
public void TweenToPosition(float percentage, float time = 0.4f) {
m_currentTransitionState = TransitionState.TWEENING;
StopAllCoroutines();
StartCoroutine(doPositionTween(percentage, time));
}
private void onOnPosition() {
//Debug.Log("onOnPosition");
m_currentTransitionState = TransitionState.ON;
m_lastLockedState = TransitionState.ON;
m_from = m_startPosition;
m_to = m_wipeOutPosition;
m_handController.gameObject.SetActive(false);
}
private void onOffPosition() {
//Debug.Log("onOffPosition");
m_currentTransitionState = TransitionState.OFF;
m_lastLockedState = TransitionState.OFF;
m_from = m_wipeOutPosition;
m_to = m_startPosition;
if ( m_imageRetriever != null ) {
m_imageRetriever.doUpdate = false;
}
else {
Debug.LogError("No image retreiver on: " + gameObject.name);
}
m_handController.gameObject.SetActive(true);
}
public void UpdateTransition(GameTime gameTime)
{
float transitionDelta = 0;
if (tState == TransitionState.TransitionOn)
{
transitionDelta = (float)(gameTime.ElapsedGameTime.TotalMilliseconds /
transitionOn.TotalMilliseconds);
}
else if (tState == TransitionState.TransitionOff)
{
transitionDelta = (float)(gameTime.ElapsedGameTime.TotalMilliseconds /
transitionOff.TotalMilliseconds);
}
if (tState != TransitionState.NoTransition)
{
transitionProgress += transitionDelta;
if (transitionProgress >= 1)
{
transitionProgress = 1;
if (tState == TransitionState.TransitionOff)
{
canClose = true;
}
tState = TransitionState.NoTransition;
}
}
else
{
transitionProgress = 0;
}
}
public override void LoadContent()
{
State = TransitionState.Intro;
}
public void SetDone()
{
State = TransitionState.Done;
}
private void ImportState(Interface.Struct.TechniteState state)
{
taskParameter = 0;
lastResources = resources;
resources = state.resources;
taskResult = (TaskResult)state.taskResult;
this.state = new CompressedState(state.state).Decoded;
transitionState = TransitionState.Preserved;
if (taskResult == Technite.TaskResult.OperationWindowMissed)
{
if (++windowMissedThisRound < MaxLogPerRound)
Out.Log(Significance.Unusual, "Operation Window Missed on " + nextTask + " of " + this);
}
if (taskResult != TaskResult.MoreWorkNeeded)
nextTask = Task.None;
}