void Start()
{
energy = GetComponent <PlayerEnergy>();
inventory = GetComponent <PlayerInventory>();
status = GetComponent <PlayerStatus>();
input = GameObject.Find("InputManager").GetComponent <InputManager>();
}
public void Load()
{
Debug.Log(Application.persistentDataPath);
if (File.Exists(Application.persistentDataPath + "/playerInfo.dat"))
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(Application.persistentDataPath + "/playerInfo.dat", FileMode.Open);
PlayerData data = (PlayerData)bf.Deserialize(file);
currentScene = data.currentScene;
//health = data.health;
//energy = data.energy;
//exp = data.exp;
file.Close();
SceneManager.LoadScene(currentScene, LoadSceneMode.Single);
healthScript = gameObject.GetComponent <PlayerHealth>();
energyScript = gameObject.GetComponent <PlayerEnergy>();
levelScript = gameObject.GetComponent <PlayerLevel>();
healthScript.currentHealth = data.health;
energyScript.currentEnergy = data.energy;
levelScript.exp = data.exp;
levelScript.level = data.level;
}
Debug.Log("Loading");
}
public override void AI()
{
Player player = Main.player[Main.myPlayer];
PlayerEnergy modPlayer = player.GetModPlayer <PlayerEnergy>(mod);
consumeEnergyTimer--;
if (consumeEnergyTimer <= 0)
{
modPlayer.energy--;
consumeEnergyTimer = 60;
}
if (modPlayer.energy <= 0)
{
projectile.Kill();
}
if (projectile.localAI[0] == 0)
{
Projectile.NewProjectile(projectile.Center.X, projectile.Center.Y, 0f, 0f, mod.ProjectileType("RifleSentryHead"), projectile.damage, projectile.knockBack, Main.myPlayer, projectile.whoAmI, 0f);
projectile.localAI[0]++;
}
projectile.velocity.X = 0f;
projectile.velocity.Y = projectile.velocity.Y + 0.2f;
if (projectile.velocity.Y > 16f)
{
projectile.velocity.Y = 16f;
}
}
// other methods
public void checkLevelUP(PlayerScore playerScore, PlayerEnergy playerEnergy, PlayerAttack playerAttack)
{
if (playerScore.getScore() >= scoreLevel) // check if the player can level up or not
{
levelUP(playerEnergy, playerAttack);
}
}
public override void Update()
{
Player player = Main.LocalPlayer;
PlayerEnergy modPlayer = player.GetModPlayer <PlayerEnergy>(mod);
Vector2 tileCenter = new Vector2(Position.X * 16, Position.Y * 16);
if (energy > maxEnergy)
{
energy = maxEnergy;
}
Rectangle mouse = new Rectangle((int)Main.MouseWorld.X, (int)Main.MouseWorld.Y, 2, 2);
Rectangle tileRect = new Rectangle(Position.X * 16, Position.Y * 16, 5 * 16, 5 * 16);
/*for (int d = 0; d < 3; d++)
* {
* int dust = Dust.NewDust(mouse.TopLeft(), mouse.Width, mouse.Height, 57, 0f, 0f, 100);
* Main.dust[dust].velocity *= 0.01f;
* int dust2 = Dust.NewDust(tileRect.TopLeft(), tileRect.Width, tileRect.Height, 57, 0f, 0f, 100);
* Main.dust[dust2].velocity *= 0.01f;
* }*/
if (Main.mouseRight && mouse.Intersects(tileRect))
{
if (modPlayer.energy > 0 && energy < maxEnergy)
{
energy++;
modPlayer.energy--;
Main.PlaySound(SoundID.MenuTick);
}
}
}
private void Awake()
{
//filename = chosen file name from GameTracker class.
gameTracker = FindObjectOfType <GameTracker>();
if (gameTracker)
{
fileName = gameTracker.ChosenFileName;
}
else
{
fileName = "DemonHunterSave1.Json";
}
filePath = Application.persistentDataPath + "/" + fileName;
_playerController = FindObjectOfType <PlayerController>();
_playerCamera = FindObjectOfType <PlayerCamera>();
_tutorialManager = FindObjectOfType <TutorialManager>();
_playerEnergyPoints = FindObjectOfType <PlayerEnergyPoints>();
_playerMeleeAttack = FindObjectOfType <PlayerMeleeAttack>();
_playerShoot = FindObjectOfType <PlayerShoot>();
_playerDash = FindObjectOfType <PlayerDash>();
_playerEnergy = FindObjectOfType <PlayerEnergy>();
_gameManager = FindObjectOfType <GameManager>();
_playerUpgradesManager = FindObjectOfType <PlayerUpgradesManager>();
_npcManager = FindObjectOfType <NPCManager>();
}
// Use this for initialization
void Start()
{
if(networkView.isMine == true)
{
myTransform = transform;
cameraHeadTransform = myTransform.FindChild ("CameraHead");
//Find SpawnManager and get SpawnScript for team
GameObject spawnManager = GameObject.Find ("SpawnManager");
SpawnScript spawnScript = spawnManager.GetComponent<SpawnScript>();
changeScript = myTransform.GetComponent<ChangeWeapon>();
if(spawnScript.onRed == true)
{
iRed = true;
}
if(spawnScript.onBlue == true)
{
iBlue = true;
}
energyScript = myTransform.GetComponent<PlayerEnergy>();
}
else
{
enabled = false;
}
}
void Awake()
{
//---能量設定---
playerEnergy = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerEnergy>();
//---水量---
water_UI = transform.Find("Water_UI");
if (water_UI != null)
{
waterMax = playerEnergy.waterEnergyMax;
waterSlider = water_UI.Find("Slider").GetComponent <Slider>();
waterFill = waterSlider.transform.Find("Fill Area/Fill").GetComponent <Image>();
}
//---髒污---
purity_UI = transform.Find("Purity_UI");
if (purity_UI != null)
{
puritySlider = purity_UI.Find("Slider").GetComponent <Slider>();
purityFill = puritySlider.transform.Find("Fill Area/Fill").GetComponent <Image>();
}
//---繁盛---
blossom_UI = transform.Find("BlossomUI");
if (blossom_UI != null)
{
blossomSlider = blossom_UI.Find("slider").GetComponent <Slider>();
blossomSlider.value = 0f;
blossomUI_canvasGroup = blossom_UI.GetComponent <CanvasGroup>();
blossomUI_canvasGroup.alpha = 1f;
}
}
public void Start()
{
currentDisbalance = 0;
playerEnergy = GetComponent <PlayerEnergy>();
playerUI = GetComponent <PlayerUI>();
disbalanceActivityOngoing = false;
}
public void levelUP(PlayerEnergy playerEnergy, PlayerAttack playerAttack) { // level up
/*
* if the score >= the score required to level up(lvlScore), the player will level up.
* the lvlScore will be multiplied by 3
*/
level++;
scoreLevel *= 3;
switch (level) {
case 1:
playerEnergy.setMaxEnergy (110);
playerAttack.setAtk (2);
break;
case 2:
playerEnergy.setMaxEnergy (120);
playerAttack.setAtk (3);
break;
case 3:
playerEnergy.setMaxEnergy (130);
playerAttack.setAtk (4);
break;
case 4:
playerEnergy.setMaxEnergy (140);
playerAttack.setAtk (5);
break;
case 5:
playerEnergy.setMaxEnergy (150);
playerAttack.setAtk (6);
break;
}
}
// Use this for initialization
void Start()
{
playerEnergyReference = GameObject.Find("PlayerRobot").GetComponent<PlayerEnergy>();
wallEnergy = 0.0f;
energyP1 = playerEnergyReference.p1Energy;
energyP2 = playerEnergyReference.p2Energy;
}
public override void UpdateInventory(Player player)
{
PlayerEnergy modPlayer = player.GetModPlayer <PlayerEnergy>(mod);
if (enabled && modPlayer.energy < modPlayer.maxEnergy)
{
if (lifeRegenAmount > 0)
{
player.lifeRegenCount = 0;
lifeRegenTimer += lifeRegenAmount;
if (lifeRegenTimer >= 120)
{
lifeRegenTimer -= 120;
modPlayer.energy++;
player.statLife -= 2;
if (player.statLife <= 0)
{
player.statLife = 0;
player.KillMe(PlayerDeathReason.ByCustomReason(player.name + " boiled away"), 1.0, 0, false);
}
}
}
}
leftArrowCooldown--;
rightArrowCooldown--;
if (Main.HoverItem.type == item.type)
{
Keys[] pressedKeys = Main.keyState.GetPressedKeys();
for (int j = 0; j < pressedKeys.Length; j++)
{
Keys key = pressedKeys[j];
if (key == Keys.Left)
{
if (leftArrowCooldown <= 0 && lifeRegenAmount > 0)
{
lifeRegenAmount--;
leftArrowCooldown = 3;
Main.PlaySound(SoundID.MenuTick, player.position);
}
}
if (key == Keys.Right)
{
if (rightArrowCooldown <= 0 && lifeRegenAmount < 50)
{
lifeRegenAmount++;
rightArrowCooldown = 3;
Main.PlaySound(SoundID.MenuTick, player.position);
}
}
}
}
if (!player.active || player.dead)
{
lifeRegenAmount = 0; // reset when dead in case player cant turn it off in time
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.layer == 8)
{
_playerEnergy = collision.GetComponentInParent <PlayerEnergy>();
}
}
public override void UpdateInventory(Player player)
{
PlayerEnergy modPlayer = player.GetModPlayer <PlayerEnergy>(mod);
if (enabled && modPlayer.energy < modPlayer.maxEnergy)
{
for (int i = 0; i < 50; i++)
{
Item other = Main.LocalPlayer.inventory[i];
if (other.type == ItemID.ChlorophyteOre)
{
if (fuel <= 0 && other.stack >= 2)
{
fuel = 600;
other.stack--;
player.QuickSpawnItem(mod.ItemType("Chlorobyte"), 2);
}
}
}
if (fuel > 0)
{
fuel--;
}
producePowerCooldown--;
if (fuel > 0 && producePowerCooldown <= 0)
{
producePowerCooldown = 30;
modPlayer.energy += 2;
}
}
}
private void OnTriggerExit2D(Collider2D collision)
{
if (collision.gameObject.layer == 8)
{
_playerEnergy = null;
}
}
void Update()
{
if (TimeManager.paused)
{
return;
}
maxEnergyValue = PlayerSkills.GetMaxEnergyValue();
currentEnergyValue = (float)PlayerEnergy.GetCurrentEnergyValue() / maxEnergyValue;
energyRadial.fillAmount = currentEnergyValue;
energyRadial.color = Color.Lerp(Color.red, Color.green, currentEnergyValue);
energyText.text = (currentEnergyValue * maxEnergyValue).ToString();
if (!SceneManager.GetActiveScene().name.Equals("MainCabin"))
{
if (((Input.GetButton("ToolWheel") && !toolWheelIsOpen) || (Input.GetButtonUp("ToolWheel") && toolWheelIsOpen)) && !MenuManager.currentMenuManager.IsInMenu())
{
ToggleToolWheel();
}
}
else
{
if (!toolsDisabledInside)
{
toolIconGroup.parent.transform.parent.gameObject.SetActive(false);
toolsDisabledInside = true;
}
}
DebugPanel.Log("Current Tool: ", "Player HUD", PlayerTools.GetCurrentlyEquippedToolIndex());
DebugPanel.Log("Current Tool (manager)", "Player HUD", ToolManager.GetCurrentToolIndex());
}
private void Awake()
{
_playerController = FindObjectOfType <PlayerController>();
_playerEnergy = FindObjectOfType <PlayerEnergy>();
_playerEnergyPoints = FindObjectOfType <PlayerEnergyPoints>();
_uiManager = FindObjectOfType <UIManager>();
}
// Use this for initialization
void Start()
{
isCooledDown = true;
myAudioSource = transform.parent.GetComponent <AudioSource> ();
energySys = transform.parent.GetComponent <PlayerEnergy> ();
//myInputDevice = InputManager.Devices [deviceIndex];
}
void Start()
{
inputManager = FindObjectOfType <InputManager> ();
playerEnergy = this.GetComponent <PlayerEnergy>();
playerRb = this.GetComponent <Rigidbody2D>();
forceFactor = 2f;
}
private void PlayerInit()
{
if (!rigid)
{
rigid = GetComponent <Rigidbody>();
}
if (!invComponent)
{
invComponent = GetComponent <InventoryComponent> ();
}
if (!abilities)
{
abilities = GetComponent <PlayerAbilities> ();
}
if (!energy)
{
energy = GetComponent <PlayerEnergy> ();
}
if (!pointLight)
{
pointLight = GetComponent <Light> ();
}
if (!sound)
{
sound = GetComponent <PlayerSound> ();
}
if (!particles)
{
particles = GetComponent <PlayerParticles> ();
}
}
void Awake()
{
Instance = gameObject;
PlayerTransform = Instance.transform;
PlayerHealth = Instance.GetComponent<PlayerHealth>();
PlayerExperience = Instance.GetComponent<PlayerExperience>();
PlayerEnergy = Instance.GetComponent<PlayerEnergy>();
}
public override void RightClick(Player player)
{
PlayerEnergy modPlayer = player.GetModPlayer <PlayerEnergy>(mod);
Main.PlaySound(2, -1, -1, mod.GetSoundSlot(SoundType.Item, "Sounds/Item/HandCrank"), 1, 0);
modPlayer.energy += 25;
item.stack++;
}
//[System.NonSerialized] public bool haveShot;
private void Awake()
{
gameManager = FindObjectOfType <GameManager>();
playerController = GetComponent <PlayerController>();
healthComponent = GetComponent <HealthComponent>();
playerEnergy = GetComponent <PlayerEnergy>();
uiManager = GameObject.Find("UIManager").GetComponent <UIManager>();
}
void OnTriggerExit(Collider col)
{
if (!col.gameObject.CompareTag("Player"))
{
return;
}
player = null;
}
void OnTriggerEnter(Collider col)
{
if (!col.gameObject.CompareTag("Player"))
{
return;
}
player = col.gameObject.GetComponent <PlayerEnergy>();
}
void Awake()
{
abilityImageHUD = GameObject.FindGameObjectWithTag("Ability2");
abilityImage = abilityImageHUD.GetComponent <Image> ();
player = GameObject.FindGameObjectWithTag("Player");
playerHealth = player.GetComponent <PlayerHealth> ();
playerEnergy = player.GetComponent <PlayerEnergy> ();
timer = 100f;
}
void Start()
{
energy = player.GetComponent <PlayerEnergy>();
input = GameObject.Find("InputManager").GetComponent <InputManager>();
anim = GetComponent <Animator>();
line = GetComponent <LineRenderer>();
line.useWorldSpace = true;
}
public void SleepToMorning()
{
sleepPrompt.CloseMenu();
PlayerHud.ToggleInteractPrompt(false);
PlayerEnergy.RestoreEnergyPercentage(DetermineSleepDuration());
TimeManager.ProgressToMorningTime();
SaveLoad.Save();
}
public void TurnIn(PlayerEnergy playerEnergy)
{
// Get soals from pEnergy, reset to 0 instantly
int amountAdded = playerEnergy.SacrificeSouls();
gameManager.AddScore(playerEnergy.team, amountAdded);
Debug.Log("Turn in ok");
// TODO: Trigger animations
}
/// <summary>
/// Attack the specified target.
/// </summary>
/// <param name="target">Target to attack.</param>
void Attack(GameObject target)
{
line.SetPositions(new Vector3[2] {
transform.position, player.transform.position
});
cooldownTimestamp = Time.time;
playerEnergy = target.GetComponent <PlayerEnergy> ();
playerEnergy.energy = playerEnergy.energy - attackStrength * playerEnergy.drainAmount;
}
//[System.NonSerialized] public bool haveAttacked;
private void Awake()
{
gameManager = FindObjectOfType <GameManager>();
playerController = GetComponent <PlayerController>();
playerEnergy = GetComponent <PlayerEnergy>();
playerHealthComp = GetComponent <HealthComponent>();
circleCollider = GetComponent <CircleCollider2D>();
uiManager = FindObjectOfType <UIManager>();
}
//[SerializeField] private GameObject explosion;
//[SerializeField] private GameObject explosion2;
private void Awake()
{
_healthComponent = GetComponent <HealthComponent>();
_playerEnergy = GetComponent <PlayerEnergy>();
if (isPlayerProj)
{
_playerController = FindObjectOfType <PlayerController>();
}
}
void OnTriggerExit(Collider col)
{
if (!col.gameObject.CompareTag("Player"))
{
return;
}
print("player exit capacitor area");
player = null;
}
//HackerMovementAnim moveAnim;
// Use this for initialization
void Start()
{
myInputDevice = GetComponentInParent <DeviceReceiver>().GetDevice();
animator = GetComponent <Animator> ();
playerMove = GetComponentInParent <PlayerMovement> ();
oldSpeedFactor = playerMove.moveSpeedFactor;
playerEnergy = GetComponentInParent <PlayerEnergy> ();
audioS = GetComponent <AudioSource> ();
// moveAnim = GetComponentInParent<HackerMovementAnim> ();
}
void OnTriggerEnter(Collider col)
{
if (!col.gameObject.CompareTag("Player"))
{
return;
}
print("player enter in capacitor area");
player = col.gameObject.GetComponent <PlayerEnergy> ();
GetComponent <AudioSource>().Play();
}
void Awake() {
// intialize player's attribute
playerScore = GetComponent<PlayerScore> ();
playerAttack = GetComponent<PlayerAttack> ();
playerEnergy = GetComponent<PlayerEnergy> ();
playerLevel = GetComponent<PlayerLevel> ();
// other flag status
grounded = false;
facingLeft = true;
doubleJump = false;
source = GetComponent<AudioSource> ();
}
// Update is called once per frame
void LateUpdate()
{
playerEnergyReference = GameObject.Find("PlayerRobot").GetComponent<PlayerEnergy>();
bluestrength = playerEnergyReference.p1Energy / 100;
redstrength = playerEnergyReference.p2Energy / 100;
Image redbar = GetComponent<Image> ();
float offset = redstrength * 0.4f;
float left = 0.4f - offset;
redbar.rectTransform.anchorMin = new Vector2 (left, 0.5f);
float ratio = redstrength / (bluestrength + redstrength) * 0.2f;
float right = 0.4f + ratio;
redbar.rectTransform.anchorMax = new Vector2 (right, 0.5f);
if (left >= 0.4f)
redbar.rectTransform.anchorMin = new Vector2 (0.4f, 0.5f);
}
// Use this for initialization
void Start()
{
if(networkView.isMine == true)
{
Transform triggerTransform = transform.FindChild("Trigger");
HDScript = triggerTransform.GetComponent<HealthAndDamage>();
energyScript = gameObject.GetComponent<PlayerEnergy>();
rescourceScript = gameObject.GetComponent<PlayerResource>();
healthStyle.normal.textColor = Color.red;
healthStyle.fontStyle = FontStyle.Bold;
energyStyle.normal.textColor = Color.cyan;
energyStyle.fontStyle = FontStyle.Bold;
rescourcesStyle.normal.textColor = Color.green;
rescourcesStyle.fontStyle = FontStyle.Bold;
}
else
{
enabled = false;
}
}
//Variables End___________________________________________________________
// Use this for initialization
void Start()
{
if(networkView.isMine == true)
{
myTransform = transform;
cameraHeadTransform = myTransform.FindChild("CameraHead");
weaponScript = myTransform.GetComponent<ChangeWeapon>();
energyScript = myTransform.GetComponent<PlayerEnergy>();
//Access the SpawnScript and find out what team this player
//is on. The rocket that is instantiated depends
//on what team the player is on.
GameObject SpawnM = GameObject.Find("SpawnManager");
SpawnScript spawnScript = SpawnM.GetComponent<SpawnScript>();
if(spawnScript.onRed == true)
{
iAmOnRedTeam = true;
}
if(spawnScript.onBlue == true)
{
iAmOnBlueTeam = true;
}
}
else
{
enabled = false;
}
}
/* static int rowState = Animator.StringToHash("Base Layer.Row");
static int gyroState = Animator.StringToHash("Base Layer.Gyro");
TODO: implement at a later date 2015-04-02
*/
//------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Functions
//------------------------------------------------------------------------------------------------------------------------------------------------------------------
void Start()
{
playerRobot = GameObject.Find ("PlayerRobot");
peAccessor = playerRobot.GetComponent<PlayerEnergy>();
playerMover = playerRobot.GetComponent<SWS.PlayerSplineMove> ();
gestureManager = GameObject.Find ("GestureManager").GetComponent<GestureManager>();
oldPosX = playerRobot.transform.position.x;
oldPosZ = playerRobot.transform.position.z;
moveSpeed = 0.0f;
//initialising reference variables
anim = GetComponent<Animator> ();
if (anim.layerCount == 2) {
anim.SetLayerWeight (1, 1);
}
switch (Application.loadedLevel){
case 0:
playerMover.events[1].AddListener(delegate{pauseMovement(4f); GameObject.Find ("MainCamera").GetComponent<ThirdPersonCamera>().callDoorZoom();});
break;
case 1:
playerMover.startPoint = 0;
playerMover.SetPath(WaypointManager.Paths["Level02_Room01_Path01"]);
playerMover.speed = 5.5f;
playerMover.lockRotation = AxisConstraint.X;
anim.SetBool("IsWalking", true);
playerMover.StartMove();
playerMover.events[3].AddListener(delegate() {pauseMovement(.8f); callJumping();});
playerMover.events[4].AddListener(delegate() {pauseMovement(1.5f);});
playerMover.events[5].AddListener(delegate() {callRowing (); stopMovement(.7f);});
break;
case 2:
break;
default:
return;
}
}
// Update is called once per frame
void Update()
{
playerEnergyReference = GameObject.Find("PlayerRobot").GetComponent<PlayerEnergy>();
P1Energy = playerEnergyReference.p1Energy;
P2Energy = playerEnergyReference.p2Energy;
switch (Application.loadedLevel) {
case 0:
isEating = anim.GetBool ("LeftEat") || anim.GetBool ("RightEat");
isPunching = anim.GetBool("LeftPunch") || anim.GetBool("RightPunch");
isCrouching = anim.GetBool(""); //TODO: Add crouching bool
isClimbing = anim.GetBool("ClimbEnter") || anim.GetBool("ClimbIdle") ||
anim.GetBool("LeftClimb") || anim.GetBool("LeftClimb") || anim.GetBool("Climbcomplete");
isWalking = anim.GetBool("Move");
case 1:
isTPosing = anim.GetBool(""); //TODO: Get TPose boolean
isRowing = anim.GetBool ("IsRowing");
isWalking = anim.GetBool("IsWalking");
}
if (isEating) {
eatingTime += Time.deltaTime;
print("Eating Time: " + eatingTime);
//TODO: How to get information of different players?
print("Name: " + P1 + " " + "Energy: " + P1Energy);
print("Name: " + P2 + " " + "Energy: " + P2Energy);
//TODO: Accumulate all the eating time with eat return and count the total number of eat times
}
if (isPunching) {
punchingTime += Time.deltaTime;
print("Punching Time: " + punchingTime);
print("Name: " + P1 + " " + "Energy: " + P1Energy);
print("Name: " + P2 + " " + "Energy: " + P2Energy);
//TODO
}
if (isCrouching) {
crouchingTime += Time.deltaTime;
print("Crouching Time: " + crouchingTime);
print("Name: " + P1 + " " + "Energy: " + P1Energy);
print("Name: " + P2 + " " + "Energy: " + P2Energy);
//TODO
}
if (isClimbing) {
climbingTime += Time.deltaTime;
print("Climbing Time: " + climbingTime);
print("Name: " + P1 + " " + "Energy: " + P1Energy);
print("Name: " + P2 + " " + "Energy: " + P2Energy);
//TODO
}
if (isTPosing) {
tPosingTime += Time.deltaTime;
print("TPosing Time: " + tPosingTime);
print("Name: " + P1 + " " + "Energy: " + P1Energy);
print("Name: " + P2 + " " + "Energy: " + P2Energy);
//TODO
}
if (isRowing) {
rowingTime += Time.deltaTime;
print("Rowing Time: " + rowingTime);
print("Name: " + P1 + " " + "Energy: " + P1Energy);
print("Name: " + P2 + " " + "Energy: " + P2Energy);
//TODO
}
}
//Variables End___________________________________________________________
// Use this for initialization
void Start()
{
if(networkView.isMine == true)
{
parentTransform = transform.parent;
cameraHeadTransform = parentTransform.FindChild("CameraHead");
weaponScript = parentTransform.GetComponent<ChangeWeapon>();
energyScript = parentTransform.GetComponent<PlayerEnergy>();
style.fontSize = 40;
style.normal.textColor = Color.red;
style.fontStyle = FontStyle.Bold;
style.alignment = TextAnchor.MiddleCenter;
//Check which team this player is on. This will determine
//who can get hurt by this player's beam.
GameObject SpawnM = GameObject.Find("SpawnManager");
SpawnScript script = SpawnM.GetComponent<SpawnScript>();
if(script.onRed == true)
{
iAmOnRedTeam = true;
}
if(script.onBlue == true)
{
iAmOnBlueTeam = true;
}
}
else
{
enabled = false;
}
}
void Start() {
playerEnergy = gameObject.GetComponent<PlayerEnergy> ();
}
//Variables End_____________________________________
// Use this for initialization
void Start()
{
if(networkView.isMine == true)
{
myTransform = transform;
motorScript = myTransform.GetComponent<CharacterMotor>();
playerGraphics = myTransform.FindChild("Graphics");
trigger = myTransform.FindChild("Trigger").gameObject;
cameraHead = myTransform.FindChild("CameraHead");
fallDamageScript = myTransform.GetComponent<FallDamage>();
changeScript = gameObject.GetComponent<ChangeWeapon>();
energyScript = gameObject.GetComponent<PlayerEnergy>();
}
else
{
enabled = false;
}
}
// other methods
public void checkLevelUP(PlayerScore playerScore, PlayerEnergy playerEnergy, PlayerAttack playerAttack) {
if (playerScore.getScore () >= scoreLevel) // check if the player can level up or not
levelUP (playerEnergy, playerAttack);
}
