private void Awake()
{
InitializeCharacterData();
sp = GetComponent <SpriteRenderer>();
res = GetComponent <Respawner>();
altSFXPlayer = GetComponent <PlaySFX>();
}
private void Start()
{
if (Respawner == null)
{
Respawner = FindObjectOfType <Respawner>();
}
}
private IEnumerator InternalSpawn(Respawner respawner, float timer)
{
yield return(new WaitForSeconds(timer));
respawner.Respawn();
Debug.Log("Respawn");
}
public void AttackUp()
{
if (detectUpAttack.PlayerInArea)
{
Respawner.Respawn();
}
}
private void OnCollisionEnter2D(Collision2D collision)
{
if (moving && collision.collider.CompareTag("Player"))
{
Respawner.Respawn();
}
}
void OnTriggerEnter(Collider other)
{
Respawner respawner = other.GetComponent <Respawner>();
if (respawner != null)
{
//Princesses can go more to the left or right
if (other.name == "Princess")
{
//Check who last had the princess
Princess princess = other.gameObject.GetComponent <Princess>();
Players thePlayer = princess.getLastThrower().i_Player;
if (thePlayer == Players.PlayerOne)
{
respawner.Kill(-Respawner.AMOUNT_TO_MOVE_OVER);
}
else
{
respawner.Kill(Respawner.AMOUNT_TO_MOVE_OVER);
}
}
else if (other.name == "PlayerOne")
{
respawner.Kill(Respawner.AMOUNT_TO_MOVE_OVER);
}
else
{
respawner.Kill(-Respawner.AMOUNT_TO_MOVE_OVER);
}
}
}
// Token: 0x0600343B RID: 13371 RVA: 0x000D6E84 File Offset: 0x000D5084
public void FixedUpdate()
{
if (Scenes.Manager)
{
Scenes.Manager.CheckForScenesFinishedLoading();
}
if (!GameController.FreezeFixedUpdate)
{
FixedRandom.FixedUpdateIndex++;
FixedRandom.UpdateValues();
}
Music.UpdateMusic();
Ambience.UpdateAmbience();
this.GameScheduler.OnGameFixedUpdate.Call();
Respawner.UpdateRespawners();
if (!GameStateMachine.Instance.IsInExtendedTitleScreen() && !UI.MainMenuVisible && (Screen.width != this.m_previousScreenWidth || Screen.height != this.m_previousScreenHeight))
{
UI.Menu.ShowResumeScreen();
}
this.m_previousScreenWidth = Screen.width;
this.m_previousScreenHeight = Screen.height;
if (this.m_lastDebugControlsEnabledValue != DebugMenuB.DebugControlsEnabled)
{
this.m_lastDebugControlsEnabledValue = DebugMenuB.DebugControlsEnabled;
}
if (!this.IsSuspended)
{
this.GameTime += Time.deltaTime;
}
}
// --------------------------------------------------------------
// Mono Methods
// --------------------------------------------------------------
private void Awake()
{
rb = GetComponent <Rigidbody2D>();
lineRenderer = GetComponent <LineRenderer>();
anim = GetComponent <Animator>();
respawner = GetComponent <Respawner>();
footSteps = GetComponent <AudioSource>();
}
public Respawner GetRespawner()
{
if (respawner == null)
{
respawner = gameObject.GetComponent <Respawner>();
}
return(respawner);
}
void OnTriggerEnter(Collider other)
{
Respawner respawner = other.gameObject.GetComponent <Respawner> ();
if (respawner)
{
respawner.Respawn();
}
}
private IEnumerator GetDeleyAfterJump()
{
yield return(new WaitForSeconds(MOVING_DELAY));
animator.SetBool(PARAM_STATE, false);
if (transform.parent == null && transform.position.y > WATER_Y_POS)
{
Respawner.RespawnPlayer();
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
Respawner res = collision.gameObject.GetComponent <Respawner>();
if (res)
{
Debug.Log("Checkpoint set");
res.setRespawnPoint(gameObject.transform.position);
}
}
void Start()
{
if (_ins != null)
{
Debug.LogError($"Multiple {this.GetType()} were instantiated");
return;
}
print("sucessfully create instance");
_ins = this;
respawn_cd = 5; // TODO: update method of initialization
}
void RespawnIfOutOfBounds()
{
if (!Respawner.Instance)
{
return;
}
if (!Respawner.Instance.Bounds.Contains(transform.position))
{
Respawner.Respawn(respawnable, respawnable.plannedRespawnPosition);
}
}
void SpawnPlayers()
{
for (var i = 0; i < nbPlayer; i++)
{
Respawner _respawner = FindAvailableRespawner();
GameObject nPlayer = SpawnPlayer(playerPrefab, i, PlayerColor[i]);
_respawner.AddPlayer(nPlayer.transform);
}
EventManager.TriggerEvent("OnStageStart");
}
private void Awake()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(this.gameObject);
}
}
internal void Start()
{
_rb = GetComponent <Rigidbody2D>();
_spriteRenderer = GetComponent <SpriteRenderer>();
_respawner = GetComponent <Respawner>();
_carryPoint = transform.Find("CarryPoint").gameObject;
_initialHealth = Health;
_timeToScore = _scoringInterval;
AssignPlayerColor();
}
private void OnTriggerEnter(Collider other)
{
if (other.GetComponent <Player>() != null)
{
if (SceneManager.GetActiveScene().name == "SceneMinigamePush")
{
MiniGamePushManager.Singleton.ResetPlayer(other.GetComponent <Player>());
}
Respawner.RespawnProcess(other.GetComponent <Player>());
}
}
public void ReceiveRespawnRequest()
{
// Get the planned respawn position and respawn to it if it is allowed to.
Vector3 directionToCenter = (transform.position - Respawner.Instance.PlayerPosition).normalized;
Vector3 respawnPosition = transform.position - directionToCenter * .5f;
plannedRespawnPosition = respawnPosition;
if (RespawnCondition == null || RespawnCondition())
{
Respawner.Respawn(this, respawnPosition);
}
}
private IEnumerator PlayTurtleAnimation()
{
animationParamState = !animationParamState;
yield return(waitForSeconds);
animator.SetBool(ANIMATOR_PARAM, animationParamState);
if (transform.childCount > 0)
{
Respawner.RespawnPlayer();
}
StartCoroutine(PlayTurtleAnimation());
}
private IEnumerator Countdown()
{
while (timer > 0)
{
timer--;
countdownLabel.text = timer.ToString();
yield return(new WaitForSeconds(1));
}
Respawner.Register();
Instantiate(HitFx, transform.position, Quaternion.identity);
Pickable.GetRelease();
}
private void Awake()
{
rb = GetComponent <Rigidbody2D>();
pV = GetComponent <PhotonView>();
lR = GetComponent <LineRenderer>();
aS = GetComponent <AudioSource>();
healthSlider = healthBar.GetComponentInChildren <Slider>();
healthBar.transform.position = transform.position;
rS = GameObject.Find("DeathText").GetComponent <Respawner>();
sP = GameObject.Find("Spawner").GetComponent <Spawner>();
sP.addPlayer("+");
}
public void ResetPlayer(Player p)
{
p.NbLife -= 1;
if (p.NbLife > 0)
{
Respawner.RespawnProcess(p);
GameManager.Instance.PlayerUI.RefreshLifePlayerUi(p, p.NbLife, p.cameraReference.transform.GetSiblingIndex());
}
else
{
// le joueur a perdu il ne réapparait pas;
/// ecran noir ?
}
GameManager.Instance.PlayerUI.RefreshLifePlayerUi(p, p.NbLife, p.cameraReference.transform.GetSiblingIndex());
}
/// <summary>
/// Called each time the attached GameObject's Collider(s) initiate contact with another Collider
/// </summary>
/// <param name="obstacle">Information about what was collided with</param>
internal void OnCollisionEnter2D(Collision2D obstacle)
{
if (IsPlayerTarget && obstacle.collider.tag == "Missile")
{
FindObjectOfType <ScoreKeeper>().ScoreKill();
var aS = GetComponent <AudioSource>();
aS.PlayOneShot(GetComponent <Ship>().Marvelous); // Play sound when ur missile destroys an enemy
}
if (!Respawner.TryRespawn(gameObject))
{
Destroy(gameObject);
}
}
/// <summary>
/// Fire periodically and respawn when we leave the screen
/// </summary>
// ReSharper disable once UnusedMember.Global
internal void Update()
{
if (Time.time - lastMissileLaunch > FiringPeriod)
{
GetComponent <MissileLauncher>().FireMissile();
lastMissileLaunch = Time.time;
}
var screenPosition = Camera.main.WorldToScreenPoint(transform.position);
if (screenPosition.x < -10 ||
screenPosition.y < -10 ||
screenPosition.y > Screen.height + 10 ||
screenPosition.x > Screen.width + 10)
{
Respawner.TryRespawn(gameObject);
}
}
void Start()
{
respawnerClass = GetComponent <Respawner>();
gameObjects = FindObjectsOfType(typeof(GameObject)) as GameObject[];
positions = new Vector2[gameObjects.Length];
rotations = new Quaternion[gameObjects.Length];
int i = 0;
foreach (GameObject go in gameObjects)
{
positions[i] = go.transform.position;
rotations[i] = go.transform.rotation;
i++;
}
}
public bool JustRespawn()
{
bool result = false;
if (IsEnable())
{
GameObject gameObject = GameObject.Find("Main");
if (null != gameObject)
{
Respawner component = gameObject.GetComponent <Respawner>();
if (null != component && component.Resurrect2())
{
result = true;
Use();
}
}
}
return(result);
}
/// <summary>
/// rabbit ref needed to handle damage on bomb pickup
/// </summary>
/// <param name="rabbit"></param>
public RabbitStats(GameObject rabbit, PlayerMovement playerMovement,
Respawner respawner, Animator anim)
{
_rabbit = rabbit;
_playerMovement = playerMovement;
_respawner = respawner;
_anim = anim;
_dieAnimHash = Animator.StringToHash("Die");
var coll = _rabbit.GetComponent <Collider2D>();
if (coll == null)
{
throw new MissingComponentException($"{nameof(rabbit)} must have a Collider2D attached");
}
_rabbitColliderVertExtent = coll.bounds.extents.y;
}
void PlayerDead(string pName, Transform transform)
{
if (lifeRemaining.ContainsKey(pName))
{
--lifeRemaining[pName].lifeRemaining;
}
if (lifeRemaining[pName].lifeRemaining > 0)
{
Respawner _respawner = FindAvailableRespawner();
_respawner.AskRespawn(transform);
}
else
{
loser = lifeRemaining[pName].reference.GetComponent <PlayerHandler>().id;
EventManager.TriggerEvent("EndGame");
StartCoroutine("EndGame");
}
EventManager.TriggerEvent("PlayerDeath");
}
/// <summary>
/// Initialize the default values.
/// </summary>
public override void Awake()
{
base.Awake();
m_Respawner = m_GameObject.GetCachedComponent <Respawner>();
if (!m_Respawner)
{
Debug.LogError("Error: The Revive ability requires the Respawner component to be added to the character.");
return;
}
// If the ragdoll is starting when the character dies then the respawner will be called manually and should not reposition the character.
if (m_StartOnDeath && Enabled)
{
m_Respawner.PositioningMode = Respawner.SpawnPositioningMode.None;
m_Respawner.ScheduleRespawnOnDeath = false;
m_Respawner.ScheduleRespawnOnDisable = false;
}
EventHandler.RegisterEvent <Vector3, Vector3, GameObject>(m_GameObject, "OnDeath", OnDeath);
EventHandler.RegisterEvent(m_GameObject, "OnAnimatorReviveComplete", OnReviveComplete);
}
void Start()
{
respawner = FindObjectOfType<Respawner>();
//connect
//PhotonNetwork.ConnectUsingSettings(Globals.version);
if(PhotonNetwork.insideLobby) {
print ("Try to connect: " + roomName);
RoomOptions options = new RoomOptions();
options.isOpen = open;
options.isVisible = visible;
options.maxPlayers = playersMax;
options.customRoomProperties = new ExitGames.Client.Photon.Hashtable() {
{"type", roomName}
};
PhotonNetwork.JoinOrCreateRoom(roomName, options, null);
}
}
