void Start()
{
fade = GameObject.FindGameObjectWithTag("Fader").GetComponent<ScreenFade>();
guiText = GameObject.Find("Text").GetComponent<GUIText>();
StartCoroutine(manageTextInput());
}
// Use this for initialization
void Start ()
{
//JUSTIN
healthBar = GameObject.Find("BossHealthBar").GetComponent<RectTransform>();
healthBarOrigin = healthBar.localPosition;
maxHealth = health;
if(name == "TermiteQueenBoss")
{
health = 1;
StartCoroutine(handleHealthSpinup());
}
//JUSTIN
if(fadeScript == null)
{
fadeScript = GameObject.FindObjectOfType<ScreenFade>();
}
if (fadeScript != null && fadeScript.gameObject.activeSelf)
{
fadeScript.StartCoroutine(fadeScript.FadeFromBlack());
}
meshList = GetComponentsInChildren<MeshRenderer>();
skinnedMeshList = GetComponentsInChildren<SkinnedMeshRenderer>();
phase = 0;
maxPhase = healthThresholds.Length;
meshStartingAngle = mesh.transform.eulerAngles;
}
void Start()
{
canvasObject = GameObject.Find ("Canvas");
canvasTransform = canvasObject.GetComponent<RectTransform> ();
iconTransform = GetComponent<RectTransform> ();
// reset canvas hierarchy so ScreenFade is always on top (masks UI/HUD on fade)
sFader = GameObject.Find ("Screen Fade").GetComponent<ScreenFade> ();
sFader.ResetParent ();
pManager = GameObject.Find ("Pause Manager").GetComponent<PauseManager> ();
}
public void Reset()
{
this.xGoGoBanana = null;
this.iGameOverCounter = 0;
this.bHasPressed = false;
this.liPlayersHasPressed.Clear();
this.bGoingToRespawn = false;
this.byEntryPoint = 0;
this.enZoneInstead = Level.ZoneEnum.None;
this.byZoningSpecial = 0;
this.iRoguelike_NextEssence = 100000;
}
public static int constructor(IntPtr l)
{
int result;
try
{
ScreenFade o = new ScreenFade();
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, o);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
public static int IsFading(IntPtr l)
{
int result;
try
{
ScreenFade screenFade = (ScreenFade)LuaObject.checkSelf(l);
bool b = screenFade.m_luaExportHelper.IsFading();
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, b);
result = 2;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
// Use this for initialization
void Start()
{
player = GameObject.FindGameObjectWithTag("MainCamera");
playerOrb = GameObject.Find("Orb");
orbScript = playerOrb.GetComponent <Orb>();
orbInd = GameObject.Find("OrbIndicator").GetComponent <OrbIndicator>();
orbP = GameObject.Find("OrbParticle").GetComponent <ParticleSystem>();
fade = GameObject.Find("Player").GetComponent <ScreenFade>();
fade.SetScreenOverlayColor(new Color(0, 0, 0, 0));
orbHasClearSpace = true;
canFire = true;
audioSource = GetComponent <AudioSource>();
//indicator2 = GameObject.Find("Particle Gravity Hole");
// Particle fix (why does this happen).
GameObject.Find("Particle Gravity Hole").transform.parent = orbInd.gameObject.transform;
orbInd.Deactivate(orbInd.gameObject);
}
public void Start()
{
// get current scene number and maximum scene index
sceneIndex = SceneManager.GetActiveScene().buildIndex;
currentSceneIndex = sceneIndex;
maxSceneIndex = SceneManager.sceneCountInBuildSettings - 1;
// fade in
fadeLevel = 1;
fadeTime = -1;
// create screen faders
faders = ScreenFade.AttachToAllCameras();
// create action handlers for next/prev scene selection
actionNext = InputHandler.Find(actionNameNext);
actionPrev = InputHandler.Find(actionNamePrev);
}
//==============================================================================
// MonoBehaviours
//==============================================================================
//==============================================================================
public void Start()
{
m_GazeBase = GetComponent <GazeBase>();
m_GazeBase.onGazeBeginCallBack += OnGazeStart;
m_GazeBase.onGazeEndCallBack += OnGazeEnd;
m_ScreenFade = FindObjectOfType <ScreenFade>();
m_isMoving = false;
m_isLookedAt = false;
m_moveDirection = Vector3.zero;
m_Camera = FindObjectOfType <OVRManager>().GetComponent <Transform>();
if (m_text != null)
{
m_text.GetComponent <Renderer>().enabled = false;
}
}
public void StartScene(string scenePath)
{
ScreenFade screenFade = Instantiate(
Constants.Get <GameObject>("prefabScreenFadeOut"),
Vector3.zero,
Quaternion.identity
).GetComponent <ScreenFade>();
screenFade.stopTime = true;
screenFade.onComplete = () => {
AsyncOperation asyncLoad = SceneManager.LoadSceneAsync(
scenePath,
LoadSceneMode.Single
);
asyncLoad.allowSceneActivation = true;
};
enabled = false;
}
private void Update( )
{
if (screenFade == ScreenFade.Default)
{
return;
}
else
{
Color color = mat.GetColor("_FadeToColor");
if (screenFade == ScreenFade.FadeToBlack)
{
if (color.r > 0.0f)
{
float offset = 0.5f * Time.deltaTime;
color.r -= offset;
color.g -= offset;
color.b -= offset;
mat.SetColor("_FadeToColor", color);
}
else
{
screenFade = ScreenFade.Default;
GameLord.instance.OnBlackout( );
}
}
else if (screenFade == ScreenFade.FadeFromBlack)
{
if (color.r < 1.0f)
{
float offset = 0.5f * Time.deltaTime;
color.r += offset;
color.g += offset;
color.b += offset;
mat.SetColor("_FadeToColor", color);
}
else
{
screenFade = ScreenFade.Default;
}
}
}
}
public static int set_m_image(IntPtr l)
{
int result;
try
{
ScreenFade screenFade = (ScreenFade)LuaObject.checkSelf(l);
Image image;
LuaObject.checkType <Image>(l, 2, out image);
screenFade.m_luaExportHelper.m_image = image;
LuaObject.pushValue(l, true);
result = 1;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
public static int set_m_color(IntPtr l)
{
int result;
try
{
ScreenFade screenFade = (ScreenFade)LuaObject.checkSelf(l);
Color color;
LuaObject.checkType(l, 2, out color);
screenFade.m_luaExportHelper.m_color = color;
LuaObject.pushValue(l, true);
result = 1;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
public static int Update(IntPtr l)
{
int result;
try
{
ScreenFade screenFade = (ScreenFade)LuaObject.checkSelf(l);
float dt;
LuaObject.checkType(l, 2, out dt);
screenFade.Update(dt);
LuaObject.pushValue(l, true);
result = 1;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
private void Initialize()
{
ResetLevelManager();
if (!IsMenuScene())
{
AssignPlayerComponents();
AssignLastEnemyComponents();
// Find inactive GameObjects
GameObject transitionCanvas = GameObject.Find(Names.TransitionCanvas);
victoryText = transitionCanvas.transform.Find(Names.VictoryText).gameObject;
defeatText = transitionCanvas.transform.Find(Names.DefeatText).gameObject;
screenFade = UnityEngine.Camera.main.GetComponent <ScreenFade>();
screenFade.SetScreenFade(false);
}
PlayThemeSong();
}
private void ReloadLobby()
{
this.CachedRoomList.Clear();
CreateGui();
if (PhotonNetwork.InRoom)
{
PhotonNetwork.LeaveRoom();
NetworkManager.Instance.WhenConnectedToMaster(this, () =>
{
PhotonNetwork.JoinLobby();
ScreenFade.FadeIn();
});
}
else
{
PhotonNetwork.JoinLobby();
ScreenFade.FadeIn();
}
}
public override void Init()
{
Input.On(Control.Start, NavigateToMainMenu);
Input.On(Control.Select, NavigateToMainMenu);
Add(new ScreenClickable(NavigateToMainMenu));
var anim1 = new ScreenFade {
Duration = TimeSpan.FromSeconds(3.4), FromAlpha = 255, ToAlpha = 0
};
var anim2 = new ScreenFade {
Duration = TimeSpan.FromSeconds(1), FromAlpha = 0, ToAlpha = 0
};
var anim3 = new ScreenFade {
Duration = TimeSpan.FromSeconds(1), FromAlpha = 0, ToAlpha = 255
};
Add(new CenteredRawImage(_logoImage));
Add(anim1);
Add(anim2);
Add(anim3);
anim1.Start(() => anim2.Start(() => anim3.Start(NavigateToMainMenu)));
}
// Update is called once per frame
void Update()
{
hit = Physics.RaycastAll(transform.position, (target.transform.position - transform.position).normalized,
Vector3.Distance(target.transform.position, transform.position), 1);
for (int i = 0; i < hit.Length; i++)
{
ScreenFade temp = hit[i].collider.gameObject.GetComponent <ScreenFade>();
if (temp)
{
temp.amount = hit.Length;
temp.timer = 0;
}
}
// to modify the camera positions until they are right these are both in update
// set the camera rotation to the desired rotation
transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.Euler(Angle), Time.deltaTime);
//transform.rotation.eulerAngles.Set(Angle.x,Angle.y,Angle.z);
// set the camera position to the player position + an offset where the player is assumed to be the parent
transform.position = Vector3.Lerp(transform.position, target.transform.position + offset, Time.deltaTime);
}
public static int FadeOut(IntPtr l)
{
int result;
try
{
ScreenFade screenFade = (ScreenFade)LuaObject.checkSelf(l);
float time;
LuaObject.checkType(l, 2, out time);
Color color;
LuaObject.checkType(l, 3, out color);
Action onEnd;
LuaObject.checkDelegate <Action>(l, 4, out onEnd);
screenFade.FadeOut(time, color, onEnd);
LuaObject.pushValue(l, true);
result = 1;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
protected override void Update(GameTime gameTime)
{
HandleInput();
multiplayerManager.Update(gameTime);
gameStateManager.Update(gameTime);
ScreenFade.Update(gameTime);
if (quitGame)
{
Exit();
return;
}
if (newChanges && !FullScreen)
{
FullScreen = true;
newChanges = false;
}
else if (newChanges && FullScreen)
{
FullScreen = false;
newChanges = false;
}
int outputx = 0;
for (int i = output.Count - 1; i >= 0; i--)
{
output[i].Update(gameTime);
if (output[i].Timer <= 0)
{
output.RemoveAt(i);
}
else
{
output[i].Position = new Vector2(60, outputx);
outputx += 30;
}
}
}
//-----------------------------------------------------------------------------
// OnGUI
//-----------------------------------------------------------------------------
// void OnGUI(){
// //draw buttons:
// DrawFadeButton();
// DrawCameraFlashButton();
// DrawInjuryButton();
// }
//-----------------------------------------------------------------------------
// Private Methods
//-----------------------------------------------------------------------------
void DrawFadeButton()
{
//decide text to display on the button based on state of fadeDirection:
string fadeText = fadeDirection ? "down" : "up";
if (GUILayout.Button("Fade " + fadeText))
{
//set type of fadeDirection:
currentFadeType = FadeType.Fade;
//toggle state of fadeDirection:
fadeDirection = !fadeDirection;
//fade up or down based on state of fadeDirection:
if (fadeDirection)
{
ScreenFade.Fade(Color.black, ScreenFade.CurrentAlpha, 1, 1, 0, false);
}
else
{
ScreenFade.Fade(Color.black, ScreenFade.CurrentAlpha, 0, 1, 0, false);
}
}
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
graphics.PreferredBackBufferWidth = Globals.ScreenWidth;
graphics.PreferredBackBufferHeight = Globals.ScreenHeight;
IsMouseVisible = true;
graphics.ApplyChanges();
// TODO: use this.Content to load your game content here
blankRecImg = Content.Load <Texture2D>("Assets/blankrec");
bigFont = Content.Load <SpriteFont>("Assets/bigfont");
plaques = new Dictionary <string, Texture2D> {
{ "123", Content.Load <Texture2D>("Assets/correct1st2nd3rd") },
{ "12", Content.Load <Texture2D>("Assets/correct1st2nd") },
{ "13", Content.Load <Texture2D>("Assets/correct1st3rd") },
{ "23", Content.Load <Texture2D>("Assets/correct2nd3rd") },
{ "1", Content.Load <Texture2D>("Assets/correct1st") },
{ "2", Content.Load <Texture2D>("Assets/correct2nd") },
{ "3", Content.Load <Texture2D>("Assets/correct3rd") }
};
betsImg = Content.Load <Texture2D>("Assets/bets");
betButtons = new List <Button> {
new Button(blankRecImg, new Rectangle(75, 300, 100, 100)),
new Button(blankRecImg, new Rectangle(225, 300, 100, 100)),
new Button(blankRecImg, new Rectangle(375, 300, 100, 100)),
new Button(blankRecImg, new Rectangle(525, 300, 100, 100)),
new Button(blankRecImg, new Rectangle(675, 300, 100, 100)),
new Button(blankRecImg, new Rectangle(825, 300, 100, 100))
};
startBtn = new Button(blankRecImg, new Rectangle(450, 500, 150, 100));
horseAniImg = new List <Texture2D> {
Content.Load <Texture2D>("Assets/horse1ani"),
Content.Load <Texture2D>("Assets/horse2ani"),
Content.Load <Texture2D>("Assets/horse3ani"),
Content.Load <Texture2D>("Assets/horse4ani"),
Content.Load <Texture2D>("Assets/horse5ani"),
Content.Load <Texture2D>("Assets/horse6ani")
};
placeImg = new List <Texture2D> {
Content.Load <Texture2D>("Assets/1st"),
Content.Load <Texture2D>("Assets/2nd"),
Content.Load <Texture2D>("Assets/3rd"),
Content.Load <Texture2D>("Assets/4th"),
Content.Load <Texture2D>("Assets/5th"),
Content.Load <Texture2D>("Assets/6th")
};
placeBets = Content.Load <Texture2D>("Assets/placeyourbets");
logo = Content.Load <Texture2D>("Assets/logo");
buttons = new List <Texture2D> {
Content.Load <Texture2D>("Assets/bet"),
Content.Load <Texture2D>("Assets/race"),
Content.Load <Texture2D>("Assets/menu")
};
bg = Content.Load <Texture2D>("Assets/bg");
horseAni = new List <Animation> {
new Animation(horseAniImg[0], 4, 1, 4, 1, 2, Animation.ANIMATE_FOREVER, 10, new Vector2(0, 0), 1, true),
new Animation(horseAniImg[1], 4, 1, 4, 1, 2, Animation.ANIMATE_FOREVER, 10, new Vector2(0, 0), 1, true),
new Animation(horseAniImg[2], 4, 1, 4, 1, 2, Animation.ANIMATE_FOREVER, 10, new Vector2(0, 0), 1, true),
new Animation(horseAniImg[3], 4, 1, 4, 1, 2, Animation.ANIMATE_FOREVER, 10, new Vector2(0, 0), 1, true),
new Animation(horseAniImg[4], 4, 1, 4, 1, 2, Animation.ANIMATE_FOREVER, 10, new Vector2(0, 0), 1, true),
new Animation(horseAniImg[5], 4, 1, 4, 1, 2, Animation.ANIMATE_FOREVER, 10, new Vector2(0, 0), 1, true)
};
scrollBg = new ScrollingBg(bg);
screenFade = new ScreenFade();
finishLine = Content.Load <Texture2D>("Assets/finish");
inMenu = true;
pauseTime = new List <Texture2D> {
Content.Load <Texture2D>("Assets/1"),
Content.Load <Texture2D>("Assets/2"),
Content.Load <Texture2D>("Assets/3")
};
Reset();
}
// Use this for initialization
void Start()
{
alert = GameObject.Find("Alert System").GetComponent<AlertManager>();
roomX = 0;
roomZ = 0;
dButton = GameObject.Find("Door Button").GetComponent<DoorButton>();
playerObject = GameObject.FindGameObjectWithTag("Player");
level = GameObject.Find("Level").GetComponent<Level>();
nextRoomInformation = GameObject.Find("NextRoomInfo").GetComponent<NextRoomInfo>();
currentRoom = transform.parent.parent.parent.GetComponent<Room>();
if(currentRoom){
roomX = currentRoom.xIndex;
roomZ = currentRoom.zIndex;
}
leftDoor = transform.Find("LeftDoor");
rightDoor = transform.Find("RightDoor");
closedScale = leftDoor.localScale;
openScale = new Vector3(leftDoor.localScale.x * 0.1f, leftDoor.localScale.y, leftDoor.localScale.z);;
targetScale = closedScale;
leftDoorClosedPosition = leftDoor.transform.position;
leftDoorOpenPosition = leftDoor.transform.position + (-transform.right * 0.3f);
targetLeftDoorPosition = leftDoorClosedPosition;
rightDoorClosedPosition = rightDoor.transform.position;
rightDoorOpenPosition = rightDoor.transform.position + (transform.right * 0.3f);
targetRightDoorPosition = rightDoorClosedPosition;
canvasObject = GameObject.Find("Canvas");
sFade = GameObject.Find("Screen Fade").GetComponent<ScreenFade>();
}
//JUSTIN
// Use this for initialization
void Start()
{
scoreHandle = GameObject.Find("Score").GetComponent<Score>(); //JUSTIN
loadout = GameObject.FindGameObjectWithTag ("SaveManager").GetComponent<SavedGameManager> ().getCurrentGame ().getCurrentLoadout ();
shrinkCollider = GetComponent<CircleCollider2D>();
setLoadout ();
hitCool = false;
dead = false;
//determines chassis health type
if (chassisExterminator || chassisBooster || chassisShrink) {
health = 3;
}
else if (chassisQuick)
{
health = 2;
}
else if (chassisFinal)
{
if((SceneIndex)SceneManager.GetActiveScene().buildIndex == SceneIndex.GAMEPLAY_4_2)
{
health = 5;
}
else
{
health = 1;
}
}
//determines chassis movement speed type
if (chassisExterminator || chassisFinal)
{
moveSpeed = 10f;
precisionSpeed = 6f;
}
else if (chassisBooster)
{
moveSpeed = 8f;
precisionSpeed = 14f;
}
else if (chassisShrink)
{
moveSpeed = 6f;
precisionSpeed = 4f;
}
else if (chassisQuick)
{
moveSpeed = 12f;
precisionSpeed = 8f;
}
hBorder = GameObject.FindGameObjectWithTag ("Border").GetComponent<HealthBorder> ();
sf = GameObject.Find ("ScreenFade").GetComponent<ScreenFade> ();
hBorder.health = health;
if (health == 5) {
hBorder.fiveHealth = true;
}
}
private void Start( )
{
screenFade = ScreenFade.Default;
mat.SetColor("_FadeToColor", Color.black);
}
// Use this for initialization
void Awake()
{
instance = this;
}
// Use this for initialization
void Start()
{
player = GameObject.FindGameObjectWithTag("Player").transform;
canvasTransform = GameObject.Find("Canvas").GetComponent<RectTransform>();
endButtonTransform = GameObject.Find("Level End Button").GetComponent<RectTransform>();
sFade = GameObject.Find("Screen Fade").GetComponent<ScreenFade>();
}
public override void Update()
{
CheckForNewPlayers();
m_timerMSPrevious = m_timerMS;
m_elapsedTimeMSPrevious = m_elapsedTime;
if (Game.AIGameData.IsIdleAIRunning == false || m_matchState != MatchState.FirstPeriod)
{
m_timerMS -= Engine.GameTime.ElapsedMS;
m_elapsedTime += Engine.GameTime.ElapsedMS;
}
UpdateMatchSoundEvents();
if (m_matchState == MatchState.Init)
{
if (m_elapsedTime > 0)
{
m_elapsedTime = 0;
ChangeState(MatchState.Begin);
}
}
if (m_matchState == MatchState.Begin)
{
if (m_elapsedTime >= m_matchBeginTimer)
{
m_elapsedTime = 0;
ChangeState(MatchState.FirstPeriod);
Game.Stats.MatchStart();
}
}
if (m_matchState == MatchState.FirstPeriod)
{
if (m_elapsedTime >= m_halfTimeDuration)
{
m_elapsedTime = 0;
ChangeState(MatchState.HalfTime);
}
}
else if (m_matchState == MatchState.HalfTime)
{
Ball ball = Game.GameManager.Ball;
if (m_matchStateStep == 0 && m_elapsedTime >= m_halfTimePauseDuration[0])
{
ball.BodyCmp.Body.LinearDamping += 0.005f * Engine.GameTime.ElapsedMS;
if (ball.Player != null || !ball.BodyCmp.Body.Awake || ball.BodyCmp.Body.LinearVelocity.LengthSquared() < 0.01f)
{
m_elapsedTime = 0;
m_matchStateStep = 1;
ball.BodyCmp.Body.LinearDamping = ball.Parameters.Physic.LinearDamping;
ScreenFade screenFade = new ScreenFade();
Owner.Attach(screenFade);
screenFade.StartFade(ScreenFade.FadeType.FadeOut, 500, false);
}
}
else if (m_matchStateStep == 1 && m_elapsedTime >= m_halfTimePauseDuration[1])
{
m_elapsedTime = 0;
m_matchStateStep = 4;;
Engine.World.EventManager.ThrowEvent((int)EventId.HalfTimeTransition);
if (Game.GameManager.Tutorial.Enabled)
{
m_matchStateStep = 2;
m_tutorialSprite.Visible = true;
}
else
{
m_matchStateStep = 4;
ScreenFade screenFade = Owner.FindComponent <ScreenFade>();
screenFade.StartFade(ScreenFade.FadeType.FadeIn, 500, true);
}
}
else if (m_matchStateStep == 2 && m_elapsedTime >= m_tutorialDisplayDuration)
{
m_elapsedTime = 0;
m_matchStateStep = 4;
m_tutorialSprite.Visible = false;
ScreenFade screenFade = Owner.FindComponent <ScreenFade>();
screenFade.StartFade(ScreenFade.FadeType.FadeIn, 1000, true);
}
else if (m_matchStateStep == 4 && m_elapsedTime >= m_halfTimePauseDuration[2])
{
ChangeState(MatchState.SecondPeriodBegin);
}
}
else if (m_matchState == MatchState.SecondPeriodBegin)
{
if (m_elapsedTime >= m_matchBeginTimer)
{
m_elapsedTime = 0;
ChangeState(MatchState.SecondPeriod);
}
}
else if (m_matchState == MatchState.SecondPeriod)
{
if (m_elapsedTime >= m_halfTimeDuration)
{
m_elapsedTime = 0;
ChangeState(MatchState.End);
}
}
else if (m_matchState == MatchState.End)
{
Ball ball = Game.GameManager.Ball;
if (m_matchStateStep == 0 && m_elapsedTime >= m_endGamePauseDuration[0])
{
ball.BodyCmp.Body.LinearDamping += 0.005f * Engine.GameTime.ElapsedMS;
if (ball.Player != null || !ball.BodyCmp.Body.Awake || ball.BodyCmp.Body.LinearVelocity.LengthSquared() < 0.01f)
{
m_elapsedTime = 0;
m_matchStateStep++;
ball.BodyCmp.Body.LinearDamping = ball.Parameters.Physic.LinearDamping;
ScreenFade screenFade = new ScreenFade();
Owner.Attach(screenFade);
screenFade.StartFade(ScreenFade.FadeType.FadeOut, 500, false);
}
}
else if (m_matchStateStep == 1 && m_elapsedTime >= m_endGamePauseDuration[1])
{
m_elapsedTime = 0;
m_matchStateStep++;
Engine.World.EventManager.ThrowEvent((int)EventId.Victory);
ScreenFade screenFade = Owner.FindComponent <ScreenFade>();
screenFade.StartFade(ScreenFade.FadeType.FadeIn, 500, true);
}
else if (m_matchStateStep == 2 && m_elapsedTime >= m_endGamePauseDuration[2])
{
m_elapsedTime = 0;
m_matchStateStep++;
Engine.World.EventManager.ThrowEvent((int)EventId.MatchFinalize);
Game.Stats.MatchEnd();
}
}
}
private void Awake()
{
curr = this;
fade = 1;
SetColor();
}
// Use this for initialization
void Start()
{
GameOverCount = gameOverCount;
fader = GetComponent<ScreenFade>();
}
static void CheckInstance(){
if ( _instance == null ) {
//create singleton:
GameObject screenFadeGameObject = new GameObject( "Screen Fade" );
DontDestroyOnLoad( screenFadeGameObject );
_instance = screenFadeGameObject.AddComponent<ScreenFade>();
//create texture:
_texture = new Texture2D( 1, 1, TextureFormat.ARGB32, false );
ChangeColor( _currentColor, false );
}
}
void OnDestroy(){
_instance = null;
}
//-----------------------------------------------------------------------------
// Deallocation
//-----------------------------------------------------------------------------
void OnDestroy()
{
_instance = null;
}
// Use this for initialization
void Start()
{
//rInfo = GameObject.Find("RoomInfo").GetComponent<RoomInfo>();
sFade = GameObject.Find("Screen Fade").GetComponent<ScreenFade>();
//destinationRoomObject = gameObject;
//destinationDoorObject = gameObject;
currentRoom = transform.parent.parent.parent.GetComponent<Room> ();
roomX = currentRoom.xIndex;
roomZ = currentRoom.zIndex;
}
// Use this for initialization
void Start()
{
sFade = GameObject.Find("Screen Fade").GetComponent<ScreenFade>();
sFade.FadeIn();
Invoke("StartLoad", 2);
}
void Start()
{
mainCanvas = GameObject.Find ("Canvas");
timeScaler = GameObject.Find ("Time Manager").GetComponent<TimeScaler>();
healthManager = GameObject.Find ("Health Manager").GetComponent<HealthManager> ();
screenFader = GameObject.Find ("Screen Fade").GetComponent<ScreenFade> ();
blurFX = GameObject.FindWithTag ("MainCamera").GetComponent<BlurOptimized> ();
blurFX.enabled = false;
pauseScreen.SetActive (false);
failScreen.SetActive (false);
invHUD = GameObject.Find ("HUD_Inventory").GetComponent<HUD_Inventory> ();
healthHUD = GameObject.Find("HUD_Healthbar").GetComponent<HUD_Healthbar>();
timeButton = GameObject.Find("Time Button");
pauseButton = GameObject.Find ("PauseButton");
mapButton = GameObject.Find ("Map Button");
alertCountdown = GameObject.Find ("AlertCountdownIcon");
}
void Awake()
{
globalInstance = this;
}
void Start()
{
screenFade = GameObject.Find("ScreenFade").GetComponent <ScreenFade>();
}
// Use this for initialization
void Start()
{
fader = GameObject.Find ("Screen Fade").GetComponent<ScreenFade> ();
fader.ResetParent ();
ResetBox ();
startTime = Time.realtimeSinceStartup;
boxSize = new Vector3 (400, 140, 0);
cornerSize = new Vector3 (15, 15, 0);
tutorialTransform = GetComponent<RectTransform> ();
Invoke ("InterruptTutorial", 5);
}
/// <summary>Fades the screen to the given colour in the given amount of time.</summary>
public Promise fade(UnityEngine.Color col, float time)
{
return(ScreenFade.Fade(this, col, time));
}
// Use this for initialization
void Start()
{
boxCol = GetComponent<BoxCollider>();
playerTransform = GameObject.FindGameObjectWithTag("Player").transform;
hudInv = GameObject.Find ("HUD_Inventory").GetComponent<HUD_Inventory> ();
cController = Camera.main.GetComponent<CameraController> ();
Time.timeScale = 1;
fade = GameObject.Find("Screen Fade").GetComponent<ScreenFade>();
tintImage = GameObject.Find("Upgrade Fader").GetComponent<RawImage>();
tintImage.color = new Color(1,1,1,0);
instructionText = GameObject.Find("InstructionText").GetComponent<Text>();
instructionText.color = new Color(0,0,0,0);
activateText = GameObject.Find("ActivateText").GetComponent<Text>();
activateText.color = new Color(0,0,0,0);
}
void Start()
{
sf = GameObject.Find("ScreenFade").GetComponent<ScreenFade>();
StartCoroutine("LevelLayout2");
}
void Awake()
{
S = this;
rateOfChangeFloat = maxAlpha / 100f;
waitTime = timeToFade / 100f;
}
// Use this for initialization
void Start()
{
fadeIn = GetComponent <ScreenFade>();
fadeIn.StartCoroutine("CloseWindow");
}
// Use this for initialization
void Start()
{
vxe = VoxelExtractionPointCloud.Instance;
myAnim = GetComponent<Animator> ();
auSource = GetComponent<AudioSource> ();
screenFadeScript = playerTrans.GetComponent<ScreenFade> ();
playerGazeScript = playerTrans.GetComponent<TutorialGaze> ();
pocketWatch = pWatchPokeScript.gameObject;
pWatchPokeScript.enabled = false;
SetMeshRenderersInChildren (pocketWatch, false);
auSource.pitch = 0.75f;
TheSheepDog.transform.position = watchTrans.position;
tutorialPhase = TutorialPhase.SetUpHypno;
SetMeshRenderersInChildren (tutorialSheep, false);
//Disable for now, will use GazeTutorial Later
//SetMeshRenderersInChildren (gazeTutorialGameObjects, false);
SetMainGameObjects (false);
}
protected override void End()
{
this.fade = (ScreenFade)null;
}
// Use this for initialization
void Start()
{
vxe = VoxelExtractionPointCloud.Instance;
myAnim = GetComponent<Animator> ();
auSource = GetComponent<AudioSource> ();
screenFadeScript = playerTrans.GetComponent<ScreenFade> ();
playerGazeScript = playerTrans.GetComponent<TutorialGaze> ();
pocketWatch = pWatchPokeScript.gameObject;
pWatchPokeScript.enabled = false;
SetMeshRenderersInChildren (pocketWatch, false);
auSource.pitch = 0.75f;
biome.setAllMaterials (biome.fadedMaterials [0]);
tutorialPhase = TutorialPhase.SetUpHypno;
#if GazeTut
SetMeshRenderersInChildren (tutorialSheep, false);
#endif
//Disable for now, will use GazeTutorial Later
//SetMeshRenderersInChildren (gazeTutorialGameObjects, false);
SetMainGameObjects (false);
audioCueManager.playAudioClip (audioCueManager.lookForPocketWatch);
}
void Awake()
{
fadeImage = GameObject.Find("FadeImage");
if(instance)
{
Destroy (gameObject);
hide(0f, false);
return;
}
instance = this;
fadeAlpha = 1f;
fadeImage.SetActive(true);
fadeImage.GetComponent<CanvasRenderer>().SetAlpha(fadeAlpha);
DontDestroyOnLoad(this);
}
void Start()
{
instance = this;
shouldFadeFromBlack = true;
}