void Start()
{
playTransform = GameObject.FindGameObjectWithTag("Player").transform;
hud = GameObject.Find("Canvas").GetComponent <ManagerHUD>();
camara = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <SmoothCamera2D>();
sprRenderer = gameObject.GetComponent <SpriteRenderer>();
}
void Update()
{
if (Input.GetButtonDown("TrocaPersonagem"))
{
players[PERSONAGEM_ATUAL].transform.Find("Seta").renderer.enabled = false;
PERSONAGEM_ATUAL = (PERSONAGEM_ATUAL + 1) % numPersonagens;
players[PERSONAGEM_ATUAL].transform.Find("Seta").renderer.enabled = true;
// Toca o som do personagem atual
players[PERSONAGEM_ATUAL].audio.Play();
SmoothCamera2D smoothCamera = Camera.main.GetComponent <SmoothCamera2D>();
smoothCamera.target = players[PERSONAGEM_ATUAL];
}
if (Input.GetKeyDown(KeyCode.Escape))
{
audio.Stop();
if (GameScript.Instance != null)
{
GameScript.Instance.TocarMusica();
}
Application.LoadLevel("Menu");
}
}
void Start()
{
ClearPowerup();
soundManager = GameObject.Find("SoundManager").GetComponent <SoundManager>();
sceneManager = GameObject.Find("SceneObject").GetComponent <SceneManager>();
cameraScript = GameObject.Find("tk2dCamera").GetComponent <SmoothCamera2D>();
InitServerDisplay();
}
void Awake()
{
Transform = transform.parent.parent;
Collider = Transform.GetComponent <BoxCollider2D>();
_heatHandlers = Transform.GetComponentsInChildren <HeatHandler>();
_camera = Transform.GetComponent <AnimationScript>().CameraScript;
_controlBorder = GetComponentInChildren <ControlBorder>();
}
// ###############################################################
// Use this for initialization
void Start()
{
body = GetComponent <Rigidbody2D> ();
audioSource = GetComponent <AudioSource> ();
anim = GetComponentInChildren <Animator> ();
dirGrav = GetComponent <DirectionalGravity> ();
cam = Camera.main.GetComponent <SmoothCamera2D> ();
spawn = transform.position;
}
// Use this for initialization
void Start()
{
if (CameraObject == null)
{
CameraObject = FindObjectOfType <SmoothCamera2D>();
}
m_CameraOffset = CameraOffset;
m_StartingPosition = this.transform.position;
m_CameraStartingPosition = CameraObject.transform.position;
}
// Use this for initialization
void Start()
{
enemyStats = GetComponent<EnemyStats> ();
nav = GetComponent<NavMeshAgent> ();
anim = GetComponentInChildren<Animator> ();
courseChangeTimeIncrement = Random.Range (3f, courseChangeTimeIncrementMax);
courseTimer = courseChangeTimeIncrement;
fuseTimer = 0f;
nav.speed = crawlSpeed;
shakeCamera = GameObject.FindGameObjectWithTag (Tags.mainCamera).GetComponent<SmoothCamera2D> ();
}
void Start()
{
if(gameObject.transform.parent.name == "PlayerEmpty"){
isEquippedByPlayer = true;
playerInfoPanel = GameObject.FindGameObjectWithTag(Tags.canvas).GetComponentInChildren<PlayerInfoPanel>();
}
else{
isEquippedByPlayer = false;
}
anim = GetComponentInChildren<Animator> ();
shakeCam = GameObject.FindGameObjectWithTag (Tags.mainCamera).GetComponent<SmoothCamera2D> ();
shakeMagnitude = gameObject.GetComponent <weaponIndex>().cameraShakeMagnitude;
}
// Use this for initialization
void Start()
{
cameraMain = GameObject.FindGameObjectWithTag (Tags.mainCamera);
smoothCam = cameraMain.GetComponent<SmoothCamera2D> ();
playerTransform = GameObject.FindGameObjectWithTag(Tags.player).transform;
smoothCam.player = playerTransform;
emptyCursorTransform = GameObject.FindGameObjectWithTag(Tags.cursor).transform;
emptyCursorTransform.gameObject.GetComponent<FollowCursor> ().defaultFloorHeight = defaultFloorHeight;
smoothCam.cursor = emptyCursorTransform;
smoothCam.enabled = true;
playerTransform.GetComponent<LookAtGameObject> ().target = emptyCursorTransform;
followGameObject = cameraMain.GetComponentInChildren<FollowGameObject> ();
followGameObject.followedGO = playerTransform.gameObject;
}
public virtual void ResetCycle()
{
Object.Destroy(GameObject.FindWithTag(Tags.CYCLE));
Object.Destroy(GameObject.Find(GameCenter.PIPE));
Object.Destroy(GameObject.Find(GameCenter.SEAT));
GameObject newCycle = Object.Instantiate(manager.gameData.cycle) as GameObject;
newCycle.transform.position = cyclePos;
cameraScript = manager.mainCamera.GetComponent <SmoothCamera2D> ();
cameraScript.dampTime = 0f;
cameraScript.target = newCycle.gameObject.transform;
manager.StartCoroutine(LateInit());
}
private void InitComponenets()
{
// initiate cycle
if (cycle == null)
{
cycle = GameObject.FindWithTag(Tags.CYCLE);
}
// get cycle pipe
pipe = cycle.transform.Find(GameCenter.PIPE);
// get rigidbody from cycle
rb = cycle.GetComponent <Rigidbody2D> ();
// get wheel controller script from cycle
wheelController = cycle.GetComponent <WheelController> ();
// set cycle initial position x,y,z
//cycle.transform.position = new Vector3 (0f, 0.89f, 0f);
// get camera controller script from cycle
if (cameraScript == null)
{
cameraScript = manager.mainCamera.GetComponent <SmoothCamera2D> ();
}
// set damp time to 0
//cameraScript.dampTime = 0f;
// set camera target to cycle
cameraScript.target = cycle.gameObject.transform;
// get left control button
leftControl = GameObject.Find(GameCenter.LEFT_CONTROL);
// get right control button
rightControl = GameObject.Find(GameCenter.RIGHT_CONTROL);
//Physics2D.IgnoreCollision (leftControl.GetComponent<CircleCollider2D> (), cycle.GetComponent<CircleCollider2D> ());
//Physics2D.IgnoreCollision (rightControl.GetComponent<CircleCollider2D> (), cycle.GetComponent<CircleCollider2D> ());
//Physics2D.IgnoreCollision (leftControl.GetComponent<CircleCollider2D> (), pipe.GetComponent<CircleCollider2D> ());
//Physics2D.IgnoreCollision (rightControl.GetComponent<CircleCollider2D> (), pipe.GetComponent<CircleCollider2D> ());
}
private void HandleTouchPanning(ref Touch touchZero, ref Touch touchOne)
{
float moveCameraX = 0f;
float moveCameraY = 0f;
if ((touchZero.deltaPosition.x < 0 && touchOne.deltaPosition.x < 0) || ((touchZero.deltaPosition.x > 0 && touchOne.deltaPosition.x > 0)))
{
moveCameraX = (Mathf.Min(touchZero.deltaPosition.x, touchOne.deltaPosition.x) * m_cameraZoomSpeed) * inputCamera.orthographicSize / 12f;
}
if ((touchZero.deltaPosition.y < 0 && touchOne.deltaPosition.y < 0) || ((touchZero.deltaPosition.y > 0 && touchOne.deltaPosition.y > 0)))
{
moveCameraY = (Mathf.Min(touchZero.deltaPosition.y, touchOne.deltaPosition.y) * m_cameraZoomSpeed) * inputCamera.orthographicSize / 12f;
}
SmoothCamera2D camera2d = inputCamera.GetComponent <SmoothCamera2D>();
if ((moveCameraX != 0 || moveCameraY != 0) && (camera2d != null))
{
camera2d.MoveConnectedTarget(-moveCameraX, -moveCameraY);
myDebounceTimer = 0.5f;
}
}
//Initializes the game for each level.
public void InitGame()
{
//set the hp at his max each time he begin a new level
if (player != null)
{
player.GetComponent<Player>().hp = player.GetComponent<Player>().maxHp;
}
else
{
initialLVL = 1;
initialEXP = 0;
}
//get level of the player if player exist
level = !firstFloor ? player.GetComponent<Player>().getLevel() : 1;
infoplayer = (GameObject)Instantiate(Resources.Load("Prefabs/CanvasInfoPlayer"));
infoplayer.SetActive(true);
//get all info in the canva infoplayer
TextName = GameObject.Find("TextName").GetComponent<Text>();
TextHp = GameObject.Find("TextHp").GetComponent<Text>();
TextStats = GameObject.Find("TextStats").GetComponent<Text>();
TextLevel = GameObject.Find("TextLevel").GetComponent<Text>();
TextWeapon = GameObject.Find("TextWeapon").GetComponent<Text>();
ImageWeapon = GameObject.Find("ImageWeapon").GetComponent<Image>();
//make the array of the range of the current weapon
weaponRange = new GameObject[5, 5];
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
{
weaponRange[i, j] = GameObject.Find("Range" + ((i * 5) + j));
}
}
//if first time load, instantiate the player
if (playerInstanciate == true)
{
player = (GameObject)Instantiate(Resources.Load("Prefabs/Warrior"));
player.name = "Player";
playerInstanciate = false;
}
//put the player in the beginning position
GameObject.Find("Player").GetComponent<Player>().enabled = true;
GameObject.Find("Player").GetComponent<Player>().transform.position = new Vector3(0, 0, 0);
camera = GameObject.Find("Main Camera").GetComponent<SmoothCamera2D>();
camera.target = GameObject.Find("Player").GetComponent<Player>().transform;
//Clear any Enemy objects in our List to prepare for next level.
enemies.Clear();
if (!firstFloor)
{
//Get a reference to our image LevelImage by finding it by name.
levelImage = (GameObject)Instantiate(Resources.Load("Prefabs/Canvas"));
levelImage.name = "Canvas";
levelGained = GameObject.Find("LevelGained").GetComponent<Text>();
//set value for the canva at each end of level who show if the player got a new weapon (50%)
expGained = GameObject.Find("ExperienceGained").GetComponent<Text>();
weaponGainedName = GameObject.Find("ItemText").GetComponent<Text>();
weaponGained = GameObject.Find("Image").GetComponent<Image>();
weaponGainedStats = GameObject.Find("ItemGainedStats").GetComponent<Text>();
Weapon newWeapon = player.GetComponent<Player>().weaponManager.lootWeapon(player.GetComponent<Player>().getLevel());
levelGained.text = "+" + (player.GetComponent<Player>().level - initialLVL);
expGained.text = "+" + (player.GetComponent<Player>().experience - initialEXP);
//if he got a new weapon
if (newWeapon != null)
{
weaponGained.enabled = true;
weaponGained.sprite = items[newWeapon.getWeaponImage()];
weaponGainedName.text = newWeapon.getWeaponName();
weaponGainedStats.text = newWeapon.ToString();
}
//or not
else
{
weaponGained.enabled = false;
weaponGainedName.text = "";
weaponGainedStats.text = "";
}
levelImage.SetActive(true);
initialLVL = player != null ? player.GetComponent<Player>().getLevel() : 1;
initialEXP = player != null ? player.GetComponent<Player>().experience : 0;
}
else
{
firstFloor = false;
onContinue();
}
//Call the SetupScene function of the BoardManager script, pass it current level number.
boardScript.SetupScene(level);
}
void Start()
{
ClearPowerup();
soundManager = GameObject.Find ("SoundManager").GetComponent<SoundManager>();
sceneManager = GameObject.Find ("SceneObject").GetComponent<SceneManager>();
cameraScript = GameObject.Find ("tk2dCamera").GetComponent<SmoothCamera2D>();
InitServerDisplay();
}
private void Awake()
{
followCamera = Camera.main.GetComponent <SmoothCamera2D> ();
//offset = offset+transform.position;
}
void Awake()
{
//Set Animator...
anim = GameObject.FindGameObjectWithTag (Tags.canvas).GetComponent<Animator> ();
pauseMenuController = GameObject.FindGameObjectWithTag (Tags.canvas).GetComponentInChildren<PauseMenuController> ();
persistentData = GameObject.FindGameObjectWithTag (Tags.mainCamera).GetComponent<PersistentData> ();
//persistentData.realGameObjectsToDestroyListArray = null;
smoothCamera2D = GameObject.FindGameObjectWithTag (Tags.mainCamera).GetComponent<SmoothCamera2D> ();
}
// Use this for initialization
void Start()
{
cameraScript = Camera.main.GetComponent <SmoothCamera2D>();
}
void OnEnable()
{
//Clear the list of colliderParents
colliderParentIDs.Clear ();
//Define the shakeCamera GameObject if it is not already
if(shakeCamera == null){
shakeCamera = GameObject.FindGameObjectWithTag (Tags.mainCamera).GetComponent<SmoothCamera2D> ();
}
//Define forward attack vector...
Vector3 forwardAttackVector = meleeAttackEndpoint.position - meleeAttackOrigin.position;
//Get colliders within range that are on the enemy layer...
inRangeColliders = Physics.OverlapSphere (transform.position, damageRadius, layerMask_enemy);
//Build list of colliders that are within damage zone...
foreach(Collider inRangeCollider in inRangeColliders){
//Check to see if the collider is a part of the owner...
if(inRangeCollider.transform == transform.parent.transform.parent.transform){
//Ignore the collider...
continue;
}
//Define target location vector...
Vector3 targetVector = inRangeCollider.bounds.ClosestPoint(meleeAttackEndpoint.position) - meleeAttackOrigin.position;
targetVector.y = forwardAttackVector.y; //ensures the targetVector is in the 2D plane
//Define cross product of attack vector and target vector...
Vector3 crossVector = Vector3.Cross (forwardAttackVector, targetVector);
//Check against the leftward or rightward damage zone limit angle, depending on sign of the y component of the cross...
if(crossVector.y < 0f){
//the target is to the left, so check against leftward angle limit...
if(Vector3.Angle (forwardAttackVector, targetVector) < damageZoneAngleLeft){
//check for blockages and apply damage if hit enemy...
RaycastHit blockage; // Check for environment blockage (walls)
if( Physics.Raycast (meleeAttackOrigin.position, targetVector, out blockage, damageRadius, layerMask_obstruction)){
RaycastHit targetPoint; //Obtain target point (more accurate than center of collider)
if(Physics.Raycast (meleeAttackOrigin.position, targetVector, out targetPoint, damageRadius, layerMask_enemy)){
if(blockage.distance > targetPoint.distance){
interactable = true;
}
}
}
else {
interactable = true;
}
}
}
else{
//the target is to the right, so check against the rightward angle limit...
if(Vector3.Angle(forwardAttackVector, targetVector) < damageZoneAngleRight){
//check for blockages and apply damage if hit enemy...
RaycastHit blockage; // Check for environment blockage (walls)
if( Physics.Raycast (meleeAttackOrigin.position, targetVector, out blockage, damageRadius, layerMask_obstruction)){
RaycastHit targetPoint; //Obtain target point (more accurate than center of collider)
if(Physics.Raycast (meleeAttackOrigin.position, targetVector, out targetPoint, damageRadius, layerMask_enemy)){
if(blockage.distance > targetPoint.distance){
interactable = true;
}
}
}
else {
interactable = true;
}
}
}
//If the collider is deemed interactable, then check to see if its parent gameobject has already been accounted for...
if(interactable){
interactable = false;
//Define parent ID...
int colParentID = inRangeCollider.gameObject.GetInstanceID();
//Test if the ID is already accounted for...
if(!colliderParentIDs.Contains (colParentID)){
//If not, then add ID to list...
colliderParentIDs.Add(colParentID);
//...and apply damage...
if(inRangeCollider.tag == Tags.enemy || inRangeCollider.tag == Tags.npc || inRangeCollider.tag == Tags.neutral){
float damage = Random.Range (minDamage,maxDamage);
EnemyStats enemyStats = inRangeCollider.gameObject.GetComponent<EnemyStats>();
enemyStats.enemyHealth -= damage;
enemyStats.damageForce = forwardAttackVector*meleeHitForce*0.5f;
enemyStats.BloodEffects(damageType, inRangeCollider.transform.position, transform.rotation);
Instantiate (meleeCharacterStrike, inRangeCollider.transform.position, transform.rotation);
shakeCamera.shakeCamera(cameraShakeMagnitude, meleeAttackEndpoint.position);
}
else if(inRangeCollider.tag == Tags.player){
float damage = Random.Range (minDamage,maxDamage);
PlayerStats playerStats = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent<PlayerStats>();
playerStats.playerHealth -= damage;
playerStats.damageForce = forwardAttackVector*meleeHitForce*0.5f;
playerStats.BloodEffects(damageType, inRangeCollider.transform.position, transform.rotation);
Instantiate (meleeCharacterStrike, inRangeCollider.transform.position, transform.rotation);
shakeCamera.shakeCamera(cameraShakeMagnitude*2.0f, transform.position);
}
}
}
}
//When the enemy testing is complete, test to see if there is a wall strike necessary...
RaycastHit hit;
if(Physics.Raycast (meleeAttackOrigin.position, forwardAttackVector, out hit, damageRadius, layerMask_obstruction)){
Instantiate (meleeWallStrike, hit.point, transform.rotation);
if(hit.rigidbody){
hit.rigidbody.AddForce (forwardAttackVector*meleeHitForce);
}
shakeCamera.shakeCamera(cameraShakeMagnitude, meleeAttackEndpoint.position);
}
}
// Use this for initialization
void Start()
{
shakeCamera = GameObject.FindGameObjectWithTag (Tags.mainCamera).GetComponent<SmoothCamera2D> ();
}
void Start()
{
smoothCamera = camera.GetComponent <SmoothCamera2D>();
}
void Awake()
{
m_smoothCamera = GetComponent <SmoothCamera2D>();
}
// Start is called before the first frame update
void Start()
{
smoother = GetComponent <SmoothCamera2D>();
}
