// Use this for initialization
void Start()
{
brickCount++;
levelManager = GameObject.FindObjectOfType<LevelManager> ();
hitCount = 0;
print (brickCount);
}
public override void Awake()
{
base.Awake();
level = LevelManager.Instance;
stats = GameStatistics.Instance;
}
void Start()
{
LM = FindObjectOfType<LevelManager>();
pauseUIOverlay.SetActive(false);
isGamePaused = false;
transitionScene = false;
}
void Start()
{
audio_source = GetComponent<AudioSource> ();
if (new_level) {
SelectMusic ();
new_level = false;
}
levelManager = GameObject.Find ("LevelLogic").GetComponent<LevelManager> ();
enemyManager = GameObject.Find ("LevelLogic").GetComponent<EnemyManager> ();
playerManager = GameObject.Find ("LevelLogic").GetComponent<PlayerManager> ();
//Form level
levelManager.InitLevelMap ();
//Update Each Tile in map - includeds asigning values through CA
levelManager.UpdateGapsAndPlatforms ();
levelManager.UpdateLevelMap ();
//Draw level
levelMap = levelManager.GetLevelMap ();
levelManager.DrawLevelMap ();
//Get level map tile array
//levelMap = levelManager.GetLevelMap ();
enemyManager.LoadMap (levelMap);
playerManager.LoadMap (levelMap);
//Player must be loaded after level for raycasting to work
playerManager.LoadPlayerSpawn ();
playerManager.LoadEndPoint ();
enemyManager.LoadEnemySpawns ();
}
// Use this for initialization
void Start () {
Debug.Log("Player Spawned");
SpawnPlayer();
levelManager = FindObjectOfType<LevelManager>();
lives = 3;
}
void Start () {
if (instance != null && instance != this) { Destroy (gameObject); }
else { instance = this; GameObject.DontDestroyOnLoad(gameObject); }
if (!formation) formation = enemyFormation.GetComponent<FormationController>();
if (!formation) Debug.Log ("formation 2 pickup error");
frameboard = GameObject.FindWithTag("Frameboard").GetComponent<Text>();
if (!frameboard) Debug.LogError("FAIL tag Frameboard");
scoreboard = GameObject.FindWithTag("Scoreboard").GetComponent<Text>();
if (!scoreboard) Debug.LogError("FAIL tag Scoreboard");
waveboard = GameObject.FindWithTag("Waveboard").GetComponent<Text>();
if (!waveboard) Debug.LogError("FAIL tag Waveboard");
playerMaxHealth = 420f;
playerHitPoints = playerMaxHealth;
playerShipCount = playerMaxShips;
bCredit = false;
creditButton.gameObject.SetActive(true);
creditMessage.gameObject.SetActive(false);
enemyFormation.gameObject.SetActive(false);
loseMessage.gameObject.SetActive(false);
quitButton.gameObject.SetActive(true);
startButton.gameObject.SetActive(true);
startMessage.gameObject.SetActive(true);
startOverButton.gameObject.SetActive(false);
waveboard.gameObject.SetActive(false);
winMessage.gameObject.SetActive(false);
ShowMyShips();
priorShipCount = playerShipCount;
fps = 0.0f;
showFramerate = true; // TODO turn off for relase
totalFrames = 0;
totalFrameTime = 0f;
waveNumber = 1;
}
void Awake()
{
levelManager = LevelManager.levelManager;
myTransform = transform;
initialPosition = myTransform.localPosition;
// Si on ne veut pas de la liste classique, on doit renseigner ceux que l'on veut ainsi que les poids associés
if (specificPickup.Length > 0) {
for (int i = 0; i < specificPickup.Length; i++) {
// Si le pickup n'est pas activé, on passe au suivant
if (!IsPickupActivated (specificPickup [i]))
continue;
listeBonus.Add (specificPickup[i]);
int currentWeight = 0;
// Si l'on ne veut pas les poids standards, on doit les changer également (il doit aussi y en avoir 1 pour 1 pickup)
if (specificPickup.Length == specificWeight.Length) {
currentWeight = specificWeight [i];
} else {
currentWeight = specificPickup [i].weight;
}
weightBonus.Add (currentWeight);
}
} else {
for (int i = 0; i < ListManager.current.powerups.Length; i++) {
// Si le pickup n'est pas activé, on passe au suivant
if (!IsPickupActivated (ListManager.current.powerups[i]))
continue;
listeBonus.Add (ListManager.current.powerups[i]);
weightBonus.Add (ListManager.current.powerups[i].weight);
}
}
}
// Use this for initialization
void Start()
{
levelManager = GameObject.Find("LevelManager").GetComponent<LevelManager>();
transform.position = transform.position.normalized*levelManager.worldRadius;
nextSpawnRemainingTime = UnityEngine.Random.Range(2.0f, 5.0f);
}
void Start()
{
Screen.showCursor = false;
manager = (GameObject.Find("LevelManager").GetComponent("LevelManager")) as LevelManager;
player_sound_manager = (GameObject.Find("MainPlayer").GetComponent("PlayerSoundManager")) as PlayerSoundManager;
current_level = Application.loadedLevel;
player = GameObject.Find("MainPlayer");
player.transform.position = start_pos.transform.position;
fade_in.FadeIn();
player.tag = "Player";
CharacterMotor motor = LevelManager.player.GetComponent("CharacterMotor") as CharacterMotor;
if(current_level == 3 && !boosted)
{
boosted = true;
motor.movement.maxForwardSpeed += 0.5f;
motor.movement.maxBackwardsSpeed += 0.5f;
motor.movement.maxSidewaysSpeed += 0.5f;
motor.jumping.baseHeight += 0.02f;
motor.jumping.extraHeight += 0.02f;
default_speed = motor.movement.maxForwardSpeed;
default_jump = motor.jumping.baseHeight;
}
else if(current_level == 3)
{
motor.movement.maxForwardSpeed = default_speed;
motor.movement.maxBackwardsSpeed = default_speed;
motor.movement.maxSidewaysSpeed = default_speed;
motor.jumping.baseHeight = default_jump;
motor.jumping.extraHeight = default_jump;
}
}
void Start () {
if (instance != null && instance != this) { Destroy (gameObject); }
else { instance = this; GameObject.DontDestroyOnLoad(gameObject); }
// hintBoard = GameObject.Find ("HintBoard").GetComponent<Text>(); // remaining bricks counter in-scene
scoreBoard = GameObject.Find ("ScoreBoard").GetComponent<Text>();
ShowMyBalls ();
}
// Use this for initialization
void Start()
{
player = GameObject.FindGameObjectWithTag("Player");
LM = (LevelManager)FindObjectOfType(typeof(LevelManager));
Debug.Log("Starting #" + nHumans);
myTransform = transform;
spriteObj = GetComponent<exSprite>();
spriteAnimation = GetComponent<exSpriteAnimation>();
// Determine if I should be an alien.
if (nAliens < maxAliens) {
float pAlien = 0;
if (nHumans >= nHandlers - maxAliens) {
pAlien = 1;
}
else {
pAlien = Random.Range(0, nHandlers);
}
if (pAlien <= 1 || nHumans >= nHandlers ) {
Debug.Log("Human "+ nHumans + " Is an ALIEN!");
isAlien = true;
nAliens++;
nHumans++;
}
else {
Debug.Log("Human "+ nHumans + " Is a HUMAN!");
nHumans++;
}
}
//EventManager.instance.AddListener(this, "Oso_clicked");
if (isAlien) {
audio.pitch = 1.75f;
}
}
// Use this for initialization
public void Setup(LevelManager _lm)
{
name = "UI";
_levman = _lm;
transform.position = new Vector3(Camera.main.transform.position.x, Camera.main.transform.position.y, -100f);
GameEventManager.GameStart += GameStart;
GameEventManager.GameOver += GameOver;
GameEventManager.Respawn += Respawn;
_IngameUI = FETool.findWithinChildren(this.gameObject, "Ingame").GetComponent<IngameUI>();
_GameOverUI = FETool.findWithinChildren(this.gameObject, "GameOver").GetComponent<GameOverUI>();
_EntryUI = FETool.findWithinChildren(this.gameObject, "EntryMenu").GetComponent<EntryUI>();
_EndGameUI = FETool.findWithinChildren(this.gameObject, "EndGame").GetComponent<EndGameUI>();
BottomPos = FETool.findWithinChildren(gameObject, "BottomPos").transform;
TopPos = FETool.findWithinChildren(gameObject, "TopPos").transform;
_IngameUI.SetupSub(this);
_IngameUI.Setup();
_GameOverUI.SetupSub(this);
_GameOverUI.Setup();
_EntryUI.SetupSub(this);
_EntryUI.Setup();
_EndGameUI.SetupSub(this);
_EndGameUI.Setup();
if (_lm._profile.SETUP.GameType == GameSetup.versionType.Demo)
{
_IngameUI.initPos = IngamePlaceDemo;
_GameOverUI.lbInitpos = LeaderboardPlaceDemo;
_EndGameUI.lbInitpos = LeaderboardPlaceDemo;
}
}
void Start()
{
leftmost = (Camera.main.ViewportToWorldPoint(new Vector2(0,0)) + new Vector3(this.GetComponent<SpriteRenderer>().sprite.bounds.size.x / 2 + buffer, 0, 0));
rightmost = (Camera.main.ViewportToWorldPoint(new Vector2(1,0)) - new Vector3(this.GetComponent<SpriteRenderer>().sprite.bounds.size.x / 2 + buffer, 0, 0));
hpBar = GameObject.Find("HealthBar").GetComponent<Image>();
levelManager = GameObject.FindObjectOfType<LevelManager>();
}
void Awake()
{
levelManager = FindObjectOfType<LevelManager>();
scoreManager = FindObjectOfType<ScoreManager>();
ballController = FindObjectOfType<BallController>();
anim = GetComponent<Animator>();
}
// Use this for initialization
void Start()
{
Config config = GetComponent<Config>();
m_levelManager = GetComponent<LevelManager>();
m_scoreTable = config.ScoreTable;
m_scoreMultipliers = config.ScoreMultipliers;
}
/// <summary>
/// Called at the start of the level
/// </summary>
void Start()
{
myInstance = this;
// Play BGM
SoundManager.Instance.PlayBGM(0);
}
// Use this for initialization
void Start()
{
text = GetComponent<Text> ();
playerHealth = maxPlayerHealth;
levelManager = FindObjectOfType<LevelManager> ();
isDead = false;
}
void Awake()
{
if (myInstance == null)
{
myInstance = this;
}
else
{
DestroyImmediate(gameObject);
return;
}
levelToLoadString = PlayerPrefs.GetString(nextLevelStringPref, "");
if (levelToLoadString != "")
{
LoadLevel(levelToLoadString);
return;
}
levelToLoadInt = PlayerPrefs.GetInt(nextLevelIntPref, -1);
if (levelToLoadInt != -1)
{
LoadLevel(levelToLoadInt);
}
}
void OnDestroy()
{
myInstance = null;
PlayerPrefs.DeleteKey(nextLevelStringPref);
PlayerPrefs.DeleteKey(nextLevelIntPref);
}
// Use this for initialization
void Start()
{
currentTime = initTime;
timeText = this.GetComponent<Text>();
levelManager = GameObject.Find("LevelMan").GetComponent<LevelManager>();
printTime((int)currentTime);
}
public void Setup(LevelManager _lev)
{
_spr = FETool.findWithinChildren(gameObject, "TheGate").GetComponentInChildren<OTSprite>();
_levMan = _lev;
GameEventManager.Respawn += Respawn;
GameEventManager.GameOver += GameOver;
firstStep = FETool.findWithinChildren(gameObject, "ExitLoc/1");
secondStep = FETool.findWithinChildren(gameObject, "ExitLoc/2");
thirdStep = FETool.findWithinChildren(gameObject, "ExitLoc/3");
spriteFirstStep = firstStep.GetComponentsInChildren<OTSprite>();
spriteSecondStep = secondStep.GetComponentsInChildren<OTSprite>();
spriteThirdStep = thirdStep.GetComponentsInChildren<OTSprite>();
fadeSprites(spriteFirstStep, 0f);
fadeSprites(spriteSecondStep, 0f);
fadeSprites(spriteThirdStep, 0f);
for (int i = 0 ; i < 24 ; i++)
{
slotList.Add(FETool.findWithinChildren(gameObject, "Slots/" + (i+1).ToString()));
}
defaultSlot = FETool.findWithinChildren(gameObject, "Slots/Default");
Vortex = FETool.findWithinChildren(gameObject, "Vortex").GetComponentInChildren<OTAnimatingSprite>();
}
void Start()
{
levelManager = FindObjectOfType<LevelManager>();
animator = GetComponentInChildren<Animator>();
transform = gameObject.transform;
speed = Random.Range(levelManager.Speed + 2, maxSpeed);
}
// Use this for initialization
void Start ()
{
isBreakable = (this.tag == "Breakable");
if (isBreakable)
numberOfBricks++;
levelManager = GameObject.FindObjectOfType<LevelManager> ();
}
void Start()
{
manager = GameObject.FindObjectOfType<LevelManager>();
Vector3 scale = gameObject.transform.localScale;
scale.x = 0;
gameObject.transform.localScale = scale;
}
void Start()
{
timer = GetComponent<Slider> ();
levelManager = GameObject.FindObjectOfType<LevelManager> ();
winLabel = GameObject.Find ("Survived");
winLabel.SetActive (false);
}
void Start()
{
levelManager = GameObject.FindObjectOfType<LevelManager>();
ball = GameObject.FindObjectOfType<Ball>();
textLife = GameObject.FindObjectOfType<Text>();
paddle = GameObject.FindObjectOfType<Paddle>();
}
public void Start()
{
manager = GameObject.Find("Manager").GetComponent<LevelManager>();
player = GameObject.Find("Player").GetComponent<Player>();
initialPosition = new Vector3(7.5f,0.73f,-8.9f);
player.SetPosition(initialPosition);
player.SetRotation(new Quaternion(0f,0f,0f,0));
gameOver = false;
xLimit1 = -10.8f;
xLimit2 = 8f;
yLimit1 = 0.3f;
yLimit2 = 4f;
zLimit1 = -9.5f;
zLimit2 = 9.5f;
radiusFood = 0.5f;
counter = 0f;
previousCounter = 0f;
foodObjects = new string[]{"FoodApple","FoodBanana","FoodCandyCane"};
timerLimit = 2.0f;
timer = timerLimit;
player.SetActive(true);
CreateFoodObjects(foodQty);
}
void MakeInstance()
{
if (instance == null )
{
instance = this;
}
}
// Use this for initialization
void Start()
{
//Filter load private resources
levelmanager = GameObject.FindObjectOfType<LevelManager> ();
timesHit = 0;
}
void Awake()
{
if (Instance != null) Debug.LogError("Should be only one level manager!");
Instance = this;
for (var i = 0; i < dimx; i++)
for (var j = 0; j < dimy; j++)
{
var x = (i - 9) * _gridStep;
var y = (j - 9) * _gridStep;
_positions[i, j] = new Vector2(x, y);
_obstacles[i, j] = false;
}
var walls = GameObject.FindGameObjectsWithTag(WallsTag);
if (walls == null) Debug.LogError("No walls found!");
foreach (var wall in walls)
{
var x = wall.transform.position.x;
var y = wall.transform.position.y;
var i = Mathf.RoundToInt(x / _gridStep + ((dimx / 2f) - 1f));
var j = Mathf.RoundToInt(y / _gridStep + ((dimy / 2f) - 1f));
_obstacles[i, j] = true;
}
GameManager.Dead += Dead;
}
void Start()
{
lm = GetComponent <LevelManager>();
}
// Start is called before the first frame update
void Start()
{
theLevelManager = FindObjectOfType <LevelManager>();
}
// TODO NEED A NEWLEVELLOADED FUNCTION THAT WILL UPDATE ALL THE UI ELEMENTS WITH VALUES FROM THE LEVELMANAGER
public void NewLevelWasLoaded(LevelManager lm, int roundNumber)
{
this.LM = lm;
SetRoundText(roundNumber);
SetVis_LevelCanvasUI(true);
}
private void Awake()
{
levelGoals = LevelInfoData.GetLevelGoals(LevelManager.GetLevelEnum(SceneManager.GetActiveScene().name));
}
public LevelGoals GetLevelGoals()
{
return(LevelInfoData.GetLevelGoals(LevelManager.GetLevelEnum(SceneManager.GetActiveScene().name)));
}
public ArenaPhase2State(string nextState, LevelManager levelManager, GameObject mob1)
{
this.nextState = nextState;
this.levelManager = levelManager;
this.mob1 = mob1;
}
private void LevelCompleted(LevelManager level)
{
curentLevel.OnLevelCompleted -= LevelCompleted;
Debug.Log("Level finished");
}
private void Start()
{
levelManager = GameObject.Find("LevelManager").GetComponent <LevelManager>();
}
void Awake()
{
_inputActions = new InputActions();
_levelManager = transform.GetComponent <LevelManager>();
}
/// <summary>
/// Rescale all of the asteroids to be the size they should be for a grid
/// with a specified tile size.
/// </summary>
/// <param name="unitsPerTile">Length of 1 grid tile</param>
public static void RescaleAsteroids(float unitsPerTile)
{
// Reset scaling lists
largeAsteroidScales.Clear();
LargeRadii.Clear();
smallAsteroidScales.Clear();
SmallRadii.Clear();
chaserAsteroidScales.Clear();
ChaserRadii.Clear();
Vector3 asteroidScale = new Vector3();
for (int i = 0; i < normalAsteroids.Count; i++)
{
asteroidScale = LevelManager.GetScaleSpriteToTileSize(
normalAsteroids[i].GetComponent <SpriteInfo>(),
unitsPerTile);
asteroidScale.x
= (asteroidScale.x * GameManager.AsteroidToTileSizeRatio);
asteroidScale.y
= (asteroidScale.y * GameManager.AsteroidToTileSizeRatio);
largeAsteroidScales.Add(asteroidScale);
largeAsteroidRadii.Add(
unitsPerTile * GameManager.AsteroidToTileSizeRatio);
}
// Reset small asteroid scales & radii
for (int i = 0; i < smallAsteroids.Count; i++)
{
asteroidScale
= LevelManager.GetScaleSpriteToTileSize(
smallAsteroids[i].GetComponent <SpriteInfo>(),
unitsPerTile);
asteroidScale.x
= (asteroidScale.x * GameManager.AsteroidToTileSizeRatio)
* GameManager.SmallToLargeAsteroidRatio;
asteroidScale.y
= (asteroidScale.y * GameManager.AsteroidToTileSizeRatio)
* GameManager.SmallToLargeAsteroidRatio;
smallAsteroidScales.Add(asteroidScale);
smallAsteroidRadii.Add(unitsPerTile
* GameManager.AsteroidToTileSizeRatio
* GameManager.SmallToLargeAsteroidRatio);
}
// Reset chaser asteroid scales & radii
for (int i = 0; i < chaserAsteroids.Count; i++)
{
asteroidScale
= LevelManager.GetScaleSpriteToTileSize(
chaserAsteroids[i].GetComponent <SpriteInfo>(),
unitsPerTile);
asteroidScale.x
= (asteroidScale.x * GameManager.AsteroidToTileSizeRatio)
* GameManager.SmallToLargeAsteroidRatio;
asteroidScale.y
= (asteroidScale.y * GameManager.AsteroidToTileSizeRatio)
* GameManager.SmallToLargeAsteroidRatio;
chaserAsteroidScales.Add(asteroidScale);
chaserAsteroidRadii.Add(unitsPerTile
* GameManager.AsteroidToTileSizeRatio
* GameManager.SmallToLargeAsteroidRatio);
}
}
public ASTAR(LevelManager level)
{
this.level = level;
}
void Awake()
{
levelManager = GameObject.FindObjectOfType <LevelManager>();
powerManager = GameObject.FindObjectOfType <PowerManager>();
scoreManager = GameObject.FindObjectOfType <ScoreManager>();
}
public void SetUp()
{
// System under test.
LevelManager = MyGame.Manager.LevelManager;
LevelManager.Initialize(CONTENT_ROOT);
}
// Use this for initialization
void Start()
{
m_Rigidbody = GetComponent <Rigidbody>();
levelManager = (LevelManager)FindObjectOfType(typeof(LevelManager));
animator = GetComponent <Animator>();
}
// Start is called before the first frame update
void Start()
{
manager = FindObjectOfType <LevelManager>();
manager.soundsource.PlayOneShot(manager.Powerappearsound);
}
// Use this for initialization
void Start()
{
mario = FindObjectOfType <Mario> ();
t_LevelManager = FindObjectOfType <LevelManager> ();
}
// Use this for initialization
void Start()
{
theLevelManager = FindObjectOfType <LevelManager>();
theCircleCollider2D = GetComponent <CircleCollider2D>();
}
void Start()
{
levelmanager = LevelManager.FindObjectOfType <LevelManager> ();
}
private void Awake()
{
instance = this;
}
// Update is called once per frame
void Update()
{
timer -= Time.deltaTime;
if (chaos >= numberOfStudents && timer >= 0)
{
state = GameState.Finished;
perdeu.SetActive(true);
// PERDER
}
else if (chaos < numberOfStudents && timer <= 0)
{
// Vencer
LevelManager lm = LevelManager.sharedInstance;
if (lm.level < lm.maxLevel)
{
state = GameState.ChangingLevel;
}
else
{
state = GameState.Finished;
ganhou.SetActive(true);
}
}
else // Evita que o jogador continue ganhando pontos após o término do jogo
{
timeSinceLastTick += Time.deltaTime;
if (timeSinceLastTick >= scoreTick)
{
IncrementScore();
}
if (childsToCorrupt > 0)
{
corruptTimer -= Time.deltaTime;
if (corruptTimer <= 0)
{
int selected = Random.Range(0, students.Length - 1);
int iterator = selected;
while (students[iterator].status != StudentStatus.Neutral)
{
iterator = (iterator + 1) % students.Length;
if (iterator == selected)
{
break;
}
}
if (students[iterator].status == StudentStatus.Neutral)
{
students[iterator].bagunca = students[iterator].threshold;
}
corruptTimer = timeToCorrupt;
childsToCorrupt--;
}
}
}
switch (state)
{
case GameState.Light:
if (chaos >= enterMediumState)
{
bgAudioSource.ChangeMusic(mediumBGM, false);
state = GameState.Medium;
}
break;
case GameState.Medium:
if (chaos >= enterHeavyState)
{
bgAudioSource.ChangeMusic(heavyBGM, false);
//bgAudioSource.ChangeBGMVolume(0.5f);
state = GameState.Heavy;
}
break;
case GameState.Heavy:
break;
case GameState.ChangingLevel:
if (students[0].enabled)
{
bgAudioSource.PlaySoundEffect(StartingSound, 0);
foreach (Student s in students)
{
s.myDesk.objectInPlace.gameObject.SetActive(false);
s.enabled = false;
}
}
finishedLevel.SetActive(true);
//LevelManager.sharedInstance.FinishLevel();
break;
case GameState.Finished:
timer += Time.deltaTime;
GameObject.FindObjectOfType <TimerBarComponent>().enabled = false;
foreach (Student s in students)
{
s.myDesk.objectInPlace.gameObject.SetActive(false);
s.enabled = false;
}
GameObject temp = (ganhou.activeSelf == true ? ganhou : perdeu);
Text finalScoreText = temp.transform.Find("score final").gameObject.GetComponent <Text>();
Text highScoreText = temp.transform.Find("Highscore value").gameObject.GetComponent <Text>();
Text recorde = temp.transform.Find("Recorde").gameObject.GetComponent <Text>();
finalScoreText.text = scoreText.text;
int hs = PlayerPrefs.GetInt(Constants.HIGH_SCORE_KEY);
if (score > hs) // Highscore
{
PlayerPrefs.SetInt(Constants.HIGH_SCORE_KEY, score);
recorde.enabled = true;
hs = score;
}
highScoreText.text = hs.ToString();
break;
}
}
// Use this for initialization
void Start()
{
lm = FindObjectOfType <LevelManager> ();
cam = FindObjectOfType <Magnify> ();
pm = FindObjectOfType <PlayerManager> ();
}
void Start()
{
LEVEL = levelManager.GetComponent <LevelManager>();
GAME = this;
SwitchState(State.INIT);
}
private void Start()
{
LevelManager.GetInstance().SetActiveDisplayPressE(false);
}
protected virtual void Start()
{
levelManager = FindObjectOfType <LevelManager>();
CheckTeleportPositionAndId();
didMyThing = false;
}
void LateUpdate()
{
int recSocketId;
int recConnectionId; // Reconoce la ID del jugador
int recChannelId;
byte[] recBuffer = new byte[NetworkConsts.bufferSize];
int dataSize;
byte error;
NetworkEventType recNetworkEvent = NetworkTransport.Receive(out recSocketId, out recConnectionId, out recChannelId, recBuffer, NetworkConsts.bufferSize, out dataSize, out error);
NetworkError Error = (NetworkError)error;
if (Error == NetworkError.MessageToLong)
{
//Trata de capturar el mensaje denuevo, pero asumiendo buffer más grande.
recBuffer = new byte[NetworkConsts.bigBufferSize];
recNetworkEvent = NetworkTransport.Receive(out recSocketId, out recConnectionId, out recChannelId, recBuffer, NetworkConsts.bigBufferSize, out dataSize, out error);
}
switch (recNetworkEvent)
{
case NetworkEventType.Nothing:
break;
case NetworkEventType.ConnectEvent:
if (NotInClientScene())
{
if (GetLocalPlayer())
{
LevelManager lm = FindObjectOfType <LevelManager>();
lm.ShowReconnectingMessage(false);
GetLocalPlayer().Connect(true);
}
}
Debug.Log("Connection succesfull");
break;
case NetworkEventType.DataEvent:
Stream stream = new MemoryStream(recBuffer);
BinaryFormatter formatter = new BinaryFormatter();
string message = formatter.Deserialize(stream) as string;
if (recChannelId == unreliableChannelId || recChannelId == reliableLittleChannelId)
{
handler.HandleMessage(message);
}
if (recChannelId == reliableBigChannelId)
{
ReceiveMessageFromPlanner(message, recConnectionId);
}
if (debug)
{
Debug.Log(HoraMinuto() + " - " + message);
}
break;
case NetworkEventType.DisconnectEvent:
if (connectionId == recConnectionId) // Detectamos que fuimos nosotros los que nos desconectamos
{
Reconnecting();
}
Debug.Log("Disconnected from server");
break;
}
}
void Awake()
{
levelManager = GameObject.FindObjectOfType <LevelManager>();
}
// Controls the pausing of the scene
/*public void pauseControl()
* {
* if (Time.timeScale == 1)
* {
* Time.timeScale = 0;
* showPaused();
* }
* else if (Time.timeScale == 0)
* {
* Time.timeScale = 1;
* hidePaused();
* }
* }
*
* // Shows objects with ShowOnPause tag
* public void showPaused()
* {
* foreach (GameObject g in pauseObjects)
* {
* g.SetActive(true);
* }
* }
*
* // Hides objects with ShowOnPause tag
* public void hidePaused()
* {
* foreach (GameObject g in pauseObjects)
* {
* g.SetActive(false);
* }
* }*/
// Loads inputted level
public void LoadLevel(int level)
{
LevelManager.ReloadLevel(level);
}
void Awake()
{
LevelManager.GetInstance().RegisterCanPressELabel(m_label_can_press_e);
}
//GameObject[] pauseObjects;
// Use this for initialization
/*(void Start()
* {
* Time.timeScale = 1;
* pauseObjects = GameObject.FindGameObjectsWithTag("ShowOnPause");
* hidePaused();
* }
*
* // Update is called once per frame
* void Update()
* {
* // Uses p button to pause and unpause the game
* if (Input.GetKeyDown(KeyCode.P))
* {
* if (Time.timeScale == 1)
* {
* Time.timeScale = 0;
* showPaused();
* }
* else if (Time.timeScale == 0)
* {
* Time.timeScale = 1;
* hidePaused();
* }
* }
* }*/
// Reloads the level
public void Reload()
{
LevelManager.ReloadLevel(2);
}
void Start()
{
lm = gameObject.GetComponentInParent <LevelManager>();
}
