// Use this for initialization
void Start () {
behavior = gameObject.FindBehavior () as CharacterBehavior;
motor = behavior.motor as CharacterMotor;
inventory = behavior.inventory;
// ---
lastAttackTime = Mathf.NegativeInfinity;
action = new AttackAction();
action.actionEnd = DoDamage;
}
public void TestAttackAction()
{
ActionFactory factory = new ActionFactory();
factory.IsDraft = false;
AttackAction action = factory.CreateGameAction("ATTACK 0 1") as AttackAction;
Assert.IsNotNull(action);
Assert.IsInstanceOfType(action, typeof(AttackAction));
}
public void AttackStyle1()
{
AttackAction attackAction = new AttackAction();
attackAction.actor = hero;
attackAction.style = 1;
attackAction.isMoving = false;
attackAction.onHitAction = GetTargetHitDamageAction();
actionManager.RunAction(attackAction);
}
void ApplyCounterAttackDamage(AttackAction action)
{
var attacker = action.target as ICombatant;
var target = action.attacker as IDestructable;
if (attacker != null && target != null)
{
var damageAction = new DamageAction(target, attacker.attack);
container.AddReaction(damageAction);
}
}
public Weakling(string name) : base(name)
{
ActionList.Add("null1", NullAction.GetActionBuilder());
ActionList.Add("null2", NullAction.GetActionBuilder());
ActionList.Add("attack", AttackAction.GetActionBuilder());
ItemBuilderFactory factory = ItemBuilderFactory.GetInstance();
LootTable.Add(new LootTableElement(999, factory.GetBuilder("rusty-spoon")));
LootTable.Add(new LootTableElement(999, factory.GetBuilder("loincloth")));
LootTable.Add(new LootTableElement(100, factory.GetBuilder("healing-potion")));
}
private int CalculateDamage(AttackAction attacker, Entity defender, int damageModifier)
{
int defenderDefense = defender != null ? defender.Defense : 0;
int baseDamage = (attacker.attack - defenderDefense) * damageModifier;
foreach (AttackModifier modifier in modifiers)
{
baseDamage = modifier.CalculateDamageModifier(attackingEntity, defendingEntity, baseDamage);
}
return(baseDamage);
}
private void ApplyStagger(AttackAction attack, UnitBasicProperties attacker)
{
if (attacker.side == UnitSide.Player)
{
attack.StaminaCost += attacker.isStaggered ? 1 : 0;
}
else if (attacker.side == UnitSide.Hollow)
{
attack.FlatModifier = attack.FlatModifier - (attacker.isStaggered ? 1 : 0);
}
}
public SpawnAttackAnimation(int id, int x, int y, int dir, bool auto, AttackAction atk)
{
ID = id;
X = x;
Y = y;
Dir = dir;
CurrentFrame = 0;
NextFrame = 0;
Attack = atk;
}
private void RunInvalidAttackPlayerTest(int sourceId)
{
int target = -1;
AttackAction action = new AttackAction(sourceId, target);
bool result = action.Execute(player1, player2);
Assert.IsTrue(result);
Assert.AreEqual(DEFAULT_MY_HEALTH, player1.Data.Health);
Assert.AreEqual(DEFAULT_OPP_HEALTH, player2.Data.Health);
}
private static AttackAction ParseAttackAction(MapController mapController, Dictionary <string, string> fields)
{
AttackAction attackAction = ParseAction <AttackAction>(mapController, fields);
attackAction.attack = Int32.Parse(fields[nameof(AttackAction) + "." + nameof(AttackAction.attack)]);
attackAction.accuracy = Int32.Parse(fields[nameof(AttackAction) + "." + nameof(AttackAction.accuracy)]);
attackAction.speed = Int32.Parse(fields[nameof(AttackAction) + "." + nameof(AttackAction.speed)]);
attackAction.skill = Int32.Parse(fields[nameof(AttackAction) + "." + nameof(AttackAction.skill)]);
attackAction.range = Int32.Parse(fields[nameof(AttackAction) + "." + nameof(AttackAction.range)]);
return(attackAction);
}
public void GivenOpponentHasStealthMinion_WhenGetAllAttackActionsInvoked_ThenStealthMinionCannotBeAttacked()
{
var aChar = new Minion(1, 1);
var bStealthChar = new Minion(1, 1, Status.Stealth);
var bFace = Face.Empty;
var gameState = new GameState(
PlayerGameState.Empty.With(_player, minions: x => ImmutableList.Create(aChar)),
PlayerGameState.Empty.With(face: x => bFace, minions: x => ImmutableList.Create(bStealthChar)));
var expectedAction = new AttackAction(_player, aChar, bFace);
CollectionAssert.AreEquivalent(expectedAction.Yield(), _testee.GetAllAttackActions(gameState, _player));
}
public void GivenOpponentHasTauntMinion_WhenGetAllAttackActionsInvoked_ThenOnlyTauntMinionCanBeAttacked()
{
var aChar = new Minion(1, 1);
var bChar = new Minion(1, 1);
var bTauntChar = new Minion(1, 1, Status.Taunt);
var gameState = GameState.Empty.With(
PlayerGameState.Empty.With(_player, minions: x => ImmutableList.Create(aChar)),
PlayerGameState.Empty.With(Player.Empty, minions: x => ImmutableList.Create(bTauntChar, bChar)));
var expectedAction = new AttackAction(_player, aChar, bTauntChar);
CollectionAssert.AreEquivalent(expectedAction.Yield(), _testee.GetAllAttackActions(gameState, _player));
}
public void GivenPlayerHasZeroAttackMinion_WhenGetAllAttackActionsInvoked_ThenZeroAttackMinionCannotAttack()
{
var aChar = new Minion(1, 1);
var aZeroAttackChar = new Minion(0, 1);
var bFace = Face.Empty;
var gameState = new GameState(
PlayerGameState.Empty.With(_player, minions: x => ImmutableList.Create(aChar, aZeroAttackChar)),
PlayerGameState.Empty.With(face: x => bFace));
var expectedAction = new AttackAction(_player, aChar, bFace);
CollectionAssert.AreEquivalent(expectedAction.Yield(), _testee.GetAllAttackActions(gameState, _player));
}
public void AttackActionTest()
{
var map = new SmallMap().BuildMap();
var attacker = new CentaurWarrior(Position.ZERO);
var defender = new CerberusWarrior(new Position(1, 1));
AttackAction action = new AttackAction(map, attacker, defender);
Assert.AreEqual(action.Attacker, attacker);
Assert.AreEqual(action.Defender, defender);
Assert.AreEqual(action.InitialAttackerPosition, Position.ZERO);
}
public void AttackStyle0()
{
AttackAction attackAction = new AttackAction();
attackAction.actor = hero;
attackAction.style = 0;
attackAction.isMoving = true;
attackAction.targetPostion = target.transform.position + new Vector3(1, 0, -2);
attackAction.onHitAction = GetTargetHitDamageAction();
actionManager.RunAction(attackAction);
}
public bool ActionTryFireSkill(int skillID)
{
if (skillID == 0)
{ //自动查找技能
if (Owner.ActionControl.IsActionRunning(AttackAction.SGetActionType()))
{ //正在攻击，暂时返回
return(false);
}
}
int skillIDForTarget = 0;
Actor skillTarget = null;
if (!LookupSkill(skillID, out skillIDForTarget, out skillTarget))
{
//Debug.LogWarning("LookupSkill failed! id is " + skillIDForTarget.ToString() + " self id is "+Owner.ID.ToString());
return(false);
}
Actor.ActorSkillInfo info = Owner.SkillBag.Find(item => item.SkillTableInfo.ID == skillIDForTarget);
if (info == null)
{
Debug.LogWarning("skill id is not exist! id is " + skillIDForTarget.ToString() + " self id is " + Owner.ID.ToString());
return(false);
}
if (skillID == 0 && Owner.ActionControl.IsActionRunning(ActorAction.ENType.enAttackAction))
{//攻击中并且不是技能命令， 不释放
return(false);
}
if (skillTarget == null)
{//无目标技能
//释放技能
return(ActionTryAttack(skillIDForTarget, skillTarget));
}
else
{
Vector3 distance = Owner.RealPos - skillTarget.RealPos;
distance.y = 0;
if (distance.magnitude > info.SkillTableInfo.AttackDistance)
{//不在攻击范围内
//向技能目标移动
ActionMoveTo(skillTarget.RealPos);
}
else
{//在攻击范围内
//释放技能
if (ActionTryAttack(skillIDForTarget, skillTarget))
{
m_curTargetID = skillTarget.ID;
return(true);
}
}
}
return(false);
}
public static AttackAction Slash(Actor actor)
{
AttackAction action = new AttackAction(actor);
action.TimeMultiplier = 0.3;
action.AttackSpeed = (int)(actor.Initiative * (action.TimeMultiplier / 2));
action.AttackPattern = AttackPatterns.Horizontal3();
action.Actor = actor;
action.Name = "Slash";
action.Tags.Add(ActionTag.Melee);
action.Damage = actor.Strength * 2;
return(action);
}
private void CommandUnitsTurrets()
{
foreach (var turretUnit in Around.MyUnitsTurrets)
{
var nearestEnemy = Around.GetNearestEntity(turretUnit.Position, PlayerType.Enemy);
var attackAction = new AttackAction(nearestEnemy.Id, null);
var action = new EntityAction(null, null, attackAction, null);
actions.Add(turretUnit.Id, action);
}
}
public void GivenPlayerHasFrozenMinion_WhenGetAllAttackActionsInvoked_ThenFrozenMinionCannotAttack()
{
var player = new Player();
var aChar = new Minion(1, 1);
var aFrozenChar = new Minion(1, 1, Status.Frozen);
var bFace = Face.Empty;
var gameState = GameState.Empty.With(
PlayerGameState.Empty.With(player, minions: x => ImmutableList.Create(aChar, aFrozenChar)),
PlayerGameState.Empty.With(face: x => bFace));
var expectedAction = new AttackAction(player, aChar, bFace);
CollectionAssert.AreEquivalent(expectedAction.Yield(), _testee.GetAllAttackActions(gameState, player));
}
// [Test]
// public void Die()
// {
// Debug.Log("###### TEST 2 ######");
// }
#region Action
public AttackAction CreateAttackAction(BattleModel actor, BattleModel target,
short style, bool isMoving, AnimeAction onHitAction)
{
AttackAction attackAction = new AttackAction();
attackAction.actor = actor;
attackAction.style = style;
attackAction.isMoving = isMoving;
attackAction.targetPostion = target.GetHitPosition() + new Vector3(0, 0, -5);
attackAction.onHitAction = onHitAction;
return(attackAction);
}
public override void Enter()
{
owner.gameStateMachine.ChangeState <PlayerIdleState>();
if (owner.attacker != null && owner.defender != null)
{
var action = new AttackAction(owner.attacker, owner.defender);
owner.gameContainer.Perform(action);
}
owner.attacker = owner.attacker = null;
owner.stateMachine.ChangeState <WaitingForInputState>();
}
public void AttackBtnClick()
{
if (battle_main_.UserList[0].State != BattlerBase.ActionState.Ready)
{
return;
}
AttackAction action = new AttackAction();
action.Entity = battle_main_.UserList[0];
action.Target = battle_main_.EnemyList[0];
battle_main_.AddAction(action);
}
public static BaseAction Bite(Actor actor)
{
AttackAction action = new AttackAction(actor);
action.TimeMultiplier = 0.2;
action.AttackSpeed = (int)(actor.Initiative * (action.TimeMultiplier / 2));
action.AttackPattern = AttackPatterns.Basic();
action.Actor = actor;
action.Name = "Bite";
action.Tags.Add(ActionTag.Melee);
action.Damage = actor.Strength;
return(action);
}
private void CommandUnitsWorkers()
{
foreach (var builderUnit in Around.MyUnitsWorkers) // All goes get spice milange because SPICE MUST FLOW
{
var nearestNotBusySpice = Around.GetNearestNotBusySpice(builderUnit.Position);
var moveAction = new MoveAction(nearestNotBusySpice.Position, true, false);
var attackAction = new AttackAction(nearestNotBusySpice.Id, null);
var action = new EntityAction(moveAction, null, attackAction, null);
actions.Add(builderUnit.Id, action);
}
if (Around.RepairNeeds)
{
foreach (var brokenBuilding in Around.MyBuildingsBroken)
{
var nearestBuilder = Around.GetNearestWorker(brokenBuilding.Position);
actions.Remove(nearestBuilder.Id);
var moveAction = new MoveAction(brokenBuilding.Position, true, false);
var repairAction = new RepairAction(brokenBuilding.Id);
actions.Add(nearestBuilder.Id, new EntityAction(moveAction, null, null, repairAction));
// var hasBigDamage = brokenBuilding.Health <= View.EntityProperties.Single(ep => ep.Key == brokenBuilding.EntityType).Value.MaxHealth / 2;
// if (hasBigDamage)
// {
// var nearestBuilder2 = Around.GetNearestWorker(brokenBuilding.Position);
// actions.Remove(nearestBuilder2.Id);
//
// moveAction = new MoveAction(brokenBuilding.Position, true, false);
// repairAction = new RepairAction(brokenBuilding.Id);
// actions.Add(nearestBuilder2.Id, new EntityAction(moveAction, null, null, repairAction));
// }
}
}
if (Around.NeedBuildBuildingWorkers)
{
SendWorkerToBuild(EntityType.BuilderBase);
}
else if (Around.NeedBuildBuildingRanged)
{
SendWorkerToBuild(EntityType.RangedBase);
}
else if (Around.NeedBuildHouse)
{
SendWorkerToBuild(EntityType.House);
}
}
public void DoTest()
{
var map = new SmallMap().BuildMap();
var attacker = new CerberusWarrior(Position.ZERO);
var defender = new CentaurWarrior(new Position(1, 1));
AttackAction action = new AttackAction(map, attacker, defender);
action.Do();
var movePointsLost = 2;
Assert.AreEqual(action.Loser.HealthPoints, action.Loser.InitialHealthPoints - action.HealthPointsLost);
Assert.AreEqual(action.MovePointsLost, movePointsLost);
Assert.AreEqual(attacker.MovePoints, Unit.MAX_MOVE_POINTS - movePointsLost);
}
public void Range2()
{
// Projectile Action
SequenceAction sequence = new SequenceAction();
AnimeAction projectileAction = CreateProjectileAction(hero.GetLaunchPosition(), target.transform.position);
sequence.AddAction(projectileAction);
sequence.AddAction(CreateTargetHitDamageAction());
//
AttackAction attackAction = CreateActorAttackAction(1, false, sequence);
actionManager.RunAction(attackAction);
}
public static Entity ParseEntity(Dictionary <string, string> fields)
{
EntityParser entity = ScriptableObject.CreateInstance <EntityParser>();
entity.name = fields[nameof(name)];
entity.m_Type = GetOrCreateEntityType(fields[nameof(name)], fields[nameof(entity.Type.EntityClass)]);
entity.m_MaxActionPoints = Int32.Parse(fields[nameof(ActionPoints)]);
entity.m_MaxHp = Int32.Parse(fields[nameof(Hp)]);
entity.m_Hp = entity.m_MaxHp;
entity.m_Defense = Int32.Parse(fields[nameof(Defense)]);
entity.m_Cost = ParseCost(fields);
AssetDatabase.CreateAsset(entity.Cost, "Assets/ScriptableObjects/Costs/Entities/" + entity.name + "Cost.asset");
MapController mapController = AssetDatabase.LoadAssetAtPath <MapController>("Assets/ScriptableObjects/MapController.asset");
if (fields.Keys.Any(field => field.Contains(nameof(MoveAction))))
{
MoveAction moveAction = ParseMoveAction(mapController, fields);
AssetDatabase.CreateAsset(moveAction, "Assets/ScriptableObjects/Actions/MoveActions/" + entity.name + "MoveAction.asset");
entity.AddAction(moveAction);
}
if (fields.Keys.Any(field => field.Contains(nameof(AttackAction))))
{
AttackAction attackAction = ParseAttackAction(mapController, fields);
AssetDatabase.CreateAsset(attackAction, "Assets/ScriptableObjects/Actions/AttackActions/" + entity.name + "AttackAction.asset");
entity.AddAction(attackAction);
}
if (fields.Keys.Any(field => field.Contains(nameof(BuildAction))))
{
BuildAction buildAction = ParseBuildAction(mapController, fields);
AssetDatabase.CreateAsset(buildAction, "Assets/ScriptableObjects/Actions/BuildActions/" + entity.name + "BuildAction.asset");
entity.AddAction(buildAction);
}
if (fields.Keys.Any(field => field.Contains(nameof(HarvestAction))))
{
HarvestAction harvestAction = ParseHarvestAction(entity, mapController, fields);
AssetDatabase.CreateAsset(harvestAction, "Assets/ScriptableObjects/Actions/HarvestActions/" + entity.name + "HarvestAction.asset");
entity.AddAction(harvestAction);
}
if (fields.Keys.Any(field => field.Contains(nameof(HealAction))))
{
HealAction healAction = ParseHealAction(mapController, fields);
AssetDatabase.CreateAsset(healAction, "Assets/ScriptableObjects/Actions/HealActions/" + entity.name + "HealAction.asset");
entity.AddAction(healAction);
}
return((Entity)entity);
}
private void OnReachPoint(Direction direction)
{
AttackAction action = direction == Direction.Left ? leftAttack : rightAttack;
if (action == AttackAction.None)
{
Turn(-facing);
}
else
{
turnAfterAttack = true;
Attack((Direction)action);
}
}
public void PopulateContent(PlayerCoordinator coordinator, AttackAction attack, int index)
{
m_Attack = attack;
var button = GetComponent <Button>();
var text = GetComponentInChildren <Text>();
button.onClick.AddListener(() =>
{
coordinator.SetCurrentAttackAction(index);
});
text.text = attack.AttackName;
}
public void AttackAction()
{
AttackAction action = new AttackAction();
action.actor = hero;
action.targetPostion = target.transform.position;
actionManager.RunAction(action);
// action. = animeClip;
// action.spawnPosition = new Vector3(0, 0, zOrderVfx);
// action.repeat = 3;
// action.destroySelf = false;
// actionManager.RunAction(action);
}
private static Random random = new Random(); // Random number generator to make the dice appear more random
public CombatTurnBased(LunchHourGames lhg, CombatSystem combatSystem)
{
this.lhg = lhg;
this.combatSystem = combatSystem;
this.chooseAction = new ChooseAction(lhg, combatSystem, this);
this.moveAction = new MoveAction(lhg, combatSystem, this);
this.attackAction = new AttackAction(lhg, combatSystem, this);
this.useAction = new UseAction(lhg, combatSystem, this);
this.defendAction = new DefendAction(lhg, combatSystem, this);
this.endTurnAction = new EndTurnAction(lhg, combatSystem, this);
currentAction = null;
nextAction = null;
}
bool Attack()
{
var system = container.GetAspect <AttackSystem> ();
if (system.validAttackers.Count == 0 || system.validTargets.Count == 0)
{
return(false);
}
var attacker = system.validAttackers.Random();
var target = system.validTargets.Random();
var action = new AttackAction(attacker, target);
container.Perform(action);
return(true);
}
public static void HandleDirection(Direction dir)
{
var ob = GameData.Data.FocusedObject;
var target = ob.Environment.GetContents(ob.Location + dir).OfType<LivingObject>().FirstOrDefault();
GameAction action;
if (target == null)
{
dir = ob.Environment.AdjustMoveDir(ob.Location, dir);
if (dir == Direction.None)
return;
action = new MoveAction(dir);
}
else
action = new AttackAction(target);
action.GUID = new ActionGUID(ob.World.PlayerID, 0);
ob.RequestAction(action);
}
public void OnEnter(params object[] optional)
{
mBattleStates.Change(States.Tick);
//
// Get a decision action for every entity in the action queue
// The sort it so the quickest actions are the top
//
/*List<Entity> entities=null, */
// FIGURE OUT A WAY TO GET THE BADDIES IN HERE!!!!
//if (optional.
//if (entities.Count > 0)
//mEntities.AddRange(entities);
//mEntities = params.entities;
mEntities.Add(new GoatEntity());
foreach(Entity e in mEntities)
{
if(e.IsPlayerControlled)
{
var action = new AttackAction();
// TODO PlayerDecide action = new PlayerDecide(e, e.Speed());
//mActions.Push(action);
mActions.Add(action);
}
else
{
var action = new BaaAction();
//TODO AIDecide action = new AIDecide(e, e.Speed());
//mActions.Push(action);
mActions.Add(action);
}
}
mActions = mActions.OrderBy(t => t.TimeRemaining).ToList();
//Sort(mActions, BattleState.SortByTime);
// public static bool SortByTime(Action a, Action b) { return a.TimeRemaining > b.TimeRemaining; }
}
protected override GameAction PrepareNextActionOverride(out JobStatus progress)
{
if (m_target.IsDestructed)
{
progress = JobStatus.Done;
return null;
}
if (this.Worker.Location.IsAdjacentTo(m_target.Location, DirectionSet.Planar))
{
var action = new AttackAction(m_target);
progress = JobStatus.Ok;
return action;
}
else
{
if (m_pathDirs == null || m_supposedLocation != this.Worker.Location || m_dest != m_target.Location)
{
var res = PreparePath(this.Worker);
if (res != JobStatus.Ok)
{
Debug.Assert(res != JobStatus.Done);
progress = res;
return null;
}
}
Direction dir = m_pathDirs.Dequeue();
if (m_pathDirs.Count == 0)
m_pathDirs = null;
m_supposedLocation += dir;
var action = new MoveAction(dir);
progress = JobStatus.Ok;
return action;
}
}
ActionState ProcessAction(AttackAction action)
{
if (this.ActionTicksUsed == 1)
this.ActionTotalTicks = 1;
if (this.ActionTicksUsed < this.ActionTotalTicks)
return ActionState.Ok;
var attacker = this;
var target = this.World.FindObject<LivingObject>(action.Target);
if (target == null)
{
SendFailReport(new AttackActionReport(this, null), "target doesn't exist");
return ActionState.Fail;
}
if (!attacker.Location.IsAdjacentTo(target.Location, DirectionSet.Planar))
{
SendFailReport(new AttackActionReport(this, target), "target isn't near");
return ActionState.Fail;
}
var roll = this.World.Random.Next(20) + 1;
bool hit;
var str = attacker.Strength;
str = (int)((20.0 / 100) * str);
var strBonus = (str / 2) - 5;
if (strBonus < 0)
strBonus = 0;
if (roll == 1)
{
hit = false;
}
else if (roll == 20)
{
hit = true;
}
else
{
var dex = target.Dexterity;
dex = (int)((20.0 / 100) * dex);
var dexBonus = (dex / 2) - 5;
if (dexBonus < 0)
dexBonus = 0;
var ac = 10 + target.ArmorClass + dexBonus;
hit = roll + strBonus >= ac;
Trace.TraceInformation("{0} attacks {1}: {2} + {3} >= 10 + {4} + {5} == {6} >= {7}",
attacker, target,
roll, strBonus,
target.ArmorClass, dexBonus,
roll + strBonus, ac);
}
int damage;
DamageCategory damageCategory;
if (hit)
{
var weapon = attacker.Weapon;
int dieSides;
if (weapon == null)
dieSides = 3;
else
dieSides = weapon.WeaponInfo.WC;
damage = this.World.Random.Next(dieSides) + 1 + strBonus;
damageCategory = DamageCategory.Melee;
Trace.TraceInformation("{0} hits {1}, {2} damage", attacker, target, damage);
}
else
{
damage = 0;
damageCategory = DamageCategory.None;
Trace.TraceInformation("{0} misses {1}", attacker, target);
}
SendReport(new AttackActionReport(this, target) { IsHit = hit, Damage = damage, DamageCategory = damageCategory });
if (hit)
target.ReceiveDamage(attacker, damageCategory, damage);
return ActionState.Done;
}
internal void AttackOtherPlayers(GameState gameState, AttackAction action)
{
Card currentAttackCard = gameState.cardContextStack.CurrentCard;
foreach (PlayerState otherPlayer in gameState.players.OtherPlayers)
{
gameState.cardContextStack.PushCardContext(otherPlayer, currentAttackCard, CardContextReason.CardAttacking);
if (otherPlayer.IsAffectedByAttacks(gameState))
{
action(gameState.players.CurrentPlayer, otherPlayer, gameState);
}
gameState.cardContextStack.Pop();
}
}
/// <summary>
/// Начинает бой между Unit'ами
/// </summary>
/// <param name="enemy">Юнит, с которым будет начато сражение</param>
public void Attack(Unit enemy)
{
var attack_action = new AttackAction(commandUnit, enemy);
if (enemy.CurrentAction != null) enemy.CurrentAction = null;
GameEngine.Game.SendOrder(commandUnit, attack_action);
}
internal void AttackOtherPlayers(GameState gameState, AttackAction action)
{
foreach (PlayerState otherPlayer in gameState.players.OtherPlayers)
{
if (otherPlayer.IsAffectedByAttacks(gameState))
{
action(gameState.players.CurrentPlayer, otherPlayer, gameState);
}
}
}
bool HandleKeyDownLiving(KeyEventArgs e)
{
var ob = App.MainWindow.FocusedObject;
if (ob == null)
return false;
var dir = KeyToDir(e.Key);
if (dir != Direction.None)
{
var target = ob.Environment.GetContents(ob.Location + dir).OfType<LivingObject>().FirstOrDefault();
if (target == null)
{
var action = new MoveAction(dir);
action.MagicNumber = 1;
ob.RequestAction(action);
}
else
{
var action = new AttackAction(target);
action.MagicNumber = 1;
ob.RequestAction(action);
}
return true;
}
switch (e.Key)
{
case Key.OemPeriod:
if (GameData.Data.User != null)
GameData.Data.User.SendProceedTurn();
return true;
case Key.Add:
m_mapControl.ZoomIn();
return true;
case Key.Subtract:
m_mapControl.ZoomOut();
return true;
case Key.PageDown:
m_mapControl.Z--;
return true;
case Key.PageUp:
m_mapControl.Z++;
return true;
default:
return false;
}
}
void Randomiser()
{
// List of functions
var attacks = new AttackAction[] {
Krucifix, Krucifix, Krucifix, Nuns, Nuns, LaunchFire, LaunchFire, LaunchFire
};
// Take random function from the array
int index = Random.Range(0, attacks.Length);
var attack = attacks[index];
// Call it
attack();
}
void SetWeapon(AbstractWeapon weap)
{
//maybe cache these? idk. doesn't seem like too much overhead at the moment.
this.action = new AttackAction(weap);
}
