public override void CopyValues(ScrObjLibraryEntry other)
{
base.CopyValues(other);
EnemyEntry ee = (EnemyEntry)other;
// General
enemyModelN = ee.enemyModelN;
enemyModelS = ee.enemyModelS;
maxhp = ee.maxhp;
speed = ee.speed;
// AI values
waitStates = new List <StateController.WaitStates>();
for (int i = 0; i < ee.waitStates.Count; i++)
{
waitStates.Add(ee.waitStates[i]);
}
waitTimeLimits = new RangedFloat(ee.waitTimeLimits.minValue, ee.waitTimeLimits.maxValue);
chaseTimeLimit = ee.chaseTimeLimit;
fleeDistance = ee.fleeDistance;
fleeTimeLimit = ee.fleeTimeLimit;
// Attacking
meleeRange = ee.meleeRange;
attackRate = ee.attackRate;
attacks = ee.attacks;
meleeTimeStartup = ee.meleeTimeStartup;
meleeTimeAnimation = ee.meleeTimeAnimation;
// Reward
exp = ee.exp;
money = ee.money;
//Add some kind of loot table
}
//Add some kind of loot table
public override void ResetValues()
{
base.ResetValues();
// General
enemyModelN = null;
enemyModelS = null;
maxhp = 1;
speed = new Vector2(0f, 0f);
// AI values
waitStates = new List <WaitStates>();
waitTimeLimits = new RangedFloat(3f, 5f);
chaseTimeLimit = 30f;
fleeDistance = 3f;
fleeTimeLimit = 30f;
// Attacking
meleeRange = 1f;
attackRate = 1f;
attacks = 1;
meleeTimeStartup = 0.5f;
//Sounds
attackChargeSfx = null;
attackActivateSfx = null;
attackImpactSfx = null;
// Reward
exp = 0;
money = 0;
//Add some kind of loot table
}
public CState_JumpMotor(float[] movementSpeed, RangedFloat applicationPeriod, float minDotValue = -1f)
{
Debug.Assert(movementSpeed.Length <= 4);
this.movementSpeed = movementSpeed;
this.applicationPeriod = applicationPeriod;
this.minDotValue = minDotValue;
}
public void SetNewDesiredAngle(Transform transform, float rotation, RangedFloat desiredAngleDifference)
{
float diff = Random.Range(desiredAngleDifference.min, desiredAngleDifference.max);
diff = Random.value > 0.5f ? diff : -diff;
desiredAngle = rotation + diff;
}
public GameSetting()
{
PlayerView = new RangedInt(1, 5, 3);
PlayerSpeed = new RangedInt(1, 9, 4);
JumpForce = new RangedFloat(0.5f, 5.0f, 0.5f);
RotateSensitivity = new RangedFloat(0.2f, 5.0f, 1.0f);
PickingDistance = new RangedInt(12, 32, 16);
}
public void AddTransitionToAllStates(CharacterState target, RangedFloat transitionRange, bool bufferInput = true)
{
foreach (var it in states)
{
if (it != target)
{
it.AddTransition(target, transitionRange, bufferInput);
}
}
}
public void SetValue(RangedFloat FloatValue)
{
m_Slider.wholeNumbers = false;
m_Slider.minValue = FloatValue.MinValue;
m_Slider.maxValue = FloatValue.MaxValue;
m_Slider.value = FloatValue.Get();
m_SliderValue.text = FloatValue.Get().ToString();
}
public CharacterState AddTransition(CharacterState target, RangedFloat transitionRange, bool bufferInput = true, StateTransition.CanEnter canEnter = null)
{
StateTransition transition = new StateTransition();
transition.target = target;
transition.transitionRange = transitionRange;
transition.bufferInput = bufferInput;
transition.canEnter = canEnter;
transitions.Add(transition);
return(this);
}
public void SetDestination_Flee(FocusOwned focus, RangedFloat desiredDistance, float searchArea = 1.0f)
{
if (!focus.HasTarget())
{
destination = (Vector2)transform.position + Random.insideUnitCircle.normalized * desiredDistance.GetRandom() + Random.insideUnitCircle * searchArea;
return;
}
Vector2 toTarget = -focus.ToTarget();
destination = (Vector2)transform.position + toTarget.normalized * desiredDistance.GetRandom() + Random.insideUnitCircle * searchArea;
}
public Vector2 GetRotationInput(Transform transform, float rotation, RangedFloat desiredangleDifference, float rotationLerp = 0.1f)
{
if (tChangeDesiredAngle.IsReadyRestart())
{
SetNewDesiredAngle(transform, rotation, desiredangleDifference);
tChangeDesiredAngle.cd = Random.Range(tChangeAngle.min, tChangeAngle.max);
}
angle = Mathf.LerpAngle(angle, desiredAngle, rotationLerp);
Vector2 desiredRotationInput = Quaternion.Euler(0, 0, angle) * Vector2.up;
return(desiredRotationInput);
}
static public void RangedSlider(ref float value, float range, string text, string tooltip, string saveHash, bool onlyPositive)
{
saveHash += text;
Rect rect = EditorGUILayout.GetControlRect();
rect.height = GUI.skin.horizontalSlider.CalcSize(new GUIContent(text)).y;
RangedFloat r = null;
if (EditorPrefs.HasKey(saveHash))
{
r = new RangedFloat(value, range, onlyPositive);
r.range.min = EditorPrefs.GetFloat(saveHash + "min");
r.range.max = EditorPrefs.GetFloat(saveHash + "max");
r.open = EditorPrefs.GetBool(saveHash);
}
if (r == null || !r.range.InRange(value))
{
r = new RangedFloat(value, range, onlyPositive);
r.open = EditorPrefs.GetBool(saveHash, false);
}
Rect fold = rect;
fold.width = 32;
r.open = EditorGUI.Foldout(fold, r.open, "");
value = EditorGUI.Slider(rect, new GUIContent(text, tooltip), value, r.range.min, r.range.max);
if (r.open)
{
EditorGUI.indentLevel++;
RangeField(ref r.range, "Slider Range", "Customize this slider's range");
EditorGUI.indentLevel--;
value = r.range.Clamp(value);
}
if (onlyPositive && r.range.min < 0)
{
r.range.min = 0;
}
EditorPrefs.SetFloat(saveHash + "min", r.range.min);
EditorPrefs.SetFloat(saveHash + "max", r.range.max);
EditorPrefs.SetBool(saveHash, r.open);
}
public AnimationState AddTransition(AnimationState target, RangedFloat transitionRange, bool bufferInput = true, BoolMethod canEnter = null)
{
AnimationTransition transition = new AnimationTransition();
transition.target = target;
transition.transitionRange = transitionRange;
transition.bufferInput = bufferInput;
if (canEnter != null)
{
transition.canEnter = canEnter;
}
_transitions.Add(transition);
return(this);
}
private void Reset()
{
SoundName = DEFAULT_SOUND_NAME;
IgnoreListenerPause = DEFAULT_IGNORE_LISTENER_PAUSE;
Loop = DEFAULT_LOOP;
Volume = new RangedFloat {
MinValue = DEFAULT_VOLUME, MaxValue = DEFAULT_VOLUME
};
Pitch = new RangedFloat {
MinValue = DEFAULT_PITCH, MaxValue = DEFAULT_PITCH
};
SpatialBlend = DEFAULT_SPATIAL_BLEND;
Mode = DEFAULT_PLAY_MODE;
ResetSequenceAfterInactiveTime = DEFAULT_RESET_SEQUENCE_AFTER_INACTIVE_TIME;
SequenceResetTime = DEFAULT_SEQUENCE_RESET_TIME;
}
public AnimationState AddTransition(AnimationState target, RangedFloat transitionRange, bool bufferInput = true, Func <bool> canEnter = null)
{
AnimationTransition transition = new AnimationTransition
{
target = target,
transitionRange = transitionRange,
bufferInput = bufferInput
};
if (canEnter != null)
{
transition.canEnter = canEnter;
}
_transitions.Add(transition);
return(this);
}
/// <summary> /// Value is in a RangedFloat, max-inclusive. /// </summary> public static bool InRangeInclusive(this float value, RangedFloat range) => value.InRangeInclusive(range.Min, range.Max);
public static void RotationToDirection(RigidbodyMovement movement, Vector2 direction, RangedFloat applicationPeriod, float rotationSpeed = 0.3f)
{
//Vector2 destination = Vector2.Lerp(inputHolder.directionInput, direction, trackFactor);
//movement.atExternalRotation = false;
//if (applicationPeriod.InRange(animationTime))
//movement.ApplyExternalRotation(destination, rotationSpeed);
}
public static void Motor(Rigidbody2D rb, Vector2 movementSpeed, float animationTime, RangedFloat applicationPeriod)
{
if (applicationPeriod.InRange(animationTime))
{
Motor(rb, movementSpeed);
}
}
public Vector2 StayInRange(RangedFloat range)
{
return(StayInRange(range.min, range.max));
}
public override void InitBehaviours(AiBehaviourController controller)
{
var stateMachine = controller.stateMachine;
var inputHolder = controller.GetComponentInParent <InputHolder>();
var transform = controller.transform;
FocusPriority priorityFocus = controller.focusPriority;
AttentionMode enemyAttention = AiBehaviourPackUtility.GetAttentionEnemy(controller);
var tExecute = new Timer();
var lookAroundMethod = new LookAround(new RangedFloat(0.5f, 0.8f), new RangedFloat(25, 50));
// TODO if seeker is not defined create MoveToDestination instead
var moveToDestination = new MoveToDestinationNavigation(controller.GetComponent <Seeker>());
var velocityAccumulator = new VelocityAccumulator(0.89f, 0.125f);
var destination = controller.InitBlackboardValue <Vector2>("destination");
////////////////
/// idle
var lookAtTarget = enemyAttention.AddNewState(true)
.AddOnBegin(inputHolder.ResetInput)
.AddOnBegin(() => tExecute.RestartRandom(1f, 2f))
.AddOnUpdate(() => {
velocityAccumulator.Update(transform, priorityFocus.currentFocus.GetTarget(), 0.01225f);
inputHolder.rotationInput = velocityAccumulator.position - (Vector2)transform.position;
inputHolder.directionInput = velocityAccumulator.position - (Vector2)transform.position;
})
.AddShallReturn(() => tExecute.IsReady())
.SetUtility(() => 10)
;
var lookAround = enemyAttention.AddNewState(true)
.AddOnBegin(() => lookAroundMethod.Begin(transform))
.AddOnBegin(inputHolder.ResetInput)
.AddOnBegin(() => tExecute.RestartRandom(0.6f, 1.5f))
.AddOnUpdate(() =>
{
velocityAccumulator.Update(transform, priorityFocus.currentFocus.GetTarget(), 0.01225f);
Vector2 targetPosition = velocityAccumulator.position - (Vector2)transform.position;
float angle = Vector2.SignedAngle(Vector2.up, targetPosition);
inputHolder.rotationInput = lookAroundMethod.GetRotationInput(transform, angle, 0.1f);
inputHolder.directionInput = velocityAccumulator.position - (Vector2)transform.position;
})
.AddShallReturn(() => tExecute.IsReady() || priorityFocus.currentFocus.GetTarget().velocity.sqrMagnitude > 20)
.SetUtility(() => 15f - 0.225f * priorityFocus.currentFocus.GetTarget().velocity.sqrMagnitude)
;
RangedFloat desiredDistance = new RangedFloat(8.5f, 15.5f);
float margin = 3.0f;
var moveTo = enemyAttention.AddNewState(true)
.AddOnBegin(() => moveToDestination.SetDestination(velocityAccumulator.position))
.AddOnBegin(() => inputHolder.ResetInput(false, true, true, true))
.AddOnBegin(() => tExecute.RestartRandom(0.25f, 0.5f))
.AddOnUpdate(() =>
{
velocityAccumulator.Update(transform, priorityFocus.currentFocus.GetTarget(), 0.01225f);
Vector2 currentTargetPosition = velocityAccumulator.position;
moveToDestination.RepathAsNeeded(currentTargetPosition, 3.0f);
Vector2 toDestination = moveToDestination.ToDestination(5, 0.5f);
inputHolder.positionInput = Vector2.Lerp(inputHolder.positionInput, toDestination, 0.1f);
inputHolder.directionInput = velocityAccumulator.position - (Vector2)transform.position;
})
.AddCanEnter(() => enemyAttention.focus.IsFurther(desiredDistance.max))
.AddShallReturn(tExecute.IsReady)
.AddShallReturn(() => enemyAttention.focus.IsCloser(desiredDistance.min + margin))
.AddShallReturn(() => moveToDestination.finished)
.SetUtility(5000f)
;
var moveAway = enemyAttention.AddNewState(true)
.AddOnBegin(() => moveToDestination.SetDestination(priorityFocus.GetAwayFromTargetPosition(desiredDistance.max - margin)))
.AddOnBegin(() => inputHolder.ResetInput(false, true, true, true))
.AddOnBegin(() => tExecute.RestartRandom(0.25f, 0.5f))
.AddOnUpdate(() =>
{
velocityAccumulator.Update(transform, priorityFocus.currentFocus.GetTarget(), 0.01225f);
Vector2 currentTargetPosition = velocityAccumulator.position;
Vector2 toDestination = moveToDestination.ToDestination(5, 0.5f);
inputHolder.positionInput = Vector2.Lerp(inputHolder.positionInput, toDestination, 0.1f);
inputHolder.directionInput = velocityAccumulator.position - (Vector2)transform.position;
})
.AddCanEnter(() => enemyAttention.focus.IsCloser(desiredDistance.min))
.AddShallReturn(tExecute.IsReady)
.AddShallReturn(() => enemyAttention.focus.IsFurther(desiredDistance.max - margin))
.AddShallReturn(() => moveToDestination.finished)
.SetUtility(5000f)
;
/// ideas:
/// looks a little bit to sides sometimes
/// tries to keep certain distance from enemy
/*/// lookAround
* var lookAround = enemyAttention.AddNewState(true)
* .AddOnBegin(() => lookAroundMethod.Begin(transform))
* .AddOnBegin(inputHolder.ResetInput)
* .AddOnBegin(() => tExecute.RestartRandom(0.25f, 0.4f))
* .AddOnUpdate(() =>
* {
* inputHolder.rotationInput = lookAroundMethod.GetRotationInput(transform);
* })
* .AddShallReturn(() => tExecute.IsReady())
* .SetUtility(6)
* ;
*
* /// randomMovement
* var randomMovement = enemyAttention.AddNewState(true)
* .AddOnBegin(() => moveToDestination.SetDestination_Search(priorityFocus, 20))
* .AddOnBegin(inputHolder.ResetInput)
* .AddOnBegin(() => tExecute.RestartRandom(0.75f, 1.5f))
* .AddOnUpdate(() =>
* {
* inputHolder.positionInput = moveToDestination.ToDestination();
* //inputHolder.positionInput = Vector2.Lerp(inputHolder.positionInput, moveToDestination.ToDestination(), 0.985f );
* })
* .AddShallReturn(() => tExecute.IsReady())
* .SetUtility(2f)
* ;*/
}
public CState_JumpMotor(float movementSpeed, RangedFloat applicationPeriod, float minDotValue = -1f)
{
this.movementSpeed = new float[] { movementSpeed, movementSpeed, movementSpeed, movementSpeed };
this.applicationPeriod = applicationPeriod;
this.minDotValue = minDotValue;
}
public HidAccessPropertyRangedSingle()
{
RangedValue = new RangedFloat();
RangedValue.ValueChanged += (sender, e) => { OnValueChanged(e); };
}
public Vector2 GetRotationInput(Transform transform, RangedFloat desiredAngleDifference, float rotationLerp = 0.1f)
{
return(GetRotationInput(transform, transform.eulerAngles.z, desiredAngleDifference, rotationLerp));
}
public CState_RotationToDirection(RangedFloat applicationPeriod, float lerpScale = 0.3f, float trackFactor = 1f)
{
this.rotationSpeed = lerpScale;
this.trackFactor = trackFactor;
this.applicationPeriod = applicationPeriod;
}
public LookAround(RangedFloat tChangeAngle, RangedFloat desiredAngleDifference)
{
this.tChangeAngle = tChangeAngle;
this.desiredAngleDifference = desiredAngleDifference;
}
public Slider(RangedFloat property)
: this(property, property.Min, property.Max)
{
property.Changed += SetFromValue;
}
public LookAround(RangedFloat tChangeAngle)
{
this.tChangeAngle = tChangeAngle;
}
public CState_Motor(Vector2 movementSpeed, RangedFloat applicationPeriod)
{
this.movementSpeed = movementSpeed;
this.applicationPeriod = applicationPeriod;
}
public void RestartRandom(RangedFloat cdRange)
{
actualTime = Time.time;
cd = UnityEngine.Random.Range(cdRange.min, cdRange.max);
}
private void Start()
{
animInfo = new AnimationInformation();
waitTimeLimits = new RangedFloat(3f, 5f);
moveSpeed = npcMoveSpeed.value;
}
public static float Range(this Random r, RangedFloat rFloat)
{
return(Random.Range(rFloat.minValue, rFloat.maxValue));
}
public void AddTransitionToAllStates(CharacterState target, ExceptionCondition exceptionCondition, RangedFloat transitionRange, AnimationTransitionData transitionData, bool bufferInput = true)
{
foreach (var it in states)
{
if (it != target && !exceptionCondition(it))
{
it.AddTransition(target, transitionRange, transitionData, bufferInput);
}
}
}
