// Use this for initialization void Start() { LocationDetector detector = GetComponent <LocationDetector>(); Vector3 newTargetLocation = detector.targetLocation; newTargetLocation += getRandomPositionInCircle(); newTargetLocation = new Vector3(newTargetLocation.x, getY(newTargetLocation), newTargetLocation.z); detector.targetLocation = newTargetLocation; }
// Use this for initialization void Start() { baseLocalScaleZ = transform.localScale.z; detector = GetComponentInParent <LocationDetector>(); if (detector) { startLocation = detector.startLocation; } }
public void Start() { if (!active) { return; } //if the aiming method requires a component that is not present do not use it if (aimingMethod == AimingMethod.TargetDirection && !GetComponent <LocationDetector>()) { aimingMethod = AimingMethod.Random; } if (aimingMethod == AimingMethod.TravelDirection && !GetComponent <AbilityMover>()) { aimingMethod = AimingMethod.Random; } Vector3 startPos = transform.position; if (createAtTarget) { LocationDetector ld = GetComponent <LocationDetector>(); if (ld) { startPos = ld.targetLocation; } } else if (createAtStartLocation) { LocationDetector ld = GetComponent <LocationDetector>(); if (ld) { startPos = ld.startLocation; } } startPos += offset; // create the ability object depending on the aiming method if (aimingMethod == AimingMethod.Random) { // create a random aim point Vector3 aimPoint = new Vector3(startPos.x + Random.Range(-5f, 5f), startPos.y, startPos.z + Random.Range(-5f, 5f)); // create the ability object GetComponent <AbilityObjectConstructor>().constructAbilityObject(abilityToInstantiate, startPos, aimPoint); } else if (aimingMethod == AimingMethod.TargetDirection) { // create the ability object GetComponent <AbilityObjectConstructor>().constructAbilityObject(abilityToInstantiate, startPos, GetComponent <LocationDetector>().targetLocation); } else if (aimingMethod == AimingMethod.TravelDirection) { // create the ability object GetComponent <AbilityObjectConstructor>().constructAbilityObject(abilityToInstantiate, startPos, transform.position + GetComponent <AbilityMover>().positionDelta); } }
// Use this for initialization void Start() { // get references mover = GetComponent <AbilityMover>(); locationDetector = GetComponent <LocationDetector>(); // set the current direction to the start direction currentDirection = locationDetector.targetLocation - locationDetector.startLocation; // randomise at start if (timeToRandomise == TimeToRandomise.Start) { randomiseDirection(maximumAngleChange); } // prepare to randomise initialy if using direction mode index = directionChangeInterval; }
// Use this for initialization void Start() { abilityMover = GetComponent <AbilityMover>(); locationDetector = GetComponent <LocationDetector>(); AlignmentManager alignmentManager = GetComponent <AlignmentManager>(); if (locationDetector && alignmentManager) { Alignment alignment = alignmentManager.alignment; if (alignment) { List <Transform> possibleTargets = new List <Transform>(); foreach (BaseHealth health in BaseHealth.all) { if (health.alignmentManager && alignment.foes.Contains(health.alignmentManager.alignment) && health.currentHealth > 0) { possibleTargets.Add(health.transform); } } Vector3 position = locationDetector.targetLocation; targetPosition = position; float distance = 0f; float targetDistance = 0f; foreach (Transform possibleTarget in possibleTargets) { distance = Vector3.Distance(position, possibleTarget.position); targetDistance = Vector3.Distance(position, targetPosition); if ((target == null || distance < targetDistance) && distance < maxDistanceFromTarget) { targetPosition = possibleTarget.position; target = possibleTarget; } } if (target) { targetGo = target.gameObject; } } } }
public static void copy(LocationDetector to, LocationDetector from) { to.startLocation = from.startLocation; to.targetLocationOffset = from.targetLocationOffset; to.targetLocation = from.targetLocation - from.targetLocationOffset; }
public GameObject constructAbilityObject(Ability ability, Vector3 location, Vector3 targetLocation, GameObject overridePrefab = null, bool InheritSharedHitDetector = true) { // create the ability object GameObject abilityObject = null; if (overridePrefab == null) { // if there is no override prefab instantiate the ability's ability prefab abilityObject = Instantiate(ability.abilityPrefab, location, Quaternion.Euler(targetLocation - location)); } else // othewise instrantiate the override prefab { abilityObject = Instantiate(overridePrefab, location, Quaternion.Euler(targetLocation - location)); } // apply the relevant mutator if this entity has one if (mutatorManager) { mutators = mutatorManager.getMutators(ability); if (mutators != null) { foreach (AbilityMutator mutator in mutators) { abilityObject = mutator.Mutate(abilityObject, location, targetLocation); if (mutator.changeLocation) { targetLocation = mutator.newLocation; } if (mutator.changeTargetLocation) { targetLocation = mutator.newTargetLocation; } } } } // move the ability object if necessary foreach (DefineStartLocation defineStartLocation in abilityObject.GetComponents <DefineStartLocation>()) { if (defineStartLocation.active) { defineStartLocation.setLocation(location, targetLocation); // the direction from the cast point needs to be maintained if (defineStartLocation.maintainDirectionFromCastPoint()) { targetLocation = abilityObject.transform.position + targetLocation - location; } } } // initialise a location detector if necessary LocationDetector locationDetector = abilityObject.GetComponent <LocationDetector>(); if (locationDetector) { locationDetector.startLocation = abilityObject.transform.position; locationDetector.targetLocation = targetLocation; } // rotate the ability object abilityObject.transform.LookAt(targetLocation); // give the ability object its alignment AlignmentManager abilityAlignmentManager = abilityObject.GetComponent <AlignmentManager>(); if (!abilityAlignmentManager) { abilityAlignmentManager = abilityObject.AddComponent <AlignmentManager>(); } abilityAlignmentManager.alignment = myAlignmentManager.alignment; // give the ability object its creation references CreationReferences abilityCreationReferences = abilityObject.GetComponent <CreationReferences>(); if (!abilityCreationReferences) { abilityCreationReferences = abilityObject.AddComponent <CreationReferences>(); } abilityCreationReferences.thisAbility = ability; abilityCreationReferences.locationCreatedFrom = location; // if this an ability object then the creator is this objects creator, otherwise the creator is this object if (myCreationReferences && GetComponent <AbilityObjectIndicator>()) { abilityCreationReferences.creator = myCreationReferences.creator; } else { abilityCreationReferences.creator = gameObject; } // check whether there should be a shared hit detector HitDetector abilityHitDetector = abilityObject.GetComponent <HitDetector>(); if (abilityHitDetector) { SharedHitDetector sharedHitDetector = null; if (myHitDetector && myHitDetector.sharedHitDetector && InheritSharedHitDetector) { sharedHitDetector = myHitDetector.sharedHitDetector; } // create a shared hit detector else if (ability.sharedHitDetector) { GameObject newGameObject = new GameObject(); sharedHitDetector = newGameObject.AddComponent <SharedHitDetector>(); sharedHitDetector.gameObject.AddComponent <SelfDestroyer>(); sharedHitDetector.name = abilityObject.name + "'s shared hit detector"; } if (sharedHitDetector != null && !abilityHitDetector.cannotHaveSharedhitDetector) { abilityHitDetector.sharedHitDetector = sharedHitDetector; } } // build the damage stats for each damage stats holder foreach (DamageStatsHolder damageStatsHolder in abilityObject.GetComponents <DamageStatsHolder>()) { damageStatsHolder.damageStats = DamageStats.buildDamageStats(damageStatsHolder, GetComponent <TaggedStatsHolder>()); } // attach any on hit status appliers if this ability deals damage on hit if (myTaggedStatsHolder && abilityObject.GetComponent <DamageEnemyOnHit>() && !abilityObject.GetComponent <CannotApplyAdditionalStatuses>()) { ChanceToApplyStatusOnEnemyHit applier; float poisonChance = myTaggedStatsHolder.GetStatValue(Tags.Properties.PoisonChance, ability.useTags); if (poisonChance > 0) { applier = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>(); applier.statusEffect = StatusEffectList.getEffect(StatusEffectID.Poison); applier.chance = poisonChance; applier.canApplyToSameEnemyAgain = false; } float igniteChance = myTaggedStatsHolder.GetStatValue(Tags.Properties.IgniteChance, ability.useTags); if (igniteChance > 0) { applier = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>(); applier.statusEffect = StatusEffectList.getEffect(StatusEffectID.Ignite); applier.chance = igniteChance; applier.canApplyToSameEnemyAgain = false; } float chillChance = myTaggedStatsHolder.GetStatValue(Tags.Properties.ChillChance, ability.useTags); if (chillChance > 0) { applier = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>(); applier.statusEffect = StatusEffectList.getEffect(StatusEffectID.Chill); applier.chance = chillChance; applier.canApplyToSameEnemyAgain = false; } float slowChance = myTaggedStatsHolder.GetStatValue(Tags.Properties.SlowChance, ability.useTags); if (slowChance > 0) { applier = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>(); applier.statusEffect = StatusEffectList.getEffect(StatusEffectID.Slow); applier.chance = slowChance; applier.canApplyToSameEnemyAgain = false; } float blindChance = myTaggedStatsHolder.GetStatValue(Tags.Properties.BlindChance, ability.useTags); if (blindChance > 0) { applier = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>(); applier.statusEffect = StatusEffectList.getEffect(StatusEffectID.Blind); applier.chance = blindChance; applier.canApplyToSameEnemyAgain = false; } float bleedChance = myTaggedStatsHolder.GetStatValue(Tags.Properties.BleedChance, ability.useTags); if (bleedChance > 0) { applier = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>(); applier.statusEffect = StatusEffectList.getEffect(StatusEffectID.Bleed); applier.chance = bleedChance; applier.canApplyToSameEnemyAgain = false; } float shockChance = myTaggedStatsHolder.GetStatValue(Tags.Properties.ShockChance, ability.useTags); if (shockChance > 0) { applier = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>(); applier.statusEffect = StatusEffectList.getEffect(StatusEffectID.Shock); applier.chance = shockChance; applier.canApplyToSameEnemyAgain = false; } } // if the ability has an ability object constructor give it a tagged stats holder with your tagged stats if (myTaggedStatsHolder && abilityObject.GetComponent <RequiresTaggedStats>()) { TaggedStatsHolder holder = abilityObject.GetComponent <TaggedStatsHolder>(); if (holder == null) { holder = abilityObject.AddComponent <TaggedStatsHolder>(); } holder.simpleStats.AddRange(myTaggedStatsHolder.simpleStats); holder.taggedStats.AddRange(myTaggedStatsHolder.taggedStats); } // set the direction if there is an ability mover if (abilityObject.GetComponent <AbilityMover>()) { abilityObject.GetComponent <AbilityMover>().positionDelta = Vector3.Normalize(targetLocation - location); // if the ability object defines its own start direction then let it if (abilityObject.GetComponent <DefineStartDirection>()) { abilityObject.GetComponent <DefineStartDirection>().setDirection(); } } // run any on creation methods foreach (OnCreation component in abilityObject.GetComponents <OnCreation>()) { if (component.runOnCreation) { component.onCreation(); } } // invoke the event if (abilityObjectCreatedEvent != null) { abilityObjectCreatedEvent.Invoke(ability, abilityObject); } return(abilityObject); }
public void createAbilityObject() { if (failsIfFailedAbility) { SelfDestroyer destroyer = GetComponent <SelfDestroyer>(); if (destroyer && destroyer.failedAbility) { return; } } //if the aiming method requires a component that is not present do not use it if (aimingMethod == AimingMethod.TargetDirection && !GetComponent <LocationDetector>()) { aimingMethod = AimingMethod.Random; } if (aimingMethod == AimingMethod.TravelDirection && !GetComponent <AbilityMover>()) { aimingMethod = AimingMethod.Random; } Vector3 startPos = transform.position; if (createAtTarget) { LocationDetector ld = GetComponent <LocationDetector>(); if (ld) { startPos = ld.targetLocation; } } else if (createAtStartLocation) { LocationDetector ld = GetComponent <LocationDetector>(); if (ld) { startPos = ld.startLocation; } } else if (createAtCastLocation) { CreationReferences references = GetComponent <CreationReferences>(); if (references) { startPos = references.locationCreatedFrom; } } startPos += offset; // create the ability object depending on the aiming method if (aimingMethod == AimingMethod.Random) { // create a random aim point Vector3 aimPoint = new Vector3(startPos.x + Random.Range(-5f, 5f), startPos.y, startPos.z + Random.Range(-5f, 5f)); // create the ability object GetComponent <AbilityObjectConstructor>().constructAbilityObject(abilityToInstantiate, startPos, aimPoint); } else if (aimingMethod == AimingMethod.TargetDirection) { // create the ability object GetComponent <AbilityObjectConstructor>().constructAbilityObject(abilityToInstantiate, startPos, GetComponent <LocationDetector>().targetLocation); } else if (aimingMethod == AimingMethod.TravelDirection) { // create the ability object GetComponent <AbilityObjectConstructor>().constructAbilityObject(abilityToInstantiate, startPos, transform.position + GetComponent <AbilityMover>().positionDelta); } }
// Use this for initialization void Start() { mover = GetComponent <AbilityMover>(); detector = GetComponent <LocationDetector>(); previousPosition = transform.position; }
public void createObjects() { objectsToCreateOnDeath.RemoveAll(x => x.gameObject == null); Transform caster = null; GameObject go = null; if (attachToCaster) { CreationReferences references = GetComponent <CreationReferences>(); if (references && references.creator) { caster = GetComponent <CreationReferences>().creator.transform; } } if (rotationToPassOn == RotationToPassOn.Own) { foreach (GameObjectHolder holder in objectsToCreateOnDeath) { go = Instantiate(holder.gameObject, transform.position, transform.rotation); if (caster) { go.transform.parent = caster; go.transform.localPosition = new Vector3(0, 0, 0); } } } else if (rotationToPassOn == RotationToPassOn.Parent && transform.parent) { foreach (GameObjectHolder holder in objectsToCreateOnDeath) { go = Instantiate(holder.gameObject, transform.position, transform.parent.transform.rotation); if (caster) { go.transform.parent = caster; go.transform.localPosition = new Vector3(0, 0, 0); } } } else { foreach (GameObjectHolder holder in objectsToCreateOnDeath) { go = Instantiate(holder.gameObject, transform.position, Quaternion.identity); if (caster) { go.transform.parent = caster; go.transform.localPosition = new Vector3(0, 0, 0); } } } if (go && passOnLocationDetector) { LocationDetector detector = GetComponent <LocationDetector>(); if (detector) { LocationDetector newDetector = go.GetComponent <LocationDetector>(); if (!newDetector) { newDetector = go.AddComponent <LocationDetector>(); } LocationDetector.copy(newDetector, detector); } } if (go && passOnCreationReferences) { CreationReferences references = GetComponent <CreationReferences>(); if (references) { CreationReferences newReferences = go.GetComponent <CreationReferences>(); if (!newReferences) { newReferences = go.AddComponent <CreationReferences>(); } references.copyTo(newReferences); } } // apply increases to radius and height if (increasedRadius != 0 || increasedHeight != 0) { go.transform.localScale = new Vector3(go.transform.localScale.x * (1 + increasedRadius), go.transform.localScale.y * (1 + increasedHeight), go.transform.localScale.z * (1 + increasedRadius)); } }
// Use this for initialization void Start() { locationDetector = GetComponent <LocationDetector>(); }