private void DoArmExtension(params object[] parameters)
{
if (isAnimating)
{
if (stateVariables.eatTargetEnemy)
{
// stateVariables.statsManager.MakeHappy();
IEatable eatable = stateVariables.eatTargetEnemy.GetComponent <IEatable>();
if (!eatable.IsNull())
{
Assert.IsNotNull(eatable);
grabSpot = eatable.GetGrabObject().transform.position;
clawArmController.StartExtension(eatable.GetGrabObject(), stateVariables.clawExtensionTime, stateVariables.clawRetractionTime);
SFXManager.Instance.Play(stateVariables.ArmExtensionSFX, transform.position);
}
}
else
{
stateVariables.eatTargetEnemy = dummyObject;
dummyObject.transform.position = stateVariables.modelHead.transform.position + stateVariables.modelHead.transform.forward * 5.0f;
grabSpot = dummyObject.transform.position;
clawArmController.StartExtension(dummyObject, stateVariables.clawExtensionTime, stateVariables.clawRetractionTime);
SFXManager.Instance.Play(stateVariables.ArmExtensionSFX, transform.position);
}
}
}
public Dog(string name)
{
this.Name = name;
AddToForest();
Type = "dog";
EatType = new MeatEat();
}
public void ReleaseHavoc()
{
for (int b = 1; b <= numberOffBadBoys; b++)
{
foreach (ChristmasDecoration christmasDecoration in christmasDecorations)
{
if (christmasDecoration is IBreakable)
{
IBreakable breakable = (IBreakable)christmasDecoration;
breakable.TryToBreak();
}
if (christmasDecoration is IEatable)
{
IEatable eatable = (IEatable)christmasDecoration;
eatable.TryToEat();
}
}
}
for (int c = 1; c <= numberOffCats; c++)
{
foreach (ChristmasDecoration christmasDecoration in christmasDecorations)
{
if (christmasDecoration is ChristmasBauble)
{
ChristmasBauble christmasBauble = (ChristmasBauble)christmasDecoration;
christmasBauble.TryToBreak();
}
if (christmasDecoration is ChristmasCookie)
{
ChristmasCookie christmasCookie = (ChristmasCookie)christmasDecoration;
christmasCookie.TryToEat();
}
}
}
}
public void Eat(IEatable food)
{
switch (food.Type)
{
case Food.FoodType.Normal:
UpdateScore(Settings.NormalFoodValue);
GrowSnake(Settings.NormalFoodValue);
break;
case Food.FoodType.Golden:
UpdateScore(Settings.GoldenFoodValue);
GrowSnake(Settings.GoldenFoodValue);
break;
case Food.FoodType.Speed:
UpdateScore(Settings.SpeedFoodValue);
GrowSnake(Settings.SpeedFoodValue);
SpeedUp(Settings.SpeedModifier);
break;
case Food.FoodType.Slow:
UpdateScore(Settings.SlowFoodValue);
GrowSnake(Settings.SlowFoodValue);
SlowDown(Settings.SpeedModifier);
break;
case Food.FoodType.Megaspeed:
ActivateHyperDrive();
break;
}
}
protected override void Start()
{
FoodTargets = new List <Transform>();
PredatorTargets = new List <Transform>();
base.Start();
PredatorDetected = false;
FoodDetected = false;
Detection = GetComponent <UnitDetection>();
Eater = GetComponent <IEater>();
Eatable = GetComponent <IEatable>();
Exhausted = GetComponent <Exhaustion>();
SubGoal s1 = new SubGoal(State.NotHungry, 1, false);
// Add it to the goals
goals.Add(s1, 0);
SubGoal s2 = new SubGoal(State.NotExhausted, 1, false);
// Add it to the goals
goals.Add(s2, 0);
SubGoal s3 = new SubGoal(State.NotEaten, 1, false);
// Add it to the goals
goals.Add(s3, 2);
Detection.OnTargetsUpdated += FilterEatableTargets;
Detection.OnTargetsUpdated += FilterEaterTargets;
}
public Deer(string name)
{
this.Name = name;
AddToForest();
Type = "Deer";
EatType = new HerbsEat();
}
public Squirrel(string name)
{
this.Name = name;
AddToForest();
Type = "Squirrel";
EatType = new HerbsEat();
}
private void DoEating()
{
//Check if enemy is still alive
if (stateVariables.eatTargetEnemy.activeSelf)
{
IEatable eatable = stateVariables.eatTargetEnemy.GetComponent <IEatable>();
if (!eatable.IsNull())
{
int health;
eatable.Eat(out health);
stateVariables.statsManager.TakeHealth(health);
Stats stats = GetComponent <Stats>();
EventSystem.Instance.TriggerEvent(Strings.Events.UPDATE_HEALTH, stats.GetHealthFraction());
EventSystem.Instance.TriggerEvent(Strings.Events.ENEMY_DEATH_BY_EATING);
GameObject skinningEffect = ObjectPool.Instance.GetObject(PoolObjectType.VFXMallCopExplosion);
playerFaceController.SetTemporaryEmotion(Turing.VFX.PlayerFaceController.Emotion.Happy, happyTimeAfterEating);
if (skinningEffect && clawTransform)
{
skinningEffect.transform.position = clawTransform.position;
}
GameObject healthJuice = ObjectPool.Instance.GetObject(PoolObjectType.VFXHealthGain);
if (healthJuice)
{
healthJuice.FollowAndDeActivate(3f, transform, Vector3.up * 3.2f, CoroutineName);
}
SFXManager.Instance.Play(stateVariables.EatSFX, transform.position);
}
}
}
protected Plant(IMap map, IGrowable growable, IEatable eatable, DeathEvent deathEvent, IEventRecorder eventRecorder)
: base(map, growable, deathEvent, eventRecorder)
{
Status = Status.Child;
_eatable = eatable;
_eatable.EatableOwner = this;
}
private GameObject GetClosestEnemy()
{
Collider[] enemies = Physics.OverlapSphere(transform.position, stateVariables.eatRadius, LayerMask.GetMask(Strings.Tags.ENEMY));
if (enemies != null)
{
Collider closestEnemy = null;
float closestDistance = Mathf.Infinity;
foreach (Collider enemy in enemies)
{
IEatable eatable = enemy.GetComponent <IEatable>();
if (!eatable.IsNull() && eatable.IsEatable())
{
float distance = Vector3.Distance(enemy.ClosestPoint(transform.position), transform.position);
if (closestDistance > distance)
{
closestDistance = distance;
closestEnemy = enemy;
}
}
}
if (closestEnemy != null)
{
return(closestEnemy.gameObject);
}
}
return(null);
}
private void Start()
{
Eater = GetComponent <IEater>();
Eatable = GetComponent <IEatable>();
Exhaustion = GetComponent <Exhaustion>();
WanderOrigin = new Vector3(0, 0, 1);
aiActive = true;
}
public Fish(IMap map, IGrowable growable, IMovable movable, IEater eater, IEatable eatable, IGender gender,
DeathEvent deathEvent, IEventRecorder eventRecorder)
: base(map, growable, movable, eater, gender, deathEvent, eventRecorder)
{
Hp = 10;
_eatable = eatable;
_eatable.EatableOwner = this;
}
public void Eat(IEatable food)
{
StarvePoint += food.Satiety;
if (StarvePoint > 100f)
{
StarvePoint = 100f;
}
food.Eat();
}
public void EatFood(IEatable food)
{
//SALE EL LOGO DE COMIENDO///
/////////////////////////////
float maxEnergyToGet = genes.genesData.maxEnergy - currentEnergy;
float energyEarned = food.Eat(maxEnergyToGet);
currentEnergy += energyEarned;
}
public bool Eat(IEatable eatable)
{
if (IsInReach(eatable))
{
eatable.Eat().ApplyOn(transform.parent.gameObject);
return(true);
}
return(false);
}
public void Eat(IEatable other)
{
volume += other.volume;
// 如果是AI操控，那吃完球后应该停止继续移动，等待下一次感知
if (controller is AI && other is Ball)
{
StopMoving();
}
}
public bool CanEat(IEatable toEat)
{
if (Mass >= toEat.GetMass() * 1.5f)
{
return true;
}
else
{
return false;
}
}
public void Attack(StateController controller)
{
controller.IsEating = true;
controller.NavMeshAgent.isStopped = true;
IEatable food = controller.ChaseTarget.GetComponent<IEatable>();
Debug.Log($"{controller.gameObject.name} is eating {food}.");
controller.Eater.Eat(food);
controller.ChaseTarget = null;
}
public override void RunMainAction(GAgent gAgent)
{
Debug.Log("Eating.");
var data = new GStateData(gAgent.controller, gAgent.agent, gAgent.target.position, gAgent.anim, "idle", 2f);
gAgent.controller.Activity(data);
IEatable food = gAgent.target.GetComponent <IEatable>();
(gAgent as Herbivore).Eater.Eat(food);
}
public bool TryToEat(IEatable toEat)
{
if (CanEat(toEat) && Vector2.Distance(transform.position, toEat.GetTransform().position) <= ActualDisplayMass * EatRadiusMult)
{
toEat.OnEaten();
Mass += toEat.GetMass();
return true;
}
else
{
return false;
}
}
public override void OnCollisionEnter(Collision c)
{
IEatable eatable = c.collider.GetComponentInParent(typeof(IEatable)) as IEatable;
if (eatable != null)
{
mAnimator.SetTrigger("Bite");
eatable.BeEaten(this);
}
else
{
base.OnCollisionEnter(c);
}
}
private void OnTriggerExit(Collider other)
{
if (other.CompareTag("Hydrator"))
{
drinkRef = null;
}
if (other.CompareTag("Feeder"))
{
foodRef = null;
}
if (other.GetComponents <IInteractable>().Length > 0)
{
InteractionText.gameObject.SetActive(false);
}
}
private bool CheckForEatableEnemy()
{
GameObject potentialEatableEnemy = GetClosestEnemy();
if (potentialEatableEnemy)
{
IEatable skinnable = potentialEatableEnemy.GetComponent <IEatable>();
if (!skinnable.IsNull() && skinnable.IsEatable())
{
stateVariables.eatTargetEnemy = potentialEatableEnemy;
stateVariables.eatTargetEnemy.GetComponent <EnemyBase>().TemporaryTerminalIndestructable();
return(true);
}
}
return(false);
}
public override IEatable GetNearestEatable()
{
IEatable eatable = null;
foreach (var sensedObject in Sensor.SensedObjects)
{
var bunny = sensedObject.GetComponent <Bunny>();
if (bunny != null && bunny.IsEatable)
{
if (eatable == null || MathExtensions.SquareDistanceBetween(Position, bunny.Position) < MathExtensions.SquareDistanceBetween(Position, eatable.Position))
{
eatable = bunny;
}
}
}
return(eatable);
}
public override IEatable GetNearestEatable()
{
IEatable eatable = null;
foreach (var sensedObject in Sensor.SensedObjects)
{
var vegetable = sensedObject.GetComponent <IVegetable>();
if (vegetable != null && vegetable.IsEatable)
{
if (eatable == null || MathExtensions.SquareDistanceBetween(Position, vegetable.Position) < MathExtensions.SquareDistanceBetween(Position, eatable.Position))
{
eatable = vegetable;
}
}
}
return(eatable);
}
private void CaptureEnemy(params object[] parameters)
{
if (stateVariables.eatTargetEnemy.activeSelf)
{
clawTransform = parameters[0] as Transform;
IEatable eatable = stateVariables.eatTargetEnemy.GetComponent <IEatable>();
if (!eatable.IsNull())
{
eatable.ToggleColliders(false);
eatable.EnableRagdoll();
eatable.GrabObject(transform);
stateVariables.eatTargetEnemy.transform.position = clawTransform.position;
grabSpot = clawTransform.position;
}
}
SFXManager.Instance.Play(stateVariables.ArmEnemyCaptureSFX, transform.position);
//clawArmController.StartRetraction(stateVariables.clawRetractionTime);
}
static void Main(string[] args)
{
//delegate has a pointer in the stack
//that refers the value in the heap
delg var2 = () => Console.WriteLine("I am a delegate");
//enum is in the stack
Color var3 = Color.magenta;
//class has a pointer in the stack
//that refers the value in the heap
Pizza var4 = new Pizza {
IsEatable = true, IsVeg = false
};
//struct is in the stack
Salad var5 = new Salad {
IsEatable = true, IsVeg = false
};
//interface can point to the stack or to the heap
IEatable var0 = var4; //interface points to class (heap)
IEatable var1 = var5; //interface points to struct (stack)
Console.WriteLine($"var0.IsEatable {var0.IsEatable} before function");
Console.WriteLine($"var1.IsEatable {var1.IsEatable} before function");
functionChangeIEatable(var0);
functionChangeIEatable(var1);
Console.WriteLine($"var0.IsEatable {var0.IsEatable} after function");
Console.WriteLine($"var1.IsEatable {var1.IsEatable} after function");
Console.WriteLine("-----------------------------");
Console.WriteLine($"functionChangePizza {var4.IsEatable} before function");
functionChangePizza(var4);
Console.WriteLine($"functionChangePizza {var4.IsEatable} after function");
Console.WriteLine("-----------------------------");
Console.WriteLine($"functionChangeSalad {var5.IsEatable} before function");
functionChangeSalad(var5);
Console.WriteLine($"functionChangeSalad {var5.IsEatable} after function");
}
private void SetEnemyCloseToEat(Collider other, bool state)
{
if (other.tag.Equals(Strings.Tags.ENEMY) && !isInDashTutorial && isSpeedUpFinished)
{
IEatable skinnable = other.GetComponent <IEatable>();
if (!skinnable.IsNull() && skinnable.IsEatable())
{
EnemyBase enemyBase = other.GetComponent <EnemyBase>();
if (enemyBase)
{
enemyBase.CloserToEat(state);
if (state)
{
StartEatTutorial();
}
}
}
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
IEatable eatableScript = collision.GetComponent <IEatable>();
if (eatableScript != null)
{
if (CompareSize(collision.transform))
{
eatableScript.Die();
Grow(collision.transform);
if (collision.tag == "Professor")
{
gameManager.Win();
}
}
else if (collision.GetComponent <Entity>().canEat)
{
Die();
}
}
}
public void EatFood()
{
Task task = Task.current;
WaitTaskContext context;
//Get the context, initializing if necessary
if (Task.current.isStarting)
{
context = new WaitTaskContext(perceptor.GetClosestFood(), taskDuration);
communicator.SetSprite(eatFoodSprite);
}
else
{
context = (WaitTaskContext)Task.current.item;
}
//Interrupt if food is no longer available
IEatable food = (IEatable)context.context;
if (!food.IsAvailableToEat)
{
task.Fail();
return;
}
//Advance the wait
context.timeLeft -= Time.deltaTime;
task.item = context;
if (Task.isInspected)
{
task.debugInfo = context.FormattedTimeLeft;
}
//Check for success
if (context.timeLeft <= 0)
{
vitalFunctions.EatFood(food);
Task.current.Succeed();
}
}
private void DoSuck(GameObject obj)
{
ISuckable suckable = obj.GetComponent <ISuckable>();
IEatable eatable = obj.GetComponent <IEatable>();
var tempDistance = Vector3.Distance(transform.position, obj.transform.position);
if (eatable != null)
{
if (tempDistance < eatDistance)
{
GameObject tempObj = eatable.Eat();
if (tempObj != null)
{
_eatenObjects.Add(tempObj);
tempObj.SetActive(false);
_audioComponent?.Play(4); // Play eat sound
eatEvent?.Invoke(); // Invoke eat event
return;
}
}
}
if (suckable != null)
{
if (InRangeCheck(gameObject, obj))
{
var tempSuckForce = vacuumPowerLevel - tempDistance;
if (tempSuckForce < minimumPower)
{
tempSuckForce = minimumPower;
}
suckable.Suck(transform.position, tempSuckForce);
}
}
}
private void OnTriggerStay(Collider other)
{
if (other.CompareTag("Hydrator"))
{
if (drinkRef == null)
{
return;
}
if (Input.GetButton("Interact"))
{
ModifyHydration(drinkRef.Drink());
}
}
if (other.CompareTag("Feeder"))
{
if (foodRef == null)
{
return;
}
if (Input.GetButton("Interact"))
{
ModifyHunger(foodRef.Eat());
foodRef = null;
}
}
var hint = other.GetComponent <IHintable>();
if (Input.GetButton("Interact"))
{
var success = hint?.CollectHint();
if (success != null && (bool)success)
{
InteractionText.gameObject.SetActive(false);
} //Tell the player they messed up?
}
}
