/// <summary>
/// Sets the detected body as a target if it is a enemy.
/// Gets called when a body enters the detection area.
/// </summary>
/// <param name="body"></param>
public void OnDetectionAreaEntered(object body)
{
if (body is AbstractEnemy enemy)
{
_target = enemy;
}
}
public void NextTurn()
{
em.TriggerEvent(new EventTurnEnd(tm.GetCurrentCharacter()));
tm.GetCurrentCharacter().EndTurn(); // Run end-of-turn function for current character.
tm.NextCharacter(); // Switch characters.
this.numCardsPlayedThisTurn = 0;
this.cardsPlayedThisTurn.Clear();
tm.GetCurrentCharacter().StartTurn(); // Run start-of-turn function for new character.
em.TriggerEvent(new EventTurnStart(tm.GetCurrentCharacter()));
if (tm.GetCurrentCharacter().FACTION == FactionType.ENEMY) // TODO: AI coding, but for now just call this function over again.
{
foreach (EnemyIntent intent in enemy.intents)
{
intent.Resolve();
}
this.NextTurn();
}
else
{
AbstractEnemy enemy = (AbstractEnemy)tm.GetOtherCharacter(tm.GetCurrentCharacter());
enemy.CalculateIntents();
foreach (EnemyIntent intent in enemy.intents)
{
Debug.Log($"The enemy intends to play {intent.cardToPlay} on {intent.argumentTargeted}");
}
renderer.Redraw();
this.round += 1;
}
}
public void Attack()
{
AbstractEnemy enemy = enemySelected != null ? enemySelected : enemyAggro;
float distance = Vector3.Distance(transform.position, enemy.transform.position);
if (distance <= rangePunch)
{
if (!canPunch)
{
return;
}
cooldownPunch = delayPunch;
enemy.TakeDamage(damagePunch);
Debug.Log("Punch !!!");
}
else if (distance <= rangeShot)
{
if (!canShot)
{
return;
}
cooldownShot = delayShot;
var shot = Instantiate(ammo, transform.position, Quaternion.identity).GetComponent <Shot>();
shot.SetDirection(transform.forward, Shot.Emetteur.player);
Debug.Log("Shot !");
}
}
public override void OnCollision(ICollidable obj, Direction dir, World world)
{
if (obj is Realm.Blocks.Block)
{
switch (dir)
{
case Direction.Down:
Velocity = new Vector2(Velocity.X, Y_VELOCITY);
break;
case Direction.Up:
Velocity = new Vector2(Velocity.X, -Y_VELOCITY);
break;
case Direction.Left:
case Direction.Right: Kill(); break;
}
}
else if (obj is AbstractEnemy && (obj as AbstractEnemy).IsAlive)
{
AbstractEnemy enemy = (AbstractEnemy)obj;
enemy.TakeDamage();
Kill();
world.EarnPoints(100);
}
}
/// <summary>
/// Stops travelling towards its target. Gets called when a body leaves
/// the detection area.
/// </summary>
/// <param name="body">The body that left the detection area.</param>
private void OnDetectionAreaExited(object body)
{
if (body == _target)
{
_target = null;
}
}
void BattleInit(EnemyTeamConfig enemyTeam)
{
Model.Log.Debug("战斗初始化");
Battle battle = Game.Instance.NowBattle;
battle.Deck.Clear();
battle.Hand.Clear();
battle.Cemetery.Clear();
battle.Gap.Clear();
//battle.player = Game.Instance.player;
battle.Enemys.Clear();
for (int i = 0; i < enemyTeam.Team.Length; i++)
{
int Id = enemyTeam.Team[i];
AbstractEnemy e = EnemyFatory.Instance.Get(Id);
e.X = enemyTeam.Pos[i].x;
e.Y = enemyTeam.Pos[i].y;
battle.Enemys.Add(e);
}
battle.Turn = 0;
foreach (AbstractPlayerCard p in battle.player.GetDeck())
{
battle.Deck.Add(p);
}
}
public void Die(AbstractEnemy[] hydrray)
{
Console.WriteLine("I'm gonna die like a little bitch.");
///<summary>
///pass in an array storing all the hydra spawn. Max number for array is 7.
///When this is called, the array is passed in, and as the hydra who called the function dies, it creates 2
///new hydras at a smaller scale with stats divided by 2.
}
private void HandleEnemyDeath(AbstractEnemy enemy)
{
// Update score
IncreaseScore(1);
// Unsubscribe from enemy events
enemy.OnAttack -= new AbstractEnemy.EnemyAttackHandler(HandleEnemyAttack);
enemy.OnDeath -= new AbstractEnemy.EnemyDeathHandler(HandleEnemyDeath);
}
public virtual void Attack(AbstractEnemy target)
{
if (CurrentMovements > 0)
{
target.Hit(30);
CurrentMovements--;
}
}
public void OnEnemyKill(AbstractEnemy enemy)
{
if (enemy == null)
{
throw new ArgumentException("No enemy given");
}
Points += enemy.PointsForKilling;
}
void AttackOfTheClones(AbstractEnemy enemyBase, int ammountOfEnemies)
{
for (int i = 0; i < ammountOfEnemies; i++)
{
AbstractEnemy newEnemy = enemyBase.Clone();
enemies.Add(newEnemy);
newEnemy.Interact();
}
}
private void Start()
{
GameObject enemyObject = gameObject.transform.parent.gameObject;
if (enemyObject)
{
enemyParent = enemyObject.GetComponent <AbstractEnemy>();
}
}
public KoopaDead(AbstractEnemy context) : base(context)
{
Context.IsDead = true;
Context.PointValue = 0;
Context.BoundingBox = null;
Context.Gravity = false;
Context.Sprite = DeadEnemySpriteFactory.Create(EnemyType.GreenKoopa);
Context.Velocity = Vector2.Zero;
}
private void HandleEnemyAttack(AbstractEnemy enemy, System.Type type)
{
// Grant perfect?
if (enemy.EvaluatePerformance())
{
DisplayPerfect();
HSmanager.AddPerfect();
}
}
private IEnumerator GenerateRaven()
{
while (true)
{
AbstractEnemy raven = ObjectPool.Instance.GetRaven();
MyEventManager.Instance.OnEnemyGenerated.Dispatch(raven);
yield return(new WaitForSeconds(WaitTime + UnityEngine.Random.Range(1, 3)));
}
}
public void ResetLevel(ref Level level)
{
level.entities.Clear();
level.enemies.Clear();
ISet <IEntity> all = entities.RetrieveAll();
foreach (IEntity entity in all)
{
if (entity is AbstractEnemy || entity is AbstractItem || entity is BrickBlock || entity is QuestionBlock || entity is ToggleBlock || entity is DisappearingBlock)
{
if (entity is AbstractEnemy abstractEnemy)
{
if (enemies.Contains(abstractEnemy))
{
AbstractEnemy enemy = (AbstractEnemy)entity.Clone();
level.enemies.Add(enemy);
level.entities.Insert(enemy);
}
else
{
level.entities.Insert(entity.Clone());
}
}
else if (entity is IBlock)
{
if (entity is BrickBlock || entity is QuestionBlock)
{
level.entities.Insert(entity.Clone());
}
else if (entity is ToggleBlock)
{
((ToggleBlock)entity).Reset();
level.entities.Insert(entity);
}
else if (entity is DisappearingBlock)
{
((DisappearingBlock)entity).Reset();
level.entities.Insert(entity);
}
}
else
{
level.entities.Insert(entity.Clone());
}
}
else
{
level.entities.Insert(entity);
}
}
level.layers = layers;
level.currentLevelSection = currentLevelSection;
level.marioPositions = marioPositions;
}
private IEnumerator GenerateZombie()
{
yield return(new WaitForSeconds(4f));
while (true)
{
AbstractEnemy zombie = ObjectPool.Instance.GetZombie();
MyEventManager.Instance.OnEnemyGenerated.Dispatch(zombie);
yield return(new WaitForSeconds(WaitTime));
}
}
public GoombaDead(AbstractEnemy context) : base(context)
{
context.IsDead = true;
Context.Sprite = DeadEnemySpriteFactory.Create(EnemyType.Goomba);
Context.PointValue = 0;
Context.Velocity = new Vector2(0, 0);
Context.Gravity = false;
Context.TimeDead = 0;
Context.Position = new Vector2(Context.Position.X + (Context.Sprite.SourceRectangle.Width / 2), Context.Position.Y);
Context.BoundingBox = null;
}
private void CreateEnemyBullet(AbstractEnemy e)
{
double sX = e.X + e.Width / 2;
double sY = e.Y + e.Height / 2;
double eX = Ship.X + Ship.Width / 2;
double eY = Ship.Y + Ship.Height / 2;
double theta = Math.Atan2(eY - sY, eX - sX);
double dx = Math.Cos(theta) * Bullet.Speed;
double dy = Math.Sin(theta) * Bullet.Speed;
Bullet b = new Bullet(sX, sY, dx, dy, true);
AddBullet(b);
}
public KoopaAlive(AbstractEnemy context) : base(context)
{
if (Context.Orientation == Facing.Right)
{
Context.Velocity = new Vector2(1f, Context.Velocity.Y);
}
else if (Context.Orientation == Facing.Left)
{
Context.Velocity = new Vector2(-1f, Context.Velocity.Y);
}
Context.Sprite = MovingEnemySpriteFactory.Create(EnemyType.GreenKoopa);
}
// When an enemy died
public void EnemyDeath(AbstractEnemy enemy)
{
OnEnemyDeath?.Invoke(enemy);
EnemyKillCount++;
LevelsScript.Instance.CurrentQuestion.killedEnemies++;
if (EnemyKillCount >= EnemiesInGame)
{
LevelsScript.Instance.EndQuestion();
//InvokeOnLevelCompleted();
}
Debug.Log($"we killed {enemy.Name}, we have now slain {EnemyKillCount} enemies");
Destroy(enemy.gameObject);
}
public override void OnCollision(ICollidable obj, Direction dir, World world)
{
if (obj is Realm.Blocks.Block)
{
Kill();
}
else if (obj is AbstractEnemy && (obj as AbstractEnemy).IsAlive)
{
AbstractEnemy enemy = (AbstractEnemy)obj;
enemy.TakeDamage();
Kill();
world.EarnPoints(100);
}
}
public static bool WillColliderOrFall(AbstractEnemy enemy)
{
if (enemy.CurrentFaceDirection == Direction.WEST)
{
StaticCollider southWestCollider = enemy.Scene.GridCollisionChecker.GetColliderAt(GridUtil.GetLeftBelowGrid(enemy.Transform.GridCoordinates));
return(enemy.Scene.GridCollisionChecker.HasBlockingColliderAt(enemy.Transform.GridCoordinates, Direction.WEST) || southWestCollider == null || !southWestCollider.BlocksMovementFrom(Direction.SOUTH));
}
else if (enemy.CurrentFaceDirection == Direction.EAST)
{
StaticCollider southEastCollider = enemy.Scene.GridCollisionChecker.GetColliderAt(GridUtil.GetRightBelowGrid(enemy.Transform.GridCoordinates));
return(enemy.Scene.GridCollisionChecker.HasBlockingColliderAt(enemy.Transform.GridCoordinates, Direction.EAST) || southEastCollider == null || !southEastCollider.BlocksMovementFrom(Direction.SOUTH));
}
throw new Exception("Wrong CurrentFaceDirection for enemy!");
}
private void OnGotEnemyParent(AbstractEnemy enemy, Platform platform)
{
if (platform == this)
{
if (enemy.GetEnemyType() == AbstractEnemy.EnemyType.Zombie)
{
GetPointAndActivateZombie((Zombie)enemy);
}
else
{
GetPointAndActivateRaven((Raven)enemy);
}
}
}
private void OnEnemyGenerated(AbstractEnemy enemy)
{
Platform parent;
if (GameData.Instance.direction == Direction.Right)
{
parent = RightPlatform;
}
else
{
parent = LeftPlatform;
}
MyEventManager.Instance.OnGotEnemyParent.Dispatch(enemy, parent);
}
public void Attack(AbstractEnemy target)
{
var coord = target.Coord.WorldCoord;
if (attackEffect != null)
{
GameObjectUtils.InstantiateChildForWorld(attackEffect, coord, gameObject, true);
}
if (attackSound != null)
{
AudioSource.PlayClipAtPoint(attackSound, coord);
}
Unit.Attack(target);
}
static internal Dictionary <int, List <AbstractEnemy> > Read(String content)
{
Dictionary <int, List <AbstractEnemy> > story
= new Dictionary <int, List <AbstractEnemy> >();
var json = (dynamic)JsonConvert.DeserializeObject(content);
foreach (var e in json)
{
long time = e["time"].Value;
long type = e["type"].Value;
long x = e["x"].Value;
long y = e["y"].Value;
long sx = e["sx"]?.Value ?? 0;
long sy = e["sy"]?.Value ?? 0;
AbstractEnemy enemy = null;
switch (type)
{
case 0: enemy = new Enemy0(x, y); break;
case 1: enemy = new Enemy1(x, y); break;
case 2:
double t = sx > 0 ? -1 : +1;
enemy = new Enemy2(x, y, sx, sy, t);
break;
case 3: enemy = new Enemy3(x, y); break;
case 4: enemy = new Enemy4(x, y); break;
}
List <AbstractEnemy> enemies;
if (story.ContainsKey((int)time))
{
enemies = story[(int)time];
}
else
{
enemies = new List <AbstractEnemy>();
story[(int)time] = enemies;
}
enemies.Add(enemy);
}
return(story);
}
public override void OnLeaveTrigger(string triggerTag, IGameObject otherEntity)
{
if (otherEntity is AbstractEnemy)
{
AbstractEnemy enemy = (otherEntity as AbstractEnemy);
if (enemy.Transform.Position.X > Transform.Position.X + (width / 2))
{
enemy.CurrentFaceDirection = Direction.WEST;
}
else
{
enemy.CurrentFaceDirection = Direction.EAST;
}
}
base.OnLeaveTrigger(triggerTag, otherEntity);
}
// Called whenever we load into the Negotiation scene.
void Start()
{
Debug.Log("RenderNegotiation calls NegotiationManager's StartNegotiation()");
nm.StartNegotiation(this, null); // Start negotiation! (This also sets up a whole bunch of gameobjects in nm that we can now use for this method)
mainCamera = Camera.main; // grab main camera
handZone = GameObject.Find("Canvas/HandZone");
argPrefab = Resources.Load("Prefabs/ArgumentDisplay") as GameObject;
cardTemplatePrefab = Resources.Load("Prefabs/CardTemplate") as GameObject;
intentPrefab = Resources.Load("Prefabs/IntentDisplay") as GameObject;
drawCount = GameObject.Find("Canvas/TrackDeck/Count").GetComponent <TextMeshProUGUI>();
discardCount = GameObject.Find("Canvas/TrackDiscard/Count").GetComponent <TextMeshProUGUI>();
scourCount = GameObject.Find("Canvas/TrackScour/Count").GetComponent <TextMeshProUGUI>();
actionCount = GameObject.Find("Canvas/TrackAP/Count").GetComponent <TextMeshProUGUI>();
scourObject = GameObject.Find("Canvas/TrackScour");
scourObject.SetActive(false);
endTurnButton = GameObject.Find("Canvas/EndTurnButton").GetComponent <Button>();
endTurnButton.onClick.AddListener(NegotiationManager.Instance.NextTurn);
roundText = GameObject.Find("Canvas/EndTurnButton/TurnCounter").GetComponent <TextMeshProUGUI>();
player = nm.player;
enemy = nm.enemy;
// Render core arguments
GameObject corePlayer = Instantiate(argPrefab, GameObject.Find("Canvas/PlayerSide/SpawnCoreHere").transform.position, Quaternion.identity);
corePlayer.GetComponent <DisplayArgument>().reference = player.GetCoreArgument();
corePlayer.transform.SetParent(GameObject.Find("Canvas/PlayerSide/SpawnCoreHere").transform);
corePlayer.SetActive(true); // Invoke the core argument's OnEnable() function since the prefab is disabled by default
GameObject coreEnemy = Instantiate(argPrefab, GameObject.Find("Canvas/EnemySide/SpawnCoreHere").transform.position, Quaternion.identity);
coreEnemy.GetComponent <DisplayArgument>().reference = enemy.GetCoreArgument();
coreEnemy.transform.SetParent(GameObject.Find("Canvas/EnemySide/SpawnCoreHere").transform);
coreEnemy.SetActive(true);
// this.RenderHand(); // Render player hand
// this.RenderCounts();
Redraw();
}
private IEnumerator SpawnSingle(AbstractEnemy enemyPrefab)
{
// Create enemy from prefab
AbstractEnemy enemy = Instantiate(enemyPrefab, spawnPoint.position, Quaternion.identity) as AbstractEnemy;
enemy.Player = player;
// Subscribe to events
enemy.OnAttack += new AbstractEnemy.EnemyAttackHandler(HandleEnemyAttack);
enemy.OnDeath += new AbstractEnemy.EnemyDeathHandler(HandleEnemyDeath);
// Special delays
if (enemy.GetType() == System.Type.GetType("WaitEnemy"))
{
yield return(new WaitForSeconds(((WaitEnemy)enemy).WaitTime));
}
else if (enemy.GetType() == System.Type.GetType("HammerEnemy"))
{
yield return(new WaitForSeconds(((HammerEnemy)enemy).WaitTime));
}
}
public static void Patrol(bool checkCollisions, AbstractEnemy enemy, float waitingTime = 0f)
{
if (enemy.Velocity.Y > 0)
{
return;
}
Direction newFaceDirection = enemy.CurrentFaceDirection;
if (checkCollisions && WillColliderOrFall(enemy))
{
if (waitingTime > 0 && !changeDirectionAllowed)
{
Timer.SetTimer("CARROT_WAIT" + enemy.GetID(), waitingTime);
enemy.Velocity = Vector2.Zero;
changeDirectionAllowed = true;
}
if (enemy.CurrentFaceDirection == Direction.WEST)
{
newFaceDirection = Direction.EAST;
}
else if (enemy.CurrentFaceDirection == Direction.EAST)
{
newFaceDirection = Direction.WEST;
}
}
if (newFaceDirection == Direction.WEST)
{
enemy.MoveDirection = -1;
}
else if (newFaceDirection == Direction.EAST)
{
enemy.MoveDirection = 1;
}
if (!Timer.IsSet("CARROT_WAIT" + enemy.GetID()))
{
enemy.CurrentFaceDirection = newFaceDirection;
enemy.VelocityX += enemy.CurrentSpeed * enemy.MoveDirection * Globals.FixedUpdateMultiplier;
changeDirectionAllowed = false;
}
}
private void SpawnAt(Vector2 position, AbstractEnemy enemy)
{
Headcrab crab = (Headcrab)Instantiate(enemy, position, Quaternion.identity);
crab.target = target;
}
