private IWarrior GetWarriorAfterCollision(IWarrior warrior, IPiece piece)
{
if (piece is IFruit)
{
warrior.Eat((IFruit)piece);
return(warrior);
}
else if (piece is IWarrior)
{
IWarrior defendingWarrrior = (IWarrior)piece;
this.winner = warrior;
if (warrior.Power > defendingWarrrior.Power)
{
this.winner = warrior;
this.gameIsFinished = true;
}
else if (warrior.Power < defendingWarrrior.Power)
{
this.winner = defendingWarrrior;
this.gameIsFinished = true;
}
else
{
this.gameIsDraw = true;
this.gameIsFinished = true;
}
}
return(this.winner);
}
public static void Main()
{
var ninjaWithSword = new Ninja(new Sword());
Ninja ninjaWithNunjack = new Ninja(new Nunjucks());
Trooper trooper = new Trooper();
IWarrior[] warriors = new IWarrior[] { ninjaWithNunjack, ninjaWithSword, trooper };
foreach (var warrior in warriors)
{
warrior.Move();
warrior.Attack();
if (warrior is IStealth)
{
IStealth stealthWarior = ((IStealth)warrior);
stealthWarior.EnableInvisibility();
}
}
// now I want my ninja to use nunjucks...use the interface IWarrior
//now I want a human...create an IHuman that can move interface
//Now I want to have a collection of all people: ninjas and humans.
Console.ReadLine();
}
public Direction GetNextMove(IWarrior warrior)
{
Console.WriteLine($"Player{warrior.VisualSymbol}, make a move please!");
var direction = new Direction();
ConsoleKeyInfo keyInfo;
while ((keyInfo = Console.ReadKey(true)).Key != ConsoleKey.Escape)
{
switch (keyInfo.Key)
{
case ConsoleKey.UpArrow:
direction = Direction.Up;
return(direction);
case ConsoleKey.RightArrow:
direction = Direction.Right;
return(direction);
case ConsoleKey.DownArrow:
direction = Direction.Down;
return(direction);
case ConsoleKey.LeftArrow:
direction = Direction.Left;
return(direction);
}
}
return(direction);
}
public static XmlWarrior ToXml(this IWarrior warrior)
{
XmlWarrior xmlWarrior = new XmlWarrior()
{
TypeOfWarrior = warrior.TypeName,
Name = warrior.Name
};
xmlWarrior.EquipmentList.AddRange(warrior.Equipment.Select(x => x.Name).ToList());
if (warrior is IHenchMen)
{
IHenchMen henchMan = warrior as IHenchMen;
xmlWarrior.AmountInGroup = henchMan.AmountInGroup;
}
else if (warrior is IHero)
{
IHero hero = warrior as IHero;
xmlWarrior.SkillList.AddRange(hero.Skills.Select(x => x.SkillName).ToList());
}
if (warrior is IWizard)
{
IWizard wizard = warrior as IWizard;
xmlWarrior.SpellList.AddRange(wizard.DrawnSpells.Select(x => x.SpellName).ToList());
}
return(xmlWarrior);
}
private void OnEnable()
{
if (character.GetComponent <IWarrior>() == null)
{
Debug.LogError("character needs to be of: " + typeof(IWarrior));
}
else
{
warrior = character.GetComponent <IWarrior>();
}
if (playerMovement == null)
{
if (GetComponent <Movement>() == null)
{
playerMovement = gameObject.AddComponent <Movement>();
}
else
{
playerMovement = GetComponent <Movement>();
}
}
playerRigidbody.mass = currMass();
playerMovement.MovingObject = playerRigidbody;
spriteRenderer = GetComponent <SpriteRenderer>();
baseMat = spriteRenderer.material;
}
public void FightBetween(IWarrior redFighter, IWarrior blueFighter)
{
this.Log("Fight started");
bool redAttack = this.GetRandomBoolean();
IWarrior attacker;
IWarrior defender;
if (redAttack)
{
attacker = redFighter;
defender = blueFighter;
}
else
{
attacker = blueFighter;
defender = redFighter;
}
attacker.Attacks(defender);
var message = string.Format("{0} kills {1} with {2}", attacker, defender, attacker.Weapon);
this.InvokeFightEvent(message);
this.Log(message);
this.Log("Fight ended");
}
public void BuildRoster(IWarrior warrior)
{
_ExperienceList.Clear();
this.m_StackPanel.Children.Clear();
int numberOFRows = warrior.MaximumExperience / 10;
int overallCounter = 1;
for (int rowCounter = 0; rowCounter < numberOFRows; rowCounter++)
{
StackPanel panel = new StackPanel()
{
Orientation = Orientation.Horizontal
};
for (int i = 0; i < warrior.MaximumExperience; i++)
{
//mmmm TODO logic and knowledge of a domain model
bool hasThickborder = warrior.IsLevelUp(overallCounter);
bool isChecked = overallCounter < warrior.CurrentExperience;
IExperience exp = new Experience(overallCounter, hasThickborder, isChecked);
overallCounter++;
_ExperienceList.Add(exp);
panel.Children.Add(exp as Experience);
}
this.m_StackPanel.Children.Add(panel);
}
}
/// <summary>
/// Maximums the close combat weapons reached.
/// </summary>
/// <param name="list">The list.</param>
/// <returns>true if the Maximum of 2 is reached</returns>
public static bool MaximumCloseCombatWeaponsReached(this IWarrior warrior)
{
if (CountNumberOf <ICloseCombatWeapon>(warrior.Equipment) >= warrior.MaximumCloseCombatWeapons)
{
return(true);
}
List <ICloseCombatWeapon> closeCombatList = new List <ICloseCombatWeapon>();
foreach (var item in warrior.Equipment)
{
if (item is ICloseCombatWeapon)
{
ICloseCombatWeapon closeCombatWeapon = item as ICloseCombatWeapon;
if (closeCombatWeapon.CloseCombatSpecialRules.Any(x => x.Equals(CloseCombatWeaponRules.Pair)))
{
return(true);
}
closeCombatList.Add(item as ICloseCombatWeapon);
}
}
return(false);
}
public void FightBetween(IWarrior redFighter, IWarrior blueFighter)
{
this.Log("Fight started");
bool redAttack = this.GetRandomBoolean();
IWarrior attacker;
IWarrior defender;
if (redAttack)
{
attacker = redFighter;
defender = blueFighter;
}
else
{
attacker = blueFighter;
defender = redFighter;
}
attacker.Attacks(defender);
var message = string.Format("{0} kills {1} with {2}", attacker, defender, attacker.Weapon);
this.InvokeFightEvent(message);
this.Log(message);
this.Log("Fight ended");
}
protected void ValidateNinjaWarriorWithOverides(IWarrior warrior)
{
warrior.ShouldBeInstanceOf<Ninja>();
warrior.Weapon.ShouldBeInstanceOf<Shuriken>();
Ninja ninja = warrior as Ninja;
ninja.SecondaryWeapon.ShouldBeInstanceOf<Sword>();
ninja.VerySecretWeaponAccessor.ShouldBeInstanceOf<Sword>();
}
protected void ValidateNinjaWarriorWithOverides(IWarrior warrior)
{
Assert.IsType<Ninja>(warrior);
Assert.IsType<Shuriken>(warrior.Weapon);
Ninja ninja = warrior as Ninja;
Assert.IsType<Sword>(ninja.SecondaryWeapon);
Assert.IsType<Sword>(ninja.SecretWeaponAccessor);
}
public void Hit(IWarrior target)
{
if (target.Weapon == this)
{
throw new SuicidalException();
}
target.Defend(Damage);
}
public IWarrior GetAnInstance()
{
IWarrior newInstance = GetANewInstance();
WarriorBase warriorBase = newInstance as WarriorBase;
warriorBase.CreationDate = DateTime.Now;
return(newInstance);
}
public WarriorViewModel(IWarrior warrior)
{
if (warrior == null)
{
throw new ArgumentNullException("Warrior is null");
}
Warrior = warrior;
Warrior.PropertiesChanged += Warrior_PropertiesChanged;
ShowWeaponsPickerCommand = new ShowWeaponsPicker(this);
BuyWarriorCommand = new BuyWarrior(this);
RemoveWarriorCommand = new RemoveWarrior(this);
IncreaseWarriorBuyAmountCommand = new IncreaseBuyAmount(this);
DecreaseWarriorBuyAmountCommand = new DecreaseBuyAmount(this);
ShowSkillSelectorCommand = new ShowSkillSelector(this);
foreach (IEquipment item in warrior.Equipment)
{
EquippedWeapons.Add(new EquipmentSummaryViewModel(item));
}
foreach (var item in warrior.AllowedSkills)
{
//if (!warrior.Skills.Contains(item))
//{
AllowedSkills.Add(new SkillViewModel(item));
//}
}
IWizard wizard = warrior as IWizard;
if (wizard != null)
{
foreach (var item in wizard.DrawnSpells)
{
Spells.Add(new SpellViewModel(item));
}
}
IHero hero = warrior as IHero;
if (hero != null)
{
foreach (var item in hero.Injuries)
{
InjuryViewModel injuryModel = new InjuryViewModel(item);
Injuries.Add(injuryModel);
InjuriesSimple.Add(injuryModel);
}
foreach (var item in hero.Skills)
{
Skills.Add(new SkillViewModel(item));
SkillsSimple.Add(new SkillViewModelSimple(item));
}
}
}
public bool IsBetter(IWarrior other)
{
++CompareCount;
if (other == null || !(other is Warrior))
{
return(false);
}
return(m_internal >= (other as Warrior).m_internal);
}
protected void ValidateNinjaWarriorWithOverides(IWarrior warrior)
{
Assert.IsType <Ninja>(warrior);
Assert.IsType <Shuriken>(warrior.Weapon);
Ninja ninja = warrior as Ninja;
Assert.IsType <Sword>(ninja.SecondaryWeapon);
Assert.IsType <Sword>(ninja.SecretWeaponAccessor);
}
/// <summary>
/// ��֤սʿ
/// </summary>
/// <param name="warrior"></param>
protected void ValidateWarrior(IWarrior warrior)
{
//���սʿ������һ������
warrior.Should().BeOfType<FootSoldier>();
//սʿ����������
warrior.Weapon.Should().NotBeNull();
//սʿ�����������Ƿ���
warrior.Weapon.Should().BeOfType<Shuriken>();
}
protected void ValidateNinjaWarriorWithOverides(IWarrior warrior)
{
warrior.Should().BeOfType <Ninja>();
warrior.Weapon.Should().BeOfType <Shuriken>();
Ninja ninja = warrior as Ninja;
ninja.SecondaryWeapon.Should().BeOfType <Sword>();
ninja.VerySecretWeaponAccessor.Should().BeOfType <Sword>();
}
public static void Main(string[] args)
{
IKernel kernel = new StandardKernel(new WarriorModule());
IWarrior samurai = kernel.Get <IWarrior>();
samurai.Attack("bad programmers");
Console.ReadLine();
}
// warriors is IWarrior[5]
public static IWarrior SelectMedian(IWarrior[] warriors)
{
IWarrior a = warriors[0], b = warriors[1], c = warriors[2], d = warriors[3], e = warriors[4];
IWarrior temp;
if (b.IsBetter(a))
{
temp = b;
b = a;
a = temp;
}
if (d.IsBetter(c))
{
temp = d;
d = c;
c = temp;
}
if (c.IsBetter(a))
{
temp = a;
a = c;
c = temp;
temp = b;
b = d;
d = temp;
}
if (e.IsBetter(b))
{
temp = e;
e = b;
b = temp;
}
if (b.IsBetter(c))
{
if (c.IsBetter(e))
{
return(c);
}
else
{
return(e);
}
}
else
{
if (b.IsBetter(d))
{
return(b);
}
else
{
return(d);
}
}
}
public WarriorPlayView(IWarrior warrior) : this()
{
_ViewModel = new WarriorViewModel(warrior);
this.DataContext = _ViewModel;
_StatisticsView.Warrior = _ViewModel.Warrior;
_ExpierenceView.BuildRoster(_ViewModel.Warrior);
_AfflictionsView.ViewModel = new AfflictionsViewModel(_ViewModel.Warrior.Afflictions);
_ViewModel.ExperienceList = _ExpierenceView.ExperienceList;
}
private int NumberOffWarriorsOfThisTypeInRoster(IWarrior warrior)
{
int total = 0;
foreach (var item in Warriors)
{
total += item.AmountOfThisType(warrior);
}
return(total);
}
public void Attack(IWarrior target)
{
Random r = new Random();
List<IArmor> armors = new List<IArmor> { target.MainArmor, target.SideArmor };
var defense = armors
.Where(a => a != null && a.Type == ArmorType.Ranged)
.Sum(a => a.Defense);
var actualDamage = weapon.Damage - defense;
target.HealthPoints -= (int)(actualDamage * (0.5+r.NextDouble()));
}
public static IWarrior[] SortWarrior(IWarrior warrior1, IWarrior warrior2)
{
if (warrior1.IsBetter(warrior2))
{
return(new IWarrior[] { warrior1, warrior2 });
}
else
{
return(new IWarrior[] { warrior2, warrior1 });
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Characteristic"/> class.
/// </summary>
/// <param name="owner">The owner.</param>
/// <param name="characteristicValue">The characteristic value.</param>
/// <param name="baseValue">The base value.</param>
/// <exception cref="ArgumentNullException">IWarrrior is null</exception>
public Characteristic(IWarrior owner, Characteristics characteristicValue, int baseValue)
{
if (owner == null)
{
throw new ArgumentNullException("IWarrrior is null");
}
_Warrior = (WarriorBase)owner;
CharacteristicValue = characteristicValue;
BaseValue = baseValue;
}
/// <summary>
/// ͨ����д�󣬶��ձ�����������֤
/// </summary>
/// <param name="warrior"></param>
protected void ValidateNinjaWarriorWithOverides(IWarrior warrior)
{
//սʿ�����ձ���ʿ
warrior.Should().BeOfType<Ninja>();
//սʿ�����������Ƿ���
warrior.Weapon.Should().BeOfType<Shuriken>();
Ninja ninja = warrior as Ninja;
//�ձ���ʿ�ĸ������������ǵ�
ninja.SecondaryWeapon.Should().BeOfType<Sword>();
//�ձ���ʿ�ĵ���Ӧ���ǵ�
ninja.VerySecretWeaponAccessor.Should().BeOfType<Sword>();
}
public void Attack(IWarrior target)
{
var r = new Random();
List<IArmor> armors = new List<IArmor> { target.MainArmor, target.SideArmor };
var armorType = BattleHelper.GetNeededArmorType(Weapon);
var defense = armors
.Where(a => a != null && a.Type == armorType)
.Sum(a => a.Defense);
var actualDamage = Weapon.Damage - defense;
target.HealthPoints -= (int)(actualDamage * (0.8 + r.NextDouble() * 0.4));
}
public void Initialize()
{
this.warriors = this.input.GetWarriors(2);
this.AddWarriorsToBoard();
this.AddFruitsToBoard();
this.currentWarriorIndex = 0;
this.currentTurnsLeft = 0;
this.gameIsFinished = false;
this.gameIsDraw = false;
this.winner = null;
}
public int AmountOfThisType(IWarrior warrior)
{
if (this.TypeName.Equals(warrior.TypeName))
{
IHenchMen henchMan = this as IHenchMen;
if (henchMan != null)
{
return(henchMan.AmountInGroup);
}
return(1);
}
return(0);
}
public EngineWarrior(IWarrior warrior, EngineCore core, int index)
{
SourceWarrior = warrior;
warriorIndex = index;
if (Pin == PSpace.UNSHARED)
{
PSpaceIndex = PSpace.UNSHARED;
}
else
{
PSpaceIndex = PSpace.PIN_APPEARED;
}
Tasks = new Queue <int>();
this.core = core;
}
/// <summary>
/// Verifies if this and another warrior
/// TODO obsolete, so remove
/// </summary>
/// <param name="warrior">The warrior.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">warrior is null</exception>
public bool AreEqual(IWarrior warrior)
{
if (warrior == null)
{
throw new ArgumentNullException("warrior is null");
}
bool areEqual =
warrior.GetType().Name.Equals(this.GetType().Name) &&
warrior.CurrentExperience == this.CurrentExperience &&
this.CreationDate != null &&
this.GetHashCode() == warrior.GetHashCode();
return(areEqual);
}
protected override void InitializeMatch(IProject aProject)
{
project = aProject;
base.InitializeMatch(project);
if (project.Warriors.Count != rules.WarriorsCount)
{
throw new EngineException("Count of warriors differ from rules");
}
random = project.EngineOptions.Random;
if (random == null)
{
random = new Random();
}
forcedAddresses = project.EngineOptions.ForcedAddresses;
sourceWarriors = project.Warriors;
warriors = new List <EngineWarrior>(rules.WarriorsCount);
runningWarriors = new List <IRunningWarrior>(rules.WarriorsCount);
iWarriors = new List <IWarrior>(rules.WarriorsCount);
for (int w = 0; w < rules.WarriorsCount; w++)
{
IWarrior sourceWarrior = sourceWarriors[w];
if (!sourceWarrior.Rules.Equals(rules))
{
throw new EngineException("Warrior was compiled under different rules");
}
EngineWarrior engineWarrior = new EngineWarrior(sourceWarrior, this, w);
warriors.Add(engineWarrior);
runningWarriors.Add(engineWarrior);
iWarriors.Add(engineWarrior);
}
InitPSpaces();
permutate = project.EngineOptions.Permutate;
if (forcedAddresses != null && forcedAddresses.Count > 0)
{
seed = forcedAddresses[1] - rules.MinDistance;
}
else
{
seed = random.Next();
}
}
protected override IWarrior Parse(string filename)
{
if (cache.ContainsKey(filename))
{
return(cache[filename]);
}
else
{
Project tmpProj = new Project(project.Rules);
tmpProj.ParserOptions = project.ParserOptions;
tmpProj.WarriorFiles.Add(filename);
ParseResult res = parser.Parse(tmpProj, console);
res.Messages.AddRange(res.Messages);
IWarrior warrior = tmpProj.Warriors[0];
cache[filename] = warrior;
return(warrior);
}
}
public Availabilities GetException(IWarrior warrior)
{
if (Exceptions != null)
{
foreach (Type item in Exceptions)
{
if (item.IsInterface && warrior.GetType().GetInterfaces().Any(x => x.Equals(item)))
{
return(ExceptionAvailabilityRoll);
}
else if (item.Name.Equals(warrior.GetType().Name))
{
return(ExceptionAvailabilityRoll);
}
}
}
return(AvailabilityRoll);
}
public IWarrior AddWarrior(IWarrior warrior)
{
IWarrior newWarrior = warrior.GetAnInstance();
Warriors.Add(newWarrior);
newWarrior.PropertiesChanged += NewWarrior_PropertiesChanged;
if (newWarrior is IHenchMen)
{
IHenchMen henchMan = newWarrior as IHenchMen;
henchMan.IncreaseGroupByOne();
}
InvokeEvent(WarBandChanged);
InvokeEvent(WarBandWariorListChanged);
return(newWarrior);
}
private IList <ResultsHelper> PrepareResults(IProject project, bool sort)
{
List <ResultsHelper> res = new List <ResultsHelper>();
for (int w = 0; w < warriorsCount; w++)
{
IWarrior warrior = project.Warriors[w];
ResultsHelper r = new ResultsHelper();
r.originalIndex = w;
r.score = score[w];
r.warrior = warrior;
res.Add(r);
}
if (sort)
{
res.Sort();
}
return(res);
}
/// <summary>
/// Parse warrior files in project parameter considering parser options and rules
/// </summary>
/// <param name="aProject">files, rules, options</param>
/// <param name="aConsole">output console, could be null</param>
/// <returns>list of errors</returns>
public virtual ParseResult Parse(IProject aProject, ISimpleOutput aConsole)
{
project = aProject;
result = new ParseResult();
console = aConsole;
project.Warriors.Clear();
int succ = 0;
foreach (string file in project.WarriorFiles)
{
if (project.ParserOptions.StatusLine && console != null)
{
console.WriteLine("Parsing: " + file);
}
IWarrior warrior = Parse(file);
project.Warriors.Add(warrior);
if (warrior != null)
{
succ++;
if (project.ParserOptions.DumpFiles)
{
StreamWriter sw = new StreamWriter(Path.ChangeExtension(file, project.ParserOptions.DumpExt));
warrior.Dump(new WrappedTextWriter(sw), project.ParserOptions);
sw.Close();
}
else if (console != null)
{
warrior.Dump(console, project.ParserOptions);
}
}
else
{
result.Succesfull = false;
}
}
if (project.ParserOptions.StatusLine && console != null)
{
console.WriteLine("========== Compiled " + project.WarriorFiles.Count + " warriors, " +
(project.WarriorFiles.Count - succ) + " failed ==========");
}
return(result);
}
public static bool Equals(IWarrior a, IWarrior b)
{
if (a.Length != b.Length) return false;
if (a.StartOffset != b.StartOffset) return false;
//if (a.Pin != b.Pin) return false;
//if (a.Name != b.Name) return false;
//if (a.Author != b.Author) return false;
for (int adr = 0; adr < b.Length; adr++)
{
if (!a[adr].Equals(b[adr])) return false;
}
return true;
}
public virtual int Attack(IWarrior warrior)
{
return warrior.SurviveAttackWith(this);
}
public AmphibiousAttack([Swimmer]IWarrior warrior)
{
Warrior = warrior;
}
public AmbiguiousAttack(IWarrior warrior)
{
Warrior = warrior;
}
public int Attack(IWarrior target, IWeapon weapon)
{
return weapon.Attack(target);
}
public void Hit(IWarrior target)
{
target.GetsHit(this);
}
private static void DumpWarrior(IWarrior w, ParserOptions opt)
{
StreamWriter sw = new StreamWriter(w.FileName);
WrappedTextWriter wr=new WrappedTextWriter(sw);
w.Dump(wr, opt);
sw.Close();
}
protected void ValidateWarrior(IWarrior warrior)
{
warrior.ShouldBeInstanceOf<FootSoldier>();
warrior.Weapon.ShouldNotBeNull();
warrior.Weapon.ShouldBeInstanceOf<Shuriken>();
}
public void SetWarrior([Optional] IWarrior warrior)
{
this.Warrior = warrior;
}
public Barrack(IWarrior warrior)
{
this.Warrior = warrior;
}
public ShireArmy([Named("Short")] IWarrior warrior)
{
Warrior = warrior;
}
public NinjaBarracks( IWarrior warrior )
{
Warrior = warrior;
}
public Barracks( IWarrior warrior )
{
Warrior = warrior;
}
private static bool BothSidesHaveFighters(IWarrior redFighter, IWarrior blueFighter)
{
return redFighter != null && blueFighter != null;
}
public Barracks( IWarrior warrior, IWeapon weapon )
{
Warrior = warrior;
Weapon = weapon;
}
protected void ValidateWarrior(IWarrior warrior)
{
Assert.IsType<FootSoldier>(warrior);
Assert.NotNull(warrior.Weapon);
Assert.IsType<Shuriken>(warrior.Weapon);
}
protected void ValidateWarrior(IWarrior warrior)
{
warrior.Should().BeOfType<FootSoldier>();
warrior.Weapon.Should().NotBeNull();
warrior.Weapon.Should().BeOfType<Shuriken>();
}
