public void Init()
{
var testBehavior = new TalentsBehavior(null);
var warriorAttribute = new WarriorAttribute();
var rogueAttribute = new RogueAttribute();
var mageAttribute = new MageAttribute();
var damageStat = new DamageStat();
playerThing = new Thing()
{
Name = "PlayerThing", Id = TestThingID.Generate("testthing")
};
playerThing.Behaviors.Add(testBehavior);
warriorAttribute.Parent = playerThing;
playerThing.AddAttribute(warriorAttribute);
mageAttribute.Parent = playerThing;
playerThing.AddAttribute(rogueAttribute);
rogueAttribute.Parent = playerThing;
playerThing.AddAttribute(mageAttribute);
warriorAttribute.SetValue(10, playerThing);
rogueAttribute.SetValue(10, playerThing);
mageAttribute.SetValue(10, playerThing);
playerThing.Stats.Add(damageStat.Name, damageStat);
}
public void Init()
{
this.playerThing = new Thing()
{
Name = "PlayerThing", ID = TestThingID.Generate("testthing")
};
}
public void Init()
{
// Create the basic actor instances and behavior for test.
witnessThing = new Thing()
{
Name = "WitnessThing", Id = TestThingID.Generate("testthing")
};
actingThing = new Thing()
{
Name = "ActingThing", Id = TestThingID.Generate("testthing")
};
openableThing = new Thing()
{
Name = "OpenableThing", Id = TestThingID.Generate("testthing")
};
opensClosesBehavior = new OpensClosesBehavior();
// Set up the actors inside another (which we'll call a "room" although it needn't actually be a room).
room = new Thing()
{
Name = "Room", Id = TestThingID.Generate("room")
};
room.Add(witnessThing);
room.Add(actingThing);
room.Add(openableThing);
// Prepare to verify correct eventing occurs.
witnessThing.Eventing.MiscellaneousRequest += (root, e) => { lastWitnessRequest = e; };
witnessThing.Eventing.MiscellaneousEvent += (root, e) => { lastWitnessEvent = e; };
actingThing.Eventing.MiscellaneousRequest += (root, e) => { lastActorRequest = e; };
actingThing.Eventing.MiscellaneousEvent += (root, e) => { lastActorEvent = e; };
}
public void Init()
{
this.playerThing = new Thing()
{
Name = "PlayerThing", Id = TestThingID.Generate("testthing")
};
var testBehavior = new TalentsBehavior(null);
var warriorAttribute = new WarriorAttribute();
var rogueAttribute = new RogueAttribute();
var mageAttribute = new MageAttribute();
var damageStat = new DamageStat();
var attackStat = new AttackStat();
var initiativeStat = new InitiativeStat();
var awarenessSkill = new SkillAwareness();
warriorAttribute.Parent = this.playerThing;
this.playerThing.AddAttribute(warriorAttribute);
mageAttribute.Parent = this.playerThing;
this.playerThing.AddAttribute(rogueAttribute);
rogueAttribute.Parent = this.playerThing;
this.playerThing.AddAttribute(mageAttribute);
warriorAttribute.SetValue(10, this.playerThing);
rogueAttribute.SetValue(10, this.playerThing);
mageAttribute.SetValue(10, this.playerThing);
this.playerThing.Stats.Add(damageStat.Name, damageStat);
this.playerThing.Stats.Add(attackStat.Name, attackStat);
this.playerThing.Stats.Add(initiativeStat.Name, initiativeStat);
this.playerThing.Skills.Add(awarenessSkill.Name, awarenessSkill);
this.playerThing.Behaviors.Add(testBehavior);
}
public void TestOpeningClosingAndMovementForExits()
{
// Create two one-way exits and two rooms to attach them to.
var openableExitA = new Thing()
{
Name = "OpenableExitA", Id = TestThingID.Generate("testthing")
};
var openableExitB = new Thing()
{
Name = "OpenableExitB", Id = TestThingID.Generate("testthing")
};
var roomA = new Thing(new RoomBehavior())
{
Name = "Room A", Id = TestThingID.Generate("testroom")
};
var roomB = new Thing(new RoomBehavior())
{
Name = "Room B", Id = TestThingID.Generate("testroom")
};
roomA.Add(openableExitA);
roomB.Add(openableExitB);
// Attach ExitBehavior and OpensClosesBehaviors in different orders though, to verify in test that
// eventing and such work correctly regardless of attachment order.
var exitBehaviorA = new ExitBehavior();
var exitBehaviorB = new ExitBehavior();
var opensClosesBehaviorB = new OpensClosesBehavior();
openableExitA.Behaviors.Add(exitBehaviorA);
openableExitA.Behaviors.Add(opensClosesBehavior);
openableExitB.Behaviors.Add(opensClosesBehaviorB);
openableExitB.Behaviors.Add(exitBehaviorB);
// Rig up behaviors so the actor can move, and move from one A to B, and from B to A.
actingThing.Behaviors.Add(new MovableBehavior());
exitBehaviorA.AddDestination("toB", roomB.Id);
exitBehaviorB.AddDestination("toA", roomA.Id);
// Ensure that the actingThing cannot move through either exit while it is in default (closed) state.
roomA.Add(actingThing);
exitBehaviorA.MoveThrough(actingThing);
Assert.AreSame(roomA, actingThing.Parent);
roomB.Add(actingThing);
exitBehaviorB.MoveThrough(actingThing);
Assert.AreSame(roomB, actingThing.Parent);
// Ensure that the actingThing can open and move through each openable exit to get between rooms.
opensClosesBehaviorB.Open(actingThing);
exitBehaviorB.MoveThrough(actingThing);
Assert.AreSame(roomA, actingThing.Parent);
opensClosesBehavior.Open(actingThing);
exitBehaviorA.MoveThrough(actingThing);
Assert.AreSame(roomB, actingThing.Parent);
}
public void Init()
{
// Create 2 rooms and a basic ExitBehavior in prep for testing.
this.roomA = new Thing(new RoomBehavior())
{
Name = "Room A", ID = TestThingID.Generate("testroom")
};
this.roomB = new Thing(new RoomBehavior())
{
Name = "Room B", ID = TestThingID.Generate("testroom")
};
this.exitBehavior = new ExitBehavior();
this.exit = new Thing(this.exitBehavior)
{
Name = "Exit", ID = TestThingID.Generate("testexit")
};
}
public void Init()
{
// Create 2 things and a basic MultipleParentsBehavior for testing.
parent1 = new Thing()
{
Name = "Thing1", Id = TestThingID.Generate("testthing")
};
parent2 = new Thing()
{
Name = "Thing2", Id = TestThingID.Generate("testthing")
};
child = new Thing()
{
Name = "Child1", Id = TestThingID.Generate("testthing")
};
multipleParentsBehavior = new MultipleParentsBehavior();
}
public void TestMultipleParentingBehavior()
{
// Verify we can add and retrieve the MultipleParentsBehavior of a Thing.
child.Behaviors.Add(multipleParentsBehavior);
Assert.IsTrue(child.Behaviors.FindFirst <MultipleParentsBehavior>() == multipleParentsBehavior);
// Verify it can now be a child of multiple parents, and one of those can be found as the primary Parent.
parent1.Add(child);
parent2.Add(child);
Assert.IsTrue(parent1.Children.Contains(child));
Assert.IsTrue(parent2.Children.Contains(child));
Assert.IsTrue(child.Parent == parent1 || child.Parent == parent2);
// Verify we can remove the item from a secondary parent, and still be attached well to the primary.
parent2.Remove(child);
Assert.IsTrue(parent1.Children.Contains(child));
Assert.IsTrue(!parent2.Children.Contains(child));
Assert.IsTrue(child.Parent == parent1);
parent2.Add(child);
// Verify we can remove the item from a primary parent, and a secondary parent becomes the primary.
parent1.Remove(child);
Assert.IsTrue(!parent1.Children.Contains(child));
Assert.IsTrue(parent2.Children.Contains(child));
Assert.IsTrue(child.Parent == parent2);
parent1.Add(child);
// Verify we can be attached to more than 2 parents.
Thing parent3 = new Thing()
{
Name = "Thing3", Id = TestThingID.Generate("testthing")
};
parent3.Add(child);
Assert.IsTrue(parent1.Children.Contains(child));
Assert.IsTrue(parent2.Children.Contains(child));
Assert.IsTrue(parent3.Children.Contains(child));
Assert.IsTrue(child.Parent != null);
}
public void TestTwoWayExitBehavior()
{
// Allow the exit to reside in two places, and place it in both room A and room B.
exit.Behaviors.Add(new MultipleParentsBehavior());
roomA.Add(exit);
roomB.Add(exit);
// Ensure there are no destinations before rigging them up.
Assert.AreSame(exitBehavior.GetDestination(roomA), null);
Assert.AreSame(exitBehavior.GetDestination(roomB), null);
// Rig the exits and ensure both got rigged up to the correct destinations.
exitBehavior.AddDestination("north", roomB.Id);
exitBehavior.AddDestination("south", roomA.Id);
Assert.AreSame(exitBehavior.GetDestination(roomA), roomB);
Assert.AreSame(exitBehavior.GetDestination(roomB), roomA);
// Create an unmovable actor, and ensure that said actor cannot move through.
actor = new Thing()
{
Name = "Actor", Id = TestThingID.Generate("testactor")
};
roomA.Add(actor);
exitBehavior.MoveThrough(actor);
Assert.AreSame(actor.Parent, roomA);
// Make the actoc movable, and ensure they end up in the next room when moving through.
actor.Behaviors.Add(new MovableBehavior());
exitBehavior.MoveThrough(actor);
Assert.AreSame(actor.Parent, roomB);
// Move the actor back through the exit again, and ensure they end up in the starting room.
exitBehavior.MoveThrough(actor);
Assert.AreSame(actor.Parent, roomA);
// TODO: Ensure the actor does not move through when using the wrong context command?
// TODO: Ensure the actor moves through both ways when using correct context commands?
}
public void Init()
{
// Create the basic actor instances and behavior for test.
this.witness = new Thing()
{
Name = "Witness", ID = TestThingID.Generate("testthing")
};
this.stalker1 = new Thing()
{
Name = "Stalker1", ID = TestThingID.Generate("testthing")
};
this.stalker2 = new Thing()
{
Name = "Stalker2", ID = TestThingID.Generate("testthing")
};
this.victim1 = new Thing()
{
Name = "Victim1", ID = TestThingID.Generate("testthing")
};
this.victim2 = new Thing()
{
Name = "Victim2", ID = TestThingID.Generate("testthing")
};
// Set up the rooms.
this.room1 = new Thing()
{
Name = "Room", ID = TestThingID.Generate("room")
};
this.room2 = new Thing()
{
Name = "Room 2", ID = TestThingID.Generate("room")
};
// Set up an exit connecting the two rooms.
this.exit = new Thing()
{
Name = "East Exit", ID = TestThingID.Generate("exit")
};
var exitBehavior = new ExitBehavior();
////exitBehavior.AddDestination("west", room1.ID);
////exitBehavior.AddDestination("east", room1.ID);
////this.exit.BehaviorManager.Add(exitBehavior);
this.room1.Add(this.exit);
this.room2.Add(this.exit);
// Populate the first room.
this.room1.Add(this.witness);
this.room1.Add(this.stalker1);
this.room1.Add(this.stalker2);
this.room1.Add(this.victim1);
this.room1.Add(this.victim2);
// Prepare to verify correct eventing occurs.
this.witness.Eventing.MovementRequest += (root, e) => { this.lastWitnessRequest = e; };
this.witness.Eventing.MovementEvent += (root, e) => { this.lastWitnessEvent = e; };
this.stalker1.Eventing.MovementRequest += (root, e) => { this.lastStalkerRequest = e; };
this.stalker1.Eventing.MovementEvent += (root, e) => { this.lastStalkerEvent = e; };
this.stalker2.Eventing.MovementRequest += (root, e) => { this.lastStalkerRequest = e; };
this.stalker2.Eventing.MovementEvent += (root, e) => { this.lastStalkerEvent = e; };
this.victim1.Eventing.MovementRequest += (root, e) => { this.lastVictimRequest = e; };
this.victim1.Eventing.MovementEvent += (root, e) => { this.lastVictimEvent = e; };
this.victim2.Eventing.MovementRequest += (root, e) => { this.lastVictimRequest = e; };
this.victim2.Eventing.MovementEvent += (root, e) => { this.lastVictimEvent = e; };
}
