public void spawnHealingOrbs(int playerHealed, int healAmount, string mode)
{
GameObject healingOrbPrefab = normalHealingOrbPrefab;
if (mode == "leechLife")
{
healingOrbPrefab = leechLifeHealingOrbPrefab;
}
if (playerHealed == 0 || playerHealed == 1)
{
OrbController healingOrb1 = Instantiate(healingOrbPrefab, orb.transform.position, Quaternion.identity, orb.GetComponentInParent <Transform>()).GetComponent <OrbController>();
healingOrb1.healAmount = healAmount;
healingOrb1.progression = orb.GetComponent <OrbController>().progression;
healingOrb1.toPlayer2 = false;
}
if (playerHealed == 0 || playerHealed == 2)
{
OrbController healingOrb2 = Instantiate(healingOrbPrefab, orb.transform.position, Quaternion.identity, orb.GetComponentInParent <Transform>()).GetComponent <OrbController>();
healingOrb2.healAmount = healAmount;
healingOrb2.progression = orb.GetComponent <OrbController>().progression;
healingOrb2.toPlayer2 = true;
}
}
public void TeamB_Attack()
{
OrbController orb = bTeam[Random.Range(0, bTeam.Count)];
orb.target = getPlayerTarget();
orb.FireTowardTarget();
}
public void addToPlayerTeam()
{
OrbController orb = spawnOrb();
orb.setTeam(0);
playerTeam.Add(orb);
}
private IEnumerator StartCountdown()
{
if (isIdolActivated)
{
yield break;
}
OrbController orb = Instantiate(orbPrefab, transform.position, Quaternion.identity).GetComponent <OrbController>();
float timeLeft = 2f;
curIdol.GiveOrbDest(orb);
while (timeLeft > 0)
{
if (!(Input.GetKey(KeyCode.F) || Input.GetKey(KeyCode.Joystick1Button2)) || Input.GetAxis("Horizontal") != 0)
{
orb.Destruct();
yield break;
}
timeLeft -= 0.01f;
yield return(new WaitForSeconds(0.01f));
}
isIdolActivated = true;
curIdol.Activate(this);
yield return(null);
}
public void resetOrbs()
{
if (orbs != null)
{
foreach (OrbController orb in orbs)
{
Destroy(orb.gameObject);
}
orbs.Clear();
}
else
{
orbs = new List <OrbController>();
}
if (maxOrbs > 0)
{
interOrbAngle = 360 / maxOrbs;
}
for (int i = 0; i < maxOrbs; i++)
{
OrbController oc = ((GameObject)GameObject.Instantiate(orbObj)).GetComponent <OrbController>();
oc.offset = Quaternion.AngleAxis(i * interOrbAngle, Vector3.forward) * Vector3.right;
oc.owner = PlayerController.GlobalPlayerInstance.transform;
oc.SetOnCollision(onCollision, onCollisionTargets);
orbs.Add(oc);
orbRadius = oc.radius;
orbSpeed = oc.rotationSpeed;
}
}
private void Awake()
{
elementNames.Add("Ice");
elementNames.Add("Fire");
elementNames.Add("Lightning");
elementConversion.Add("Ice", 0);
elementConversion.Add("Fire", 1);
elementConversion.Add("Lightning", 2);
for (int i = 0; i < 3; i++)
{
Orb orb = new Orb();
Element elem = new Element();
elem.Name = elementNames[i];
orb.Type = elem;
orbInventory.Add(elementNames[i], 0);
}
oc = GetComponent <OrbController>();
player = GetComponent <Player>();
pUI = GameObject.FindGameObjectWithTag("uiManager").GetComponent <PlayerUI>();
pAnim = GetComponent <PlayerAnimation>();
oAud = GameObject.FindGameObjectWithTag("OrbUse").GetComponent <OrbUse>();
opAud = GameObject.FindGameObjectWithTag("OrbPickUp").GetComponent <OrbPickUp>();
pPart = GetComponent <PlayerParticles>();
}
void Awake()
{
dialogueDisplayer = GameObject.Find("DialogueDisplayer").GetComponent <DialogueDisplayer>();
screamSoundObjectSource = GameObject.Find("ScreamSound").GetComponent <AudioSource>();
screamFollowObject = GameObject.Find("ScreamFollowObject").GetComponent <ScreamFollowObject>();
rightFacingFatherOrbTransform = GameObject.Find("RightFaceFatherOrbPos").transform;
leftFacingFatherOrbTransform = GameObject.Find("LeftFaceFatherOrbPos").transform;
fatherOrbHoldTransform = GameObject.Find("RightFaceFatherOrbPos").transform;
bubbleLineStartTransform = GameObject.Find("LineStartPosition").transform;
proCamera = Camera.main.GetComponent <ProCamera2D>();
mainCamera = Camera.main;
managerObject = GameObject.Find("Managers");
fader = managerObject.GetComponent <CrossFade>();
roomManager = GameObject.Find("Managers").GetComponent <RoomManager>();
playerGO = GameObject.Find("Player");
player = playerGO.GetComponent <Player>();
defaultPlayerLayer = playerGO.layer;
fatherOrbGO = GameObject.Find("FatherOrb");
fatherOrb = fatherOrbGO.GetComponent <FatherOrb>();
monsterGO = GameObject.Find("Monster");
orbController = fatherOrbGO.GetComponent <OrbController>();
orbEffects = fatherOrbGO.GetComponent <OrbEffects>();
if (monsterGO != null)
{
monster = monsterGO.GetComponent <Monster>();
}
breathCanvas = playerGO.transform.Find("BreathCanvas");
Monster.MonsterReachedPlayer += GameOver;
}
private void OnTriggerEnter(Collider other)
{
if (other.CompareTag("Orb"))
{
if (GameManager.gameManager.orb.GetComponent <PowerController>().behaviouralPower == GameManager.PowerType.LargeOrb && mirrorHealth > 0)
{
mirrorHealth--;
OrbController controller = GameManager.gameManager.orb.GetComponent <OrbController>();
controller.toPlayer2 = !controller.toPlayer2;
if (mirrorHealth <= 0)
{
soundEmitter.PlaySound(1, true);
DestroyShield();
}
else
{
soundEmitter.PlaySound(0);
}
}
else
{
soundEmitter.PlaySound(0);
OrbController controller = GameManager.gameManager.orb.GetComponent <OrbController>();
controller.toPlayer2 = !controller.toPlayer2;
}
StartCoroutine(ShieldKnockback(15f));
}
}
public void Player_Attack(int orbIndex, int power, int angle)
{
OrbController orb = playerTeam[orbIndex];
orb.power = power;
orb.angle = angle;
orb.FireInAngle();
}
/// <summary>
/// Called whenever an orb is created.
/// </summary>
/// <param name="orb"></param>
protected virtual void OnOrbCreated(OrbController orb)
{
Debug.Assert(game_state == GameState.kSetup);
orbs.Add(orb);
CheckCountdownConditions();
}
private void TriggerSkill(GameObject hit)
{
OrbController orbController = GetComponent <OrbController>();
if (orbController != null)
{
orbController.TriggerSkill(hit, contactPoint);
}
}
private void Start()
{
canBeActivatedByPlayer1 = new List <bool> {
true, true, true, true, true, true, true, true, true
};
canBeActivatedByPlayer2 = new List <bool> {
true, true, true, true, true, true, true, true, true
};
orbController = gameObject.GetComponent <OrbController>();
VFX = transform.GetChild(0).gameObject;
}
void turnOnNextOrb()
{
for (int i = 0; i < maxOrbs; i++)
{
OrbController orb = orbs[i];
if (orb && !orb.IsOn)
{
orb.TurnOn();
return;
}
}
}
/// <summary>
/// Adds the given orb to the current sequence if possible.
/// </summary>
/// <returns><c>true</c>, if orb could be added, <c>false</c> otherwise.</returns>
/// <param name="type">Type.</param>
public bool SelectOrb(OrbController controller)
{
if (currentSequence == null || !playing)
return false;
if (currentSequence.Count() == 0 || currentSequence.Last().GetNeighbors().Contains(controller))
{
currentSequence.Add(controller);
return true;
}
return false;
}
void OnProximityEnter(object sender, Collider other)
{
GameObject collidedObj = other.gameObject;
if (collidedObj.tag == Tags.Orb)
{
OrbController orbController = collidedObj.GetComponent <OrbController>();
if (!orbController.IsAttached())
{
attacherDriverStack.GetHead().AttachOrbs(collidedObj, Tail);
}
}
}
protected override void OnShown(EventArgs e)
{
base.OnShown(e);
comboBoxBrightness.Items.Add(OrbBrightness.Bright.ToString());
comboBoxBrightness.Items.Add(OrbBrightness.Medium.ToString());
comboBoxBrightness.Items.Add(OrbBrightness.Dim.ToString());
checkBoxButtonsEnabled.Checked = true;
using (OrbPicker orbPicker = new OrbPicker())
{
if (orbPicker.ShowDialog() == DialogResult.OK)
{
try
{
groupBoxSerialOnly.Enabled = orbPicker.SerialMode;
if (orbPicker.SerialMode)
{
_orbSerial = new OrbSerialController(orbPicker.ComPort);
_orb = _orbSerial;
// register for button state changes
_orbSerial.OrbButtonChanged += new EventHandler <OrbButtonsEventArgs>(_orbSerial_OrbButtonChanged);
}
else
{
_orb = new OrbPagerController(orbPicker.DeviceId);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(),
"Ambient Orb Tester - Failed to create OrbController",
MessageBoxButtons.OK,
MessageBoxIcon.Hand);
// quit if no orb
Close();
}
}
else
{
// just quit if no connection selected
Close();
}
}
}
void addToAITeam()
{
//Team A
OrbController orbA = spawnOrb();
orbA.setTeam(1);
orbA.LevelUpAI(currentAILevel);
aTeam.Add(orbA);
//Team B
OrbController orbB = spawnOrb();
orbB.setTeam(2);
orbB.LevelUpAI(currentAILevel);
bTeam.Add(orbB);
}
/// <summary>
/// Called whenever a new orb cross the proximity boundaries.
/// </summary>
private void OnProximityEnter(object sender, Collider other)
{
if (isServer)
{
GameObject game_object = other.gameObject;
if (game_object.tag == Tags.Orb)
{
OrbController orb_controller = game_object.GetComponent <OrbController>();
if (!orb_controller.IsLinked)
{
RpcAttachOrb(game_object);
}
}
}
}
protected override void OnClosing(CancelEventArgs e)
{
base.OnClosing(e);
// if we have a serial orb controller unhook the button changed event
if (_orbSerial != null)
{
_orbSerial.OrbButtonChanged -= _orbSerial_OrbButtonChanged;
_orbSerial = null;
}
// always dispose the orb controller
if (_orb != null)
{
_orb.Dispose();
_orb = null;
}
}
public void CreateOrb(OrbSkill skill)
{
nextObrBullet = Instantiate(prafabHolder.OrbBullet, player.GetShootPoint(ShootPointPosition.MID).position, Quaternion.identity);
OrbController orbController = nextObrBullet.GetComponent <OrbController>();
orbController.skill = skill;
orbController.caster = player;
GameObject skillPrafab = prafabHolder.GetSkill(skill.skillName);
OrbSkillController orbSkillControllerComponent = skill.GetComponent <OrbSkillController>();
OrbSkillController orbSkillController = (OrbSkillController)nextObrBullet.AddComponent(orbSkillControllerComponent.GetType());
orbSkillController.skill = skill;
orbSkillController.creator = gameObject;
orbController.orbSkillController = orbSkillController;
//nextObrBullet.GetComponent<Bullet>().creator = gameObject;
}
private void OnFieldOfViewEnter(object sender, Collider other)
{
GameObject colObject = other.gameObject;
if (target == null || IsPatrolling())
{
StopCoroutine("GiveUpHandler");
if (colObject.tag == Tags.Ship && colObject.GetComponent <Tail>().GetOrbCount() >= minOrbsToStartFight)
{
target = colObject;
StartCoroutine("GiveUpHandler");
}
else if (IsFreeOrb(colObject))
{
target = colObject;
orbController = colObject.GetComponent <OrbController>();
}
}
}
OrbController GetCurrentOrb()
{
OrbController closerOrb = null;
float minAngle = float.MaxValue;
int minAngleIndex = 0;
for (int i = 0; i < orbs.Count; ++i)
{
Vector3 targetDirection = (orbs[i].transform.position - camera.transform.position).normalized;
float dot = Vector3.Dot(targetDirection, camera.transform.forward);
float angle = Mathf.Acos(dot) * Mathf.Rad2Deg;
if (angle < minAngle)
{
minAngle = angle;
minAngleIndex = i;
}
}
closerOrb = orbs[minAngleIndex];
return(closerOrb);
}
private void OnFieldOfViewEnter(object sender, Collider other)
{
GameObject colObject = other.gameObject;
if (target == null || IsPatrolling())
{
StopCoroutine("GiveUpHandler");
if (colObject.tag == Tags.Ship && colObject.GetComponent <Ship>().TailLength >= minOrbsToStartFight)
{
target = colObject;
orbController = null;
powerupCollectable = null;
StartCoroutine("GiveUpHandler");
}
else if (IsFreeOrb(colObject))
{
target = colObject;
powerupCollectable = null;
orbController = colObject.GetComponent <OrbController>();
}
else
{
powerupCollectable = colObject.GetComponent <PowerUpCollectable>();
if (powerupCollectable && powerupCollectable.IsActive)
{
target = colObject;
orbController = null;
}
else
{
powerupCollectable = null;
}
}
}
}
private void ResetTarget()
{
target = null;
orbController = null;
}
void Update()
{
// Check input
Vector2 inputDirection = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical")).normalized;
Vector2 lookDirection = new Vector2(Input.GetAxisRaw("Mouse X"), Input.GetAxisRaw("Mouse Y"));
bool jump = Input.GetButtonDown("Jump");
bool fire1 = Input.GetButtonDown("Fire1");
bool fire2 = Input.GetButton("Fire2");
bool resetOrb = Input.GetButtonDown("ResetOrb");
bool grabDown = Input.GetButtonDown("Grab");
bool grabUp = Input.GetButtonUp("Grab");
bool grab = Input.GetButton("Grab");
bool interact = Input.GetButtonDown("Interact");
if (currentOrb.transform.parent != orbPoint)
{
currentOrb = GetCurrentOrb();
if (fire1)
{
Teleport(grab);
}
else if (fire2)
{
AttractOrb();
}
else if (resetOrb)
{
ResetOrb();
}
}
else
{
if (fire1)
{
ShootOrb();
}
}
animator.SetBool("Attracting", fire2 && currentOrb.transform.parent != orbPoint);
if (grabDown)
{
tryToGrab = true;
}
if (grabUp && grabbedToWall)
{
UngrabWall();
tryToGrab = false;
}
if (tryToGrab && !grabbedToWall)
{
GrabToWall();
}
if (interact)
{
Interact();
}
// Update character
if (canMove)
{
currentVelocity = GetInputVelocity(inputDirection, true);
}
MoveCharacter();
if (jump && (isGrounded || grabbedToWall))
{
tryToGrab = false;
Jump();
}
}
public GameObject CreateOrbBullet(GameObject orbBulletObj, Transform start, GameObject owner, Vector3 targetPos, Transform target, float damageModifier = 1f)
{
OrbController orbController = orbBulletObj.GetComponent <OrbController>();
DistanceDestroy distanceDestroy = orbBulletObj.GetComponent <DistanceDestroy>();
SphereCollider bulletCollider = orbBulletObj.AddComponent <SphereCollider>();
OrbBullet bullet = orbBulletObj.AddComponent <OrbBullet>();
Rigidbody rigidbody = orbBulletObj.AddComponent <Rigidbody>();
OrbSkill skill = orbController.skill;
Role ownerRole = owner.GetComponent <Role>();
ownerRole.GetSkillByName(skill.skillName).StartCD();
gizmosShootPoint = orbBulletObj.transform.position;
Vector3 scale = start.localScale;
orbBulletObj.transform.position = start.position;
orbBulletObj.transform.rotation = start.rotation;
orbBulletObj.transform.LookAt(target);
orbBulletObj.transform.localScale = scale;
gizmosShootPoint = orbBulletObj.transform.position;
distanceDestroy.fixPosition = start.position;
float raduis;
bulletColliderRadius.TryGetValue(BulletSize.Mega, out raduis);
bulletCollider.radius = raduis;
bulletCollider.enabled = true;
rigidbody.mass = 2;
rigidbody.useGravity = false;
rigidbody.constraints = RigidbodyConstraints.FreezeRotationY | RigidbodyConstraints.FreezeRotationZ | RigidbodyConstraints.FreezeRotationX;
bullet.orbSkill = skill;
bullet.bulletSpeed = normalizeAttackSpeed(ownerRole.attribute.attackSpeed);
bullet.creator = owner;
bullet.damageModifier = damageModifier;
bullet.direction = start.position - targetPos;
GameObject bulletprojectile = Instantiate(skill.bulletPrafab);
bulletprojectile.transform.SetParent(orbBulletObj.transform, false);
GameObject bulletImpactPrafab = skill.bulletImpactPrafab;
bullet.impectPrafab = bulletImpactPrafab;
bullet.autoDestroyTime = 10;
bullet.enhancement = GetBulletEnhancement();
bullet.EnhancementMerge();
bullet.PreEnhancementProcess();
bullet.ApplyForce();
orbController.caster = owner.GetComponent <Role>();
orbController.OrbAttackStart();
return(orbBulletObj);
}
//==========OTHERS==========
public void onEnemyHit(GameObject target)
{
Enemy enemy = target.GetComponent <Enemy>();
int bonusDamage = (orbController.combo / orbController.damageIncreaseStep) * orbController.damageComboIncrease;
if (bonusDamage > orbController.maxComboDamage)
{
bonusDamage = orbController.maxComboDamage;
}
int damageTaken = baseDamage + bonusDamage;
switch (behaviouralPower)
{
case GameManager.PowerType.LargeOrb:
damageTaken += largeOrbDamage;
break;
case GameManager.PowerType.Shield:
damageTaken -= mitigatedDamage;
break;
case GameManager.PowerType.Slug:
damageTaken -= mitigatedDamageSlug;
break;
}
switch (elementalPower)
{
case GameManager.PowerType.Ice:
//update in score manager
ScoreManager.scoreManager.statusAilmentApplied++;
enemy.actualFreezeCoroutine = enemy.StartCoroutine(enemy.FreezeCoroutine(freezeDuration));
damageTaken += iceDamage;
break;
case GameManager.PowerType.Fire:
//update in score manager
ScoreManager.scoreManager.statusAilmentApplied++;
if (enemy.actualFireCoroutine != null)
{
StopCoroutine(enemy.actualFireCoroutine);
}
if (isActivatedByBrazier)
{
enemy.actualFireCoroutine = enemy.StartCoroutine(enemy.FireDamage(enemy.gameObject, fireTicksDamageBrazier, fireTickDurationBrazier));
}
else
{
enemy.actualFireCoroutine = enemy.StartCoroutine(enemy.FireDamage(enemy.gameObject, fireTicksDamage, fireTickDuration));
}
damageTaken += fireDamage;
break;
case GameManager.PowerType.Electric:
//update in score manager
ScoreManager.scoreManager.statusAilmentApplied++;
StartCoroutine(ElectricZappingCoroutine(transform.position, target, true));
damageTaken += electricDamage;
DeactivatePower(elementalPower);
break;
case GameManager.PowerType.Darkness:
//update in score manager
ScoreManager.scoreManager.statusAilmentApplied++;
enemy.actualDarknessCoroutine = enemy.StartCoroutine(enemy.DarknessCoroutine(darknessTimer));
break;
}
//update in score manager (to keep track of who's given the last hit)
if (GameManager.gameManager.orb.GetComponent <OrbController>().toPlayer2)
{
enemy.lastHitByP1 = true;
enemy.lastHitByP2 = false;
}
else
{
enemy.lastHitByP1 = false;
enemy.lastHitByP2 = true;
}
enemy.TakeDamage(damageTaken);
if (behaviouralPower == GameManager.PowerType.LeechLife)
{
OrbController controller = GameManager.gameManager.orb.GetComponent <OrbController>();
if (controller.toPlayer2)
{
GameManager.gameManager.spawnHealingOrbs(1, (int)(damageTaken / (100 / lifeSteel)), "leechLife");
}
else
{
GameManager.gameManager.spawnHealingOrbs(2, (int)(damageTaken / (100 / lifeSteel)), "leechLife");
}
}
}
IEnumerator Die()
{
animation.Stop();
OrbController oc = GetComponent <OrbController>();
// Disable this component so Update and LateUpdate is no longer called
oc.enabled = false;
StartCoroutine(RandomSparkAllOver());
// Fold turret out from whatever point it was in the animation (unless it's already fully out)
if (oc.IsUnfolded() == false || animation["Take 001"].enabled)
{
animation["Take 001"].enabled = true;
animation["Take 001"].speed = 1;
}
player.SendMessage("OnGonnaBlow");
// Give the orb a rigidbody so it can move physically
Rigidbody rigid = rigidbody;
// First make the orb rotate wildly in air for 1.5 seconds
// Then make it fall to the ground and continue rotating wildly
// Make it explode after 5 seconds
float fallAfterSeconds = 1.5f;
float explodeAfterSeconds = 5.0f;
float rotateSpeed = 2000f;
float axisChange = 20f;
float time = Time.time;
Vector3 axis = Vector3.up;
while (Time.time < time + explodeAfterSeconds)
{
if (Time.deltaTime > 0 && Time.timeScale > 0)
{
// Value that starts at 0 and is 1 after fallAfterSeconds time
float fallLerp = Mathf.InverseLerp(time, time + fallAfterSeconds, Time.time);
// Value that starts at 0 and is 1 after explodeAfterSeconds time
float explodeLerp = Mathf.InverseLerp(time, time + explodeAfterSeconds, Time.time);
// Rotate the axis to create unpredictable rotation
float deltaRot = axisChange * Time.deltaTime;
axis = Quaternion.Euler(deltaRot, deltaRot, deltaRot) * axis;
// Rotate around the axis.
rigidbody.angularVelocity = axis * fallLerp * rotateSpeed * Mathf.Deg2Rad;
// Make the pitch increasingly higher until the explosion
audio.pitch = Mathf.Max(audio.pitch, 1 + Mathf.Pow(explodeLerp, 2) * 4.0f);
// Make it fall to the ground after fallAfterSeconds time
if (Time.time - time > fallAfterSeconds && rigid.useGravity == false)
{
rigid.useGravity = true;
axisChange = 90f;
StartCoroutine(PanicShooting());
}
}
yield return(0);
}
gameObject.SetActiveRecursively(false);
Instantiate(deadReplacement, transform.position, transform.rotation);
// Make player die if too close
if (Vector3.Distance(player.transform.position, transform.position) < 6)
{
// Make player die
HealthController hc = player.GetComponent <HealthController>();
hc.health = 0;
// Make player fly into the air
CharacterController cc = player.GetComponent <CharacterController>();
cc.Move(((player.transform.position - transform.position).normalized * 15 + Vector3.up * 5) * Time.deltaTime);
}
// Otherwise, player wins the game
else
{
player.SendMessage("OnWin");
}
}
void Start()
{
orbController = GameManager.gameManager.orb.GetComponent <OrbController>();
inRange = false;
}
public void GiveOrbDest(OrbController orb)
{
orb.destination = target.position;
curOrb = orb;
}
public void changeOrb()
{
currentOrb = GameManager.instance.playerTeam[tokenDropdown.value];
showCursor();
}
