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(); }