public static Resolver GetResolver()
{
Mock <IDevice> device = new Mock <IDevice>();
Mock <IEngineConfigFile> configFile = new Mock <IEngineConfigFile>();
device.Setup(d => d.ConfigFile).Returns(configFile.Object);
Mock <IBitmapLoader> bitmapLoader = new Mock <IBitmapLoader>();
bitmapLoader.Setup(loader => loader.Load(It.IsAny <int>(), It.IsAny <int>())).Returns(new Mock <IBitmap>().Object);
device.Setup(d => d.BitmapLoader).Returns(bitmapLoader.Object);
Mock <IAssemblies> assemblies = new Mock <IAssemblies>();
device.Setup(d => d.Assemblies).Returns(assemblies.Object);
var mocks = new Mocks();
device.Setup(d => d.FileSystem).Returns(mocks.FileSystem().Object);
Mock <IBrushLoader> brushes = new Mock <IBrushLoader>();
device.Setup(d => d.BrushLoader).Returns(brushes.Object);
Mock <IGraphicsBackend> graphics = new Mock <IGraphicsBackend>();
device.Setup(d => d.GraphicsBackend).Returns(graphics.Object);
Mock <IFontLoader> fonts = new Mock <IFontLoader>();
device.Setup(d => d.FontLoader).Returns(fonts.Object);
Mock <IKeyboardState> keyboard = new Mock <IKeyboardState>();
device.Setup(d => d.KeyboardState).Returns(keyboard.Object);
return(new Resolver(device.Object));
}
public async Task CanOnlyAddOneComponentTest()
{
Resolver resolver = Mocks.GetResolver();
resolver.Builder.RegisterType <OnlyOneComponent>().As <IOnlyOneComponent>();
resolver.Build();
for (int i = 0; i < 100; i++)
{
OnlyOneComponent.LastID = 0;
AGSEmptyEntity entity = new AGSEmptyEntity("Test" + Guid.NewGuid(), resolver);
List <Task> tasks = new List <Task>();
for (int j = 0; j < 10; j++)
{
tasks.Add(Task.Run(() => entity.AddComponent <IOnlyOneComponent>()));
}
await Task.WhenAll(tasks);
var component = entity.AddComponent <IOnlyOneComponent>();
component.AssertOne();
}
}
public void Init()
{
_mocks = Mocks.Init();
}
public static IEnumerable <IObject> GetImplementors(Mocks mocks, Mock <IGameState> stateMock, IGameState state = null)
{
if (state == null && stateMock != null)
{
state = stateMock.Object;
}
mocks.Game().Setup(g => g.State).Returns(state);
stateMock?.Setup(s => s.UI).Returns(new AGSConcurrentHashSet <IObject>());
Mock <IInput> input = new Mock <IInput>();
Resolver resolver = GetResolver();
input.Setup(i => i.KeyUp).Returns(new Mock <IEvent <KeyboardEventArgs> >().Object);
input.Setup(i => i.KeyDown).Returns(new Mock <IEvent <KeyboardEventArgs> >().Object);
if (stateMock != null)
{
stateMock.Setup(s => s.Cutscene).Returns(mocks.Cutscene().Object);
}
Mock <IUIEvents> uiEvents = new Mock <IUIEvents>();
Mock <IEvent <MouseButtonEventArgs> > buttonEvent = new Mock <IEvent <MouseButtonEventArgs> >();
Mock <IEvent <MousePositionEventArgs> > mouseEvent = new Mock <IEvent <MousePositionEventArgs> >();
uiEvents.Setup(u => u.MouseClicked).Returns(buttonEvent.Object);
uiEvents.Setup(u => u.MouseDown).Returns(buttonEvent.Object);
uiEvents.Setup(u => u.MouseUp).Returns(buttonEvent.Object);
uiEvents.Setup(u => u.LostFocus).Returns(buttonEvent.Object);
uiEvents.Setup(u => u.MouseEnter).Returns(mouseEvent.Object);
uiEvents.Setup(u => u.MouseLeave).Returns(mouseEvent.Object);
uiEvents.Setup(u => u.MouseMove).Returns(mouseEvent.Object);
Mock <IGraphicsFactory> graphicsFactory = new Mock <IGraphicsFactory>();
Func <ISprite> getSprite = () => new AGSSprite(resolver, mocks.MaskLoader().Object);
graphicsFactory.Setup(g => g.GetSprite()).Returns(() => getSprite());
AGSAnimationComponent animationComponent = new AGSAnimationComponent();
Mock <IImage> image = new Mock <IImage>();
Mock <IButtonComponent> buttonComponent = new Mock <IButtonComponent>();
buttonComponent.Setup(b => b.HoverAnimation).Returns(new ButtonAnimation(new AGSSingleFrameAnimation(getSprite())));
buttonComponent.Setup(b => b.IdleAnimation).Returns(new ButtonAnimation(new AGSSingleFrameAnimation(getSprite())));
buttonComponent.Setup(b => b.PushedAnimation).Returns(new ButtonAnimation(new AGSSingleFrameAnimation(getSprite())));
Mock <IAudioSystem> audioSystem = new Mock <IAudioSystem>();
Mock <IRuntimeSettings> settings = mocks.Settings();
Mock <IRenderThread> renderThread = new Mock <IRenderThread>();
Mock <IUpdateThread> updateThread = new Mock <IUpdateThread>();
renderThread.Setup(u => u.RunBlocking(It.IsAny <Action>())).Callback <Action>(a => a());
updateThread.Setup(u => u.RunBlocking(It.IsAny <Action>())).Callback <Action>(a => a());
resolver.Builder.RegisterInstance(input.Object);
resolver.Builder.RegisterInstance(state);
resolver.Builder.RegisterInstance(uiEvents.Object);
resolver.Builder.RegisterInstance(animationComponent).As <IAnimationComponent>();
resolver.Builder.RegisterInstance(buttonComponent.Object);
resolver.Builder.RegisterInstance(audioSystem.Object);
resolver.Builder.RegisterInstance(new Mock <IRenderMessagePump>().Object);
resolver.Builder.RegisterInstance(new Mock <IUpdateMessagePump>().Object);
resolver.Builder.RegisterInstance(renderThread.Object);
resolver.Builder.RegisterInstance(updateThread.Object);
resolver.Builder.RegisterInstance(new Mock <ILabelRenderer>().Object);
resolver.Builder.RegisterInstance(new Mock <ITexture>().Object);
resolver.Builder.RegisterInstance(mocks.MaskLoader().Object).As <IMaskLoader>();
resolver.Builder.RegisterInstance(settings.Object).As <IGameSettings>();
resolver.Builder.RegisterInstance(settings.Object).As <IRuntimeSettings>();
resolver.Builder.RegisterInstance(mocks.Game().Object);
resolver.Build();
Func <IObject> baseObj = () => new AGSObject("Test", resolver);
mocks.Game().Setup(g => g.Events).Returns(resolver.Container.Resolve <IGameEvents>());
mocks.Game().Setup(g => g.Factory).Returns(resolver.Container.Resolve <IGameFactory>());
Mock <IOutfit> outfit = new Mock <IOutfit>();
Func <IPanel> basePanel = () => new AGSPanel("Panel", resolver, image.Object);
Func <ILabel> baseLabel = () => new AGSLabel("Label", resolver)
{
LabelRenderSize = new AGS.API.SizeF(100f, 50f)
};
var button = new AGSButton("Button", resolver)
{
LabelRenderSize = new AGS.API.SizeF(100f, 50f)
};
List <IObject> implmentors = new List <IObject>
{
baseObj().Hotspot("Object"),
new AGSCharacter("Character", resolver, outfit.Object).Hotspot("Character"),
basePanel().Hotspot("Panel"),
baseLabel().Hotspot("Label"),
button.Hotspot("Button"),
new AGSInventoryWindow("Inventory", resolver, image.Object).Hotspot("Inventory"),
new AGSSlider("Slider", resolver, image.Object).Hotspot("Slider"),
new AGSCheckBox("Checkbox", resolver),
new AGSTextbox("Textbox", resolver),
new AGSComboBox("Combobox", resolver),
};
return(implmentors);
}
public static Resolver GetResolver()
{
return(Mocks.GetResolver());
}
public void RoomProperlyRendered_Test()
{
int threadID = AGSGame.UIThreadID;
AGSGame.UIThreadID = Environment.CurrentManagedThreadId;
try
{
_mocks.Room().Setup(m => m.ShowPlayer).Returns(false);
AGSViewport viewport = new AGSViewport(new AGSDisplayListSettings(), new AGSCamera(), Mocks.GetResolver());
viewport.RoomProvider = new AGSSingleRoomProvider(_mocks.Room().Object);
_mocks.GameState().Setup(m => m.Viewport).Returns(viewport);
_mocks.GameState().Setup(m => m.GetSortedViewports()).Returns(new List <IViewport> {
_mocks.GameState().Object.Viewport
});
_areas.Clear(); _areas.Add(getArea());
var roomObj = _mocks.Object(true);
var uiObj = _mocks.Object(true);
roomObj.Setup(c => c.ID).Returns("roomObj");
uiObj.Setup(c => c.ID).Returns("uiObj");
_roomObjects.Clear(); _roomObjects.Add(roomObj.Object);
_uiObjects.Clear(); _uiObjects.Add(uiObj.Object);
var displayList = getDisplayList();
var pipeline = getPipeline(displayList);
var roomRenderer = new Mock <IRenderer>();
var uiRenderer = new Mock <IRenderer>();
var roomInsturction = new Mock <IRenderInstruction>();
var uiInstruction = new Mock <IRenderInstruction>();
roomRenderer.Setup(r => r.GetNextInstruction(_mocks.GameState().Object.Viewport)).Returns(roomInsturction.Object);
uiRenderer.Setup(r => r.GetNextInstruction(_mocks.GameState().Object.Viewport)).Returns(uiInstruction.Object);
pipeline.Subscribe("roomObj", roomRenderer.Object);
pipeline.Subscribe("uiObj", uiRenderer.Object);
IRendererLoop loop = getLoop(displayList, pipeline);
Assert.IsTrue(loop.Tick()); //First tick just to tell the display list about our viewport, the second tick will have the objects to render
displayList.GetDisplayList(_mocks.GameState().Object.Viewport);
displayList.Update();
pipeline.Update();
Assert.IsTrue(loop.Tick());
roomInsturction.Verify(r => r.Render(), Times.Once);
uiInstruction.Verify(r => r.Render(), Times.Once);
}
finally
{
AGSGame.UIThreadID = threadID;
}
}
public async Task WalkTest(float fromX, float fromY, bool fromWalkable,
float toX, float toY, bool toWalkable,
float closeToX, float closeToY, bool hasCloseToWalkable)
{
//Setup:
Mock <IEntity> entity = new Mock <IEntity>();
Mock <ITranslateComponent> translate = new Mock <ITranslateComponent>();
Mock <IHasRoomComponent> hasRoom = new Mock <IHasRoomComponent>();
Mock <IOutfitComponent> outfitHolder = new Mock <IOutfitComponent> ();
Mock <IOutfit> outfit = new Mock <IOutfit> ();
Mock <IDrawableInfoComponent> drawable = new Mock <IDrawableInfoComponent>();
Mock <IPathFinder> pathFinder = new Mock <IPathFinder> ();
Mock <IFaceDirectionComponent> faceDirection = new Mock <IFaceDirectionComponent> ();
Mock <IObjectFactory> objFactory = new Mock <IObjectFactory> ();
Mock <IRoom> room = new Mock <IRoom> ();
Mock <IViewport> viewport = new Mock <IViewport>();
Mock <IArea> area = new Mock <IArea> ();
Mock <IWalkableArea> walkableArea = new Mock <IWalkableArea>();
Mock <IMask> mask = new Mock <IMask> ();
Mock <ICutscene> cutscene = new Mock <ICutscene> ();
Mock <IGameState> gameState = new Mock <IGameState> ();
Mock <IGame> game = new Mock <IGame>();
Mock <IGameEvents> gameEvents = new Mock <IGameEvents>();
gameEvents.Setup(g => g.OnRepeatedlyExecute).Returns(_onRepeatedlyExecute);
game.Setup(g => g.State).Returns(gameState.Object);
game.Setup(g => g.Events).Returns(gameEvents.Object);
gameState.Setup(s => s.Cutscene).Returns(cutscene.Object);
gameState.Setup(r => r.Viewport).Returns(viewport.Object);
room.Setup(r => r.Areas).Returns(new AGSBindingList <IArea>(1)
{
area.Object
});
walkableArea.Setup(w => w.IsWalkable).Returns(true);
area.Setup(a => a.Enabled).Returns(true);
// ReSharper disable CompareOfFloatsByEqualityOperator
area.Setup(a => a.IsInArea(It.Is <PointF>(p => p.X == fromX && p.Y == fromY))).Returns(fromWalkable);
area.Setup(a => a.IsInArea(It.Is <PointF>(p => p.X == toX && p.Y == toY))).Returns(toWalkable);
area.Setup(a => a.IsInArea(It.Is <PointF>(p => p.X == toX - 1 && p.Y == toY - 1))).Returns(toWalkable);
area.Setup(a => a.IsInArea(It.Is <PointF>(p => p.X == toX + 1 && p.Y == toY + 1))).Returns(toWalkable);
area.Setup(a => a.IsInArea(It.Is <PointF>(p => p.X == closeToX && p.Y == closeToY))).Returns(hasCloseToWalkable);
area.Setup(a => a.Mask).Returns(mask.Object);
area.Setup(a => a.GetComponent <IWalkableArea>()).Returns(walkableArea.Object);
float distance;
area.Setup(a => a.FindClosestPoint(It.Is <PointF>(p => p.X == toX && p.Y == toY), out distance)).Returns(new PointF(closeToX, closeToY));
// ReSharper restore CompareOfFloatsByEqualityOperator
mask.Setup(m => m.Width).Returns(10);
outfitHolder.Setup(o => o.Outfit).Returns(outfit.Object);
float x = fromX;
float y = fromY;
hasRoom.Setup(o => o.Room).Returns(room.Object);
translate.Setup(o => o.X).Returns(() => x);
translate.Setup(o => o.Y).Returns(() => y);
translate.Setup(o => o.Position).Returns(() => (x, y));
translate.SetupSet(o => o.Position = It.IsAny <Position>()).Callback <Position>(f => (x, y, _) = f);
translate.SetupSet(o => o.X = It.IsAny <float>()).Callback <float>(f => x = f);
translate.SetupSet(o => o.Y = It.IsAny <float>()).Callback <float>(f => y = f);
Mocks.Bind(entity, hasRoom);
Mocks.Bind(entity, translate);
Mocks.Bind(entity, faceDirection);
Mocks.Bind(entity, outfitHolder);
Mocks.Bind(entity, drawable);
Position toLocation = (toX, toY);
Position closeLocation = (closeToX, closeToY);
// ReSharper disable CompareOfFloatsByEqualityOperator
pathFinder.Setup(p => p.GetWalkPoints(It.Is <Position>(l => l.X == fromX && l.Y == fromY),
It.Is <Position>(l => l.X == toX && l.Y == toY))).Returns(toWalkable ? new List <Position> {
toLocation
} : new List <Position>());
pathFinder.Setup(p => p.GetWalkPoints(It.Is <Position>(l => l.X == fromX && l.Y == fromY),
It.Is <Position>(l => l.X == closeToX && l.Y == closeToY))).Returns(hasCloseToWalkable ? new List <Position> {
closeLocation
} : new List <Position>());
// ReSharper restore CompareOfFloatsByEqualityOperator
AGSWalkComponent walk = new AGSWalkComponent(pathFinder.Object, objFactory.Object, game.Object)
{
WalkStep = new PointF(4f, 4f), MovementLinkedToAnimation = false
};
bool walkShouldSucceed = fromWalkable && (toWalkable || hasCloseToWalkable);
walk.Init(entity.Object, typeof(IWalkComponent));
walk.AfterInit();
//Act:
bool walkSucceded = await walk.WalkAsync(toLocation);
//Test:
Assert.AreEqual(walkShouldSucceed, walkSucceded);
if (walkShouldSucceed)
{
Assert.AreEqual(toWalkable ? toX : closeToX, x, 0.1f);
Assert.AreEqual(toWalkable ? toY : closeToY, y, 0.1f);
}
}
public void BindingCalledForExplicitTypeAlreadyAdded()
{
AGSEmptyEntity entity = new AGSEmptyEntity("test" + Guid.NewGuid(), Mocks.GetResolver());
AGSCropSelfComponent crop = new AGSCropSelfComponent();
entity.AddComponent <ICropSelfComponent>(crop);
bool bindingCalled = false;
entity.Bind <ICropSelfComponent>(c =>
{
Assert.AreSame(crop, c);
bindingCalled = true;
}, _ => {});
Assert.IsTrue(bindingCalled);
}
