void Update()
{
if (state == FadingState.Idle)
return;
float progress = Mathf.Clamp((Time.time - FadeStartTime) / fadeSeconds, 0.0f, 1.0f);
bool FadeIsOver = progress > 0.95f;
_image.color = Color.Lerp(_image.color, TargetColor, progress * progress);
if (FadeIsOver)
{
if (state == FadingState.In)
{
_image.color = Color.clear;
_image.enabled = false;
state = FadingState.Idle;
}
else
{
// load next level
if (NextLevel != null)
{
SceneManager.LoadScene(NextLevel);
}
else
{
SceneManager.LoadScene(0);
}
}
}
}
public override void Update()
{
switch (State)
{
case FadingState.FadeIn:
Visibility.StepForward();
if (Visibility.Complete)
{
State = FadingState.Idle;
}
break;
case FadingState.Idle:
if (InputHelper.ButtonJustPressed2Player(Buttons.B))
{
State = FadingState.FadeOut;
}
break;
case FadingState.FadeOut:
Visibility.StepBackward();
if (Visibility.Progress <= 0f)
{
State = FadingState.FadeIn;
Visibility.Reset();
SceneManager.Instance.SetCurrentSceneTo("Menu");
}
break;
}
}
// Start is called before the first frame update
void Start()
{
orochi = new Monster("orochi", 10, 1000, 50, 20, imageOro, poison, oroHP, oroDamage);
zz = new Hero("zz", 2, imageZz, imageZzAttack, imageZzEnd);
moltres = new Monster("moltres", 15, 550, 30, 45, imageMol, fire, molHP, molDamage);
metal = new Metal(iPhone);
imagewhite.color = new Color(0, 0, 0, 0);
fadingstate = FadingState.Fadein;
}
public virtual void Read(PackFileDeserializer des, BinaryReaderEx br)
{
m_weight = br.ReadSingle();
m_timeElapsed = br.ReadSingle();
m_onFraction = br.ReadSingle();
m_fadingState = (FadingState)br.ReadSByte();
m_useMotion = br.ReadBoolean();
m_syncNextFrame = br.ReadBoolean();
m_isActive = br.ReadBoolean();
}
/// <summary>
/// Update the bar, processing how much it should fade a bar.
/// </summary>
public void Update()
{
double seconds = ServiceManager.Game.DeltaTime;
CheckForHold(seconds);
// Do nothing if the bar is not being faded.
if (state == FadingState.NONE)
{
return;
}
elapsed += (float)seconds;
if (state == FadingState.IN)
{
if (elapsed > fadeInTime)
{
StopFading();
}
else
{
if (this.Opacity < inOpacity)
{
this.Opacity += .1f;
}
else
{
state = FadingState.NONE;
holdElapsed = 0f;
holding = true;
}
}
}
else
{
if (elapsed > fadeOutTime)
{
StopFading();
}
else
{
if (this.Opacity > outOpacity)
{
this.Opacity -= .025f;
}
}
}
if (IsPulsing)
{
DoPulse();
}
}
public void StartFadeIn()
{
if (!_image.enabled)
{
Color tmp = Color.black;
tmp.a = 1.0f;
_image.color = tmp;
_image.enabled = true;
}
TargetColor = Color.clear;
FadeStartTime = Time.time;
state = FadingState.In;
}
private void StartStopTimer(FadingState newState)
{
if (newState == FadingState.Idle)
{
state = newState;
timer.Stop();
}
else
{
state = newState;
timer.Start();
FadeStep();
}
}
// Update is called once per frame
void Update()
{
if(actualState == FadingState.FadingOut && audio.volume > 0)
{
audio.volume -= fadingVelocity * Time.deltaTime;
}
else if(actualState == FadingState.FadingOut && audio.volume <= 0)
{
actualState = FadingState.Muted;
audio.volume = 0;
}
else if(actualState == FadingState.FadingIn && audio.volume < 1)
{
audio.volume += fadingVelocity * Time.deltaTime;
}
else if(actualState == FadingState.FadingIn && audio.volume >= 1)
{
actualState = FadingState.Unmuted;
audio.volume = 1;
}
}
public void StartFadeOut(string LevelToLoadOverride = null)
{
if (LevelToLoadOverride != null)
{
NextLevel = LevelToLoadOverride;
}
if (!_image.enabled)
{
Color tmp = Color.clear;
tmp.a = 0.0f;
_image.color = tmp;
_image.enabled = true;
}
TargetColor = Color.black;
FadeStartTime = Time.time;
state = FadingState.Out;
}
private IEnumerator RespawnPlayer()
{
_player.IsControllable = false;
// Start fading in
_startTime = Time.time;
_activeState = FadingState.FadingIn;
yield return new WaitForSeconds( FADE_DURATION );
// After _fadeDuration time, show solid black
_guiColor.a = 1;
_activeState = FadingState.Shown;
yield return new WaitForEndOfFrame();
// Add a solid black screen to hide stuff.
yield return new WaitForSeconds( TIME_DURING_BLANK_SCREEN );
_activeState = FadingState.FadingOut;
_startTime = Time.time;
_player.transform.position = targetRespawnPoint.position;
yield return new WaitForSeconds( FADE_DURATION );
_guiColor.a = 0;
_activeState = FadingState.Hidden;
_player.IsControllable = true;
}
public void FadeInFadeOut(ref Metal metalShining, ref Monster oro, ref Monster mol)
{
switch (fadingstate)
{
case FadingState.Init:
{
imagewhite.color = new Color(255, 255, 255, 0);
}
break;
case FadingState.Fadein:
{
FadingTime += Time.deltaTime;
if (FadingTime > 2.0f)
{
imagewhite.color = new Color(255, 255, 255, 1);
fadingstate = FadingState.White;
FadingTime = 0f;
}
else
{
imagewhite.color = new Color(255, 255, 255, FadingTime / 2);
}
}
break;
case FadingState.White:
{
oro.ImageMon.color = new Color(0, 0, 0, 0);
oro.HPtext.color = new Color(0, 0, 0, 0);
mol.ImageMon.color = new Color(0, 0, 0, 0);
mol.HPtext.color = new Color(0, 0, 0, 0);
wow.color = new Color(0, 0, 0, 0);
FadingTime += Time.deltaTime;
if (FadingTime > 3.0f)
{
metalShining.state = Metal.Shining.Hide;
fadingstate = FadingState.Fadeout;
FadingTime = 0f;
}
}
break;
case FadingState.Fadeout:
{
metalShining.MetalShining();
FadingTime += Time.deltaTime;
if (FadingTime > 2.0f)
{
imagewhite.color = new Color(255, 255, 255, 0);
FadingTime = 0f;
fadingstate = FadingState.End;
}
else
{
imagewhite.color = new Color(255, 255, 255, 1 - FadingTime / 2);
}
}
break;
case FadingState.End:
{
metalShining.MetalShining();
}
break;
}
}
public void SceneChanging(ref Monster FirstAtk, ref Monster SecondAtk, ref Hero ZZ, ref Text wow, ref Metal metalShining)
{
switch (scenestate)
{
case SceneState.PreFight:
{
scenetime += Time.deltaTime;
metalShining.Image.color = new Color(1, 1, 1, 0);
wow.color = new Color(1, 1, 1, 0);
if (scenetime > 0.2f)
{
scenestate = SceneState.MonsterFight;
scenetime = 0;
}
}
break;
case SceneState.MonsterFight:
{
scenetime += Time.deltaTime;
MonsterFighting(ref FirstAtk, ref SecondAtk);
if (FirstAtk.HPnow < 500 && FirstAtk.DamageText.color == new Color(1, 1, 1, 0))
{
ZZ.State = Hero.HeroState.PreAttack;
scenestate = SceneState.HeroFight;
scenetime = 0;
}
}
break;
case SceneState.HeroFight:
{
scenetime += Time.deltaTime;
ZZ.zzAttack(ref FirstAtk, ref SecondAtk);
if (ZZ.State == Hero.HeroState.Attack)
{
fadingstate = FadingState.Fadein;
scenestate = SceneState.Wow;
}
}
break;
case SceneState.Wow:
{
wowUpdate(ref wow);
scenetime += Time.deltaTime;
ZZ.zzAttack(ref FirstAtk, ref SecondAtk);
FadeInFadeOut(ref metal, ref orochi, ref moltres);
if (fadingstate == FadingState.White)
{
scenestate = SceneState.Ending;
}
}
break;
case SceneState.Ending:
{
FadeInFadeOut(ref metal, ref orochi, ref moltres);
scenestate = SceneState.Ending;
ZZ.ImageOri.sprite = ZZ.ImageEnd;
ZZ.ImageOri.transform.localPosition = new Vector3(425, -100, 0);
}
break;
}
}
/// <summary>
/// Have the HUD gradually fade it's opacity to near-invisible.
/// </summary>
public void FadeOut()
{
state = FadingState.OUT;
elapsed = 0f;
}
// Use this for initialization
void Start()
{
actualState = FadingState.Unmuted;
}
internal void Fade(FadingState state)
{
StartStopTimer(state);
}
/// <summary>
/// Update the bar, processing how much it should fade a bar.
/// </summary>
public void Update()
{
double seconds = ServiceManager.Game.DeltaTime;
CheckForHold(seconds);
// Do nothing if the bar is not being faded.
if (state == FadingState.NONE)
return;
elapsed += (float)seconds;
if (state == FadingState.IN)
{
if (elapsed > fadeInTime)
{
StopFading();
}
else
{
if (this.Opacity < inOpacity)
{
this.Opacity += .1f;
}
else
{
state = FadingState.NONE;
holdElapsed = 0f;
holding = true;
}
}
}
else
{
if (elapsed > fadeOutTime)
{
StopFading();
}
else
{
if (this.Opacity > outOpacity)
this.Opacity -= .025f;
}
}
if (IsPulsing)
{
DoPulse();
}
}
/// <summary>
/// Have the HUD gradually fade it's opacity to 100% visible.
/// </summary>
public void FadeIn()
{
state = FadingState.IN;
elapsed = 0f;
}
/// <summary>
/// Stop fading the HUD immediately.
/// </summary>
private void StopFading()
{
state = FadingState.NONE;
elapsed = 0f;
}
/// <summary>
/// Have the HUD gradually fade it's opacity to 100% visible.
/// </summary>
public void FadeIn()
{
state = FadingState.IN;
elapsed = 0f;
}
/// <summary>
/// Have the HUD gradually fade it's opacity to near-invisible.
/// </summary>
public void FadeOut()
{
state = FadingState.OUT;
elapsed = 0f;
}
void OnRenderObject()
{
#if UNITY_EDITOR
if (!previewInEditor && !Application.isPlaying)
{
return;
}
#endif
bool seeThroughReal = seeThroughIntensity > 0 && (this.seeThrough == SeeThroughMode.AlwaysWhenOccluded || (this.seeThrough == SeeThroughMode.WhenHighlighted && _highlighted));
if (!_highlighted && !seeThroughReal)
{
return;
}
// Check camera culling mask
Camera cam = Camera.current;
int cullingMask = cam.cullingMask;
// Ensure renderers are valid and visible (in case LODgroup has changed active renderer)
if (!ignoreObjectVisibility)
{
for (int k = 0; k < rmsCount; k++)
{
if (rms [k].renderer != null && rms [k].renderer.isVisible != rms [k].renderWasVisibleDuringSetup)
{
SetupMaterial();
break;
}
}
}
// Apply effect
float glowReal = _highlighted ? this.glow : 0;
int layer = gameObject.layer;
if (fxMatMask == null)
{
return;
}
// First create masks
for (int k = 0; k < rmsCount; k++)
{
Transform t = rms [k].transform;
if (t == null)
{
continue;
}
Mesh mesh = rms [k].mesh;
if (mesh == null)
{
continue;
}
if (((1 << t.gameObject.layer) & cullingMask) == 0)
{
continue;
}
if (!rms [k].renderer.isVisible)
{
continue;
}
if (rms [k].skinnedMesh)
{
cbMask.Clear();
cbMask.DrawRenderer(rms[k].renderer, fxMatMask);
Graphics.ExecuteCommandBuffer(cbMask);
}
else
{
Vector3 lossyScale = t.lossyScale;
Vector3 position = t.position;
if (rms [k].bakedTransform)
{
if (rms [k].currentPosition != t.position || rms [k].currentRotation != t.eulerAngles || rms [k].currentScale != t.lossyScale)
{
BakeTransform(k, true);
}
rms [k].renderingMatrix = Matrix4x4.identity;
}
else
{
rms [k].renderingMatrix = Matrix4x4.TRS(position, t.rotation, lossyScale);
}
fxMatMask.SetPass(0);
Graphics.DrawMeshNow(mesh, rms [k].renderingMatrix);
}
}
// Compute tweening
float fade = 1f;
if (fading != FadingState.NoFading)
{
if (fading == FadingState.FadingIn)
{
if (fadeInDuration > 0)
{
fade = (Time.time - fadeStartTime) / fadeInDuration;
if (fade > 1f)
{
fade = 1f;
fading = FadingState.NoFading;
}
}
}
else if (fadeOutDuration > 0)
{
fade = 1f - (Time.time - fadeStartTime) / fadeOutDuration;
if (fade < 0f)
{
fade = 0f;
fading = FadingState.NoFading;
_highlighted = false;
if (OnObjectHighlightEnd != null)
{
OnObjectHighlightEnd(gameObject);
}
SendMessage("HighlightEnd", null, SendMessageOptions.DontRequireReceiver);
}
}
}
if (glowHQ)
{
glowReal *= 0.25f;
}
// Add effects
for (int k = 0; k < rmsCount; k++)
{
Transform t = rms [k].transform;
if (t == null)
{
continue;
}
Mesh mesh = rms [k].mesh;
if (mesh == null)
{
continue;
}
if (((1 << t.gameObject.layer) & cullingMask) == 0)
{
continue;
}
if (!rms [k].renderer.isVisible)
{
continue;
}
// See-Through
if (seeThroughReal)
{
if (rms [k].skinnedMesh)
{
cbSeeThrough.Clear();
for (int l = 0; l < mesh.subMeshCount; l++)
{
if (l < rms [k].fxMatSeeThrough.Length && rms [k].fxMatSeeThrough [l] != null)
{
cbSeeThrough.DrawRenderer(rms [k].renderer, rms [k].fxMatSeeThrough [l], l);
}
}
Graphics.ExecuteCommandBuffer(cbSeeThrough);
}
else
{
for (int l = 0; l < mesh.subMeshCount; l++)
{
if (l < rms [k].fxMatSeeThrough.Length && rms [k].fxMatSeeThrough [l] != null)
{
rms [k].fxMatSeeThrough [l].SetPass(0);
Graphics.DrawMeshNow(mesh, rms [k].renderingMatrix, l);
}
}
}
}
if (!_highlighted)
{
return;
}
// Glow
for (int l = 0; l < mesh.subMeshCount; l++)
{
if (glow > 0)
{
rms [k].fxMatGlow.SetVector("_GlowDirection", Vector3.zero);
for (int j = 0; j < glowPasses.Length; j++)
{
rms [k].fxMatGlow.SetColor("_GlowColor", glowPasses [j].color);
rms [k].fxMatGlow.SetVector("_Glow", new Vector4(fade * glowReal * glowPasses [j].alpha, glowPasses [j].offset * glowWidth / 100f, glowMagicNumber1, glowMagicNumber2));
if (glowHQ)
{
for (int o = 0; o < offsets.Length; o++)
{
Vector3 direction = offsets [o];
direction.y *= cam.aspect;
rms [k].fxMatGlow.SetVector("_GlowDirection", direction);
if (rms [k].skinnedMesh)
{
cbGlow.Clear();
cbGlow.DrawRenderer(rms [k].renderer, rms [k].fxMatGlow, l);
Graphics.ExecuteCommandBuffer(cbGlow);
}
else
{
rms [k].fxMatGlow.SetPass(0);
Graphics.DrawMeshNow(mesh, rms [k].renderingMatrix, l);
}
}
}
else
{
if (rms [k].skinnedMesh)
{
cbGlow.Clear();
cbGlow.DrawRenderer(rms [k].renderer, rms [k].fxMatGlow, l);
Graphics.ExecuteCommandBuffer(cbGlow);
}
else
{
rms [k].fxMatGlow.SetPass(0);
Graphics.DrawMeshNow(mesh, rms [k].renderingMatrix, l);
}
}
}
}
if (outline > 0)
{
Color outlineColor = this.outlineColor;
outlineColor.a = outline * fade;
rms [k].fxMatOutline.SetColor("_OutlineColor", outlineColor);
if (outlineHQ)
{
for (int o = 0; o < offsets.Length; o++)
{
Vector3 direction = offsets [o] * (outlineWidth / 100f);
direction.y *= cam.aspect;
rms [k].fxMatOutline.SetVector("_OutlineDirection", direction);
if (rms [k].skinnedMesh)
{
cbOutline.Clear();
cbOutline.DrawRenderer(rms [k].renderer, rms [k].fxMatOutline, l);
Graphics.ExecuteCommandBuffer(cbOutline);
}
else
{
rms [k].fxMatOutline.SetPass(0);
Graphics.DrawMeshNow(mesh, rms [k].renderingMatrix, l);
}
}
}
else
{
if (rms [k].skinnedMesh)
{
cbOutline.Clear();
cbOutline.DrawRenderer(rms [k].renderer, rms [k].fxMatOutline, l);
Graphics.ExecuteCommandBuffer(cbOutline);
}
else
{
rms [k].fxMatOutline.SetPass(0);
Graphics.DrawMeshNow(mesh, rms [k].renderingMatrix, l);
}
}
}
if (overlay > 0)
{
if (l < rms [k].fxMatOverlay.Length && rms [k].fxMatOverlay [l] != null)
{
Color overlayColor = this.overlayColor;
overlayColor.a = overlay * fade;
rms [k].fxMatOverlay [l].color = overlayColor;
rms [k].fxMatOverlay [l].SetVector("_OverlayData", new Vector3(overlayAnimationSpeed, overlayMinIntensity, overlayBlending));
if (rms [k].skinnedMesh)
{
cbOverlay.Clear();
cbOverlay.DrawRenderer(rms [k].renderer, rms [k].fxMatOverlay [l], l);
Graphics.ExecuteCommandBuffer(cbOverlay);
}
else
{
rms [k].fxMatOverlay [l].SetPass(0);
Graphics.DrawMeshNow(mesh, rms [k].renderingMatrix, l);
}
}
}
if (innerGlow > 0 && innerGlowWidth > 0)
{
Color innerGlowColorA = innerGlowColor;
innerGlowColorA.a = innerGlow * fade;
rms [k].fxMatInnerGlow.SetColor("_Color", innerGlowColorA);
if (rms [k].skinnedMesh)
{
cbInnerGlow.Clear();
cbInnerGlow.DrawRenderer(rms [k].renderer, rms [k].fxMatInnerGlow, l);
Graphics.ExecuteCommandBuffer(cbInnerGlow);
}
else
{
rms [k].fxMatInnerGlow.SetPass(0);
Graphics.DrawMeshNow(mesh, rms [k].renderingMatrix, l);
}
}
}
if (targetFX)
{
// Stay?
float fadeOut = 1f;
if (Application.isPlaying)
{
fadeOut = (Time.time - highlightStartTime);
if (fadeOut >= targetFXStayDuration)
{
fadeOut -= targetFXStayDuration;
fadeOut = 1f - fadeOut;
}
if (fadeOut > 1f)
{
fadeOut = 1f;
}
}
if (fadeOut > 0)
{
// Get scale
float scaleT = 1f;
float time;
if (Application.isPlaying)
{
scaleT = (Time.time - highlightStartTime) / targetFXTransitionDuration;
if (scaleT > 1f)
{
scaleT = 1f;
}
scaleT = Mathf.Sin(scaleT * Mathf.PI * 0.5f);
time = Time.time;
}
else
{
time = (float)DateTime.Now.Subtract(DateTime.Today).TotalSeconds;
}
Bounds bounds = rms [k].renderer.bounds;
Vector3 size = bounds.size;
float minSize = size.x;
if (size.y < minSize)
{
minSize = size.y;
}
if (size.z < minSize)
{
minSize = size.z;
}
size.x = size.y = size.z = minSize;
size = Vector3.Lerp(size * targetFXInitialScale, size * targetFXEndScale, scaleT);
Quaternion camRot = Quaternion.LookRotation(cam.transform.position - rms [k].transform.position);
Quaternion rotation = Quaternion.Euler(0, 0, time * targetFXRotationSpeed);
camRot *= rotation;
Vector3 center = targetFXCenter != null ? targetFXCenter.transform.position : bounds.center;
Matrix4x4 m = Matrix4x4.TRS(center, camRot, size);
Color color = targetFXColor;
color.a *= fade * fadeOut;
rms [k].fxMatTarget.color = color;
rms [k].fxMatTarget.SetPass(0);
Graphics.DrawMeshNow(quadMesh, m);
}
}
}
}
/// <summary>
/// Stop fading the HUD immediately.
/// </summary>
private void StopFading()
{
state = FadingState.NONE;
elapsed = 0f;
}
/// <summary>
/// Start or finish highlight on the object
/// </summary>
public void SetHighlighted(bool state)
{
if (!Application.isPlaying)
{
_highlighted = state;
return;
}
if (fading == FadingState.NoFading)
{
fadeStartTime = Time.time;
}
if (state && !ignore)
{
if (_highlighted && fading == FadingState.NoFading)
{
return;
}
if (OnObjectHighlightStart != null)
{
if (!OnObjectHighlightStart(gameObject))
{
return;
}
}
SendMessage("HighlightStart", null, SendMessageOptions.DontRequireReceiver);
highlightStartTime = Time.time;
if (fadeInDuration > 0)
{
if (fading == FadingState.FadingOut)
{
float remaining = fadeOutDuration - (Time.time - fadeStartTime);
fadeStartTime = Time.time - remaining;
}
fading = FadingState.FadingIn;
}
else
{
fading = FadingState.NoFading;
}
_highlighted = true;
Refresh();
}
else if (_highlighted)
{
if (fadeOutDuration > 0)
{
if (fading == FadingState.FadingIn)
{
float elapsed = Time.time - fadeStartTime;
fadeStartTime = Time.time + elapsed - fadeInDuration;
}
fading = FadingState.FadingOut; // when fade out ends, highlighted will be set to false in OnRenderObject
}
else
{
fading = FadingState.NoFading;
_highlighted = false;
if (OnObjectHighlightEnd != null)
{
OnObjectHighlightEnd(gameObject);
}
SendMessage("HighlightEnd", null, SendMessageOptions.DontRequireReceiver);
}
}
}
public void FadeOutMusic(float duration)
{
fadingVelocity = audio.volume / duration;
actualState = FadingState.FadingOut;
}
public override void Initialize()
{
mCamera = new Camera();
State = FadingState.FadeIn;
Visibility = new SteppingProgress(2f);
}
