public void Init(Base parent, Inventory inventory)
{
this.inventory = inventory;
Item_Text = new Gwen.ControlInternal.Text (parent);
Item_Text.Font = new Gwen.Font (application.RendererContext.GwenRenderer);
Item_Text.Y = 5;
Item_Text.Font.Size = 15;
spaces = new InventorySpace[inventory.Size.X, inventory.Size.Y];
barItems = new List<InventoryBarButton>();
canvasFrame = new InventoryBackground(parent, inventory, this);
canvasFrame.Width = parent.Width;
canvasFrame.Height = parent.Height;
window = new WindowControl (canvasFrame, Localizer.Instance.GetValueForName("inventory"));
window.DisableResizing ();
window.IsMoveable = false;
window.OnClose += (sender, arguments) => application.Window.CaptureMouse ();
itemGridFrame = new Base (window);
itemGridFrame.SetSize ((BoxSize + 1) * inventory.Size.X, (BoxSize + 1) * inventory.Size.Y);
bla_unfug_crosshair = new ImagePanel (canvasFrame);
bla_unfug_crosshair.SetSize (16, 16);
bla_unfug_crosshair.ImageName = "Content/crosshair.png";
bla_unfug_crosshair.SetPosition ((canvasFrame.Width / 2.0f) - (bla_unfug_crosshair.Width / 2.0f),
(canvasFrame.Height / 2.0f) - (bla_unfug_crosshair.Width / 2.0f));
bla_unfug_crosshair.BringToFront ();
itemInfoFrame = new Base (window);
itemInfoFrame.SetSize (infoFrameSize, itemGridFrame.Height);
itemGridFrame.X += itemInfoFrame.Width + 4;
toolbarFrame = new Base(window);
toolbarFrame.Width = itemGridFrame.Width + itemInfoFrame.Width;
toolbarFrame.Height = toolbarFrameSize;
toolbarFrame.Y = itemGridFrame.Height - 4;
dropBtn = new Button(toolbarFrame);
dropBtn.AutoSizeToContents = true;
dropBtn.Padding = btnPadding;
dropBtn.Text = Localizer.Instance.GetValueForName("drop");
dropBtn.X = toolbarFrame.Width - dropBtn.Width;
dropBtn.Y = (toolbarFrameSize - dropBtn.Height) / 2;
dropBtn.IsDisabled = true;
dropBtn.Clicked += (sender, arguments) => {
if (dropBtn.IsDisabled)
return;
if (toggledBtn != null)
{
dropItem(toggledBtn, toggledBtn.Item, inventory);
}
};
useBtn = new Button(toolbarFrame);
useBtn.AutoSizeToContents = true;
useBtn.Padding = btnPadding;
useBtn.Text = Localizer.Instance.GetValueForName("use");
useBtn.X = dropBtn.X - useBtn.Width - 8;
useBtn.Y = (toolbarFrameSize - useBtn.Height) / 2;
useBtn.IsDisabled = true;
useBtn.Clicked += (sender, arguments) => {
if (useBtn.IsDisabled)
return;
if (toggledBtn != null)
{
if (MessageCreated != null)
MessageCreated(new ItemUseMessage(player, GameState.Scene, toggledBtn.Item, ItemUsage.Eatable));
}
};
rotateBtn = new Button(toolbarFrame);
rotateBtn.AutoSizeToContents = true;
rotateBtn.Padding = btnPadding;
rotateBtn.Text = Localizer.Instance.GetValueForName("rotate");
rotateBtn.X = useBtn.X - rotateBtn.Width - 8;
rotateBtn.Y = (toolbarFrameSize - rotateBtn.Height) / 2;
rotateBtn.IsDisabled = true;
rotateBtn.Clicked += (sender, argument) => {
if (rotateBtn.IsDisabled)
return;
var pos = inventory.GetPositionOfItem(toggledBtn.Item);
var item = inventory.TakeOut(pos);
var prev_orientation = item.Orientation;
item.Orientation =
item.Orientation == Orientation.Horizontal ? Orientation.Vertical : Orientation.Horizontal;
if (!inventory.Insert(item, pos))
{
item.Orientation = prev_orientation;
if (!inventory.Insert(item, pos))
{
Logger.Log.AddLogEntry(LogLevel.Error, "InventoryGUI",
"Lost an inventory item while rotating!");
toggledBtn.DelayedDelete();
toggledBtn = null;
return;
}
}
toggledBtn.UpdateSize();
};
inventoryBar = new TextBox(canvasFrame);
inventoryBar.Disable();
inventoryBar.KeyboardInputEnabled = false;
inventoryBar.Height = barBoxSize + 2;
inventoryBar.Width = barBoxSize * inventory.InventoryBar.Length + 1;
inventoryBar.Y = canvasFrame.Height - inventoryBar.Height;
inventoryBar.X = (canvasFrame.Width - inventoryBar.Width) / 2;
barSpaces = new InventoryBarSpace[inventory.InventoryBar.Length];
for (int i = 0; i < inventory.InventoryBar.Length; i++)
{
barSpaces[i] = new InventoryBarSpace(inventoryBar, MessageProvider, inventory, this, barItems, barBoxSize);
barSpaces[i].X = i * barBoxSize;
barSpaces[i].Y = 1;
barSpaces[i].Width = barBoxSize + 1;
barSpaces[i].Height = barBoxSize + 1;
barSpaces[i].DrawDebugOutlines = false;
if (i == inventory.ActiveBarPosition)
{
barSpaces[i].DrawDebugOutlines = true;
barSpaces[i].Children.ForEach(c => c.DrawDebugOutlines = false);
}
}
window.SetSize (itemGridFrame.Width + itemInfoFrame.Width + 16,
itemGridFrame.Height + toolbarFrameSize + 28);
window.SetPosition ((canvasFrame.Width - window.Width) / 2,
(canvasFrame.Height - window.Height - inventoryBar.Height) / 2);
window.Hide();
int w = 0, h = 0;
for (int y = 0; y < inventory.Size.Y; y++)
{
for (int x = 0; x < inventory.Size.X; x++)
{
spaces [x, y] = new InventorySpace (itemGridFrame, BoxSize, inventory);
spaces [x, y].X = w;
spaces [x, y].Y = h;
spaces [x, y].Width = BoxSize + 1;
spaces [x, y].Height = BoxSize + 1;
w += BoxSize;
}
h += BoxSize;
w = 0;
}
imagePanel = new ImagePanel(itemInfoFrame);
imagePanel.Width = infoFrameSize;
imagePanelHeight = itemGridFrame.Height / 3;
imagePanel.Hide();
items = new List<InventoryButton>();
inventory.Items.ForEach((item, position) => {
AddItem(item, position);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="FreezingArcher.Game.MazeTest"/> class.
/// </summary>
/// <param name="messageProvider">The message provider for this instance.</param>
/// <param name="objmnr">The object manager for this instance.</param>
/// <param name="rendererContext">The renderer context for the maze scenes.</param>
/// <param name="game">The game the maze should be generated in.</param>
public MazeTest (MessageProvider messageProvider, ObjectManager objmnr, RendererContext rendererContext,
Content.Game game, Application app, CompositorNodeScene sceneNode,
CompositorImageOverlayNode healthOverlayNode, CompositorColorCorrectionNode colorCorrectionNode,
CompositorNodeOutput outputNode, CompositorWarpingNode warpingNode)
{
ValidMessages = new[] {
(int) MessageId.Input,
(int) MessageId.Update,
(int) MessageId.HealthChanged,
(int) MessageId.CollisionDetected,
(int) MessageId.StaminaChanged,
(int) MessageId.ItemUse,
(int) MessageId.FlashlightToggled
};
messageProvider += this;
mazeGenerator = new MazeGenerator (objmnr);
MazeSceneNode = sceneNode;
HealthOverlayNode = healthOverlayNode;
ColorCorrectionNode = colorCorrectionNode;
OutputNode = outputNode;
WarpingNode = warpingNode;
this.game = game;
application = app;
FPS_Text = new Gwen.ControlInternal.Text (app.RendererContext.Canvas);
FPS_Text.String = "0 FPS";
FPS_Text.Font = new Gwen.Font (app.RendererContext.GwenRenderer);
FPS_Text.SetPosition (5, 5);
FPS_Text.Font.Size = 15;
FPS_Text.Hide ();
HealthOverlayNode.OverlayTexture = rendererContext.CreateTexture2D ("bloodsplatter", true, "Content/bloodsplatter.png");
HealthOverlayNode.Factor = 0;
HealthOverlayNode.Blending = OverlayBlendMode.Multiply;
warpingNode.WarpTexture = rendererContext.CreateTexture2D ("warp", true, "Content/warp.jpg");
game.SceneNode = MazeSceneNode;
game.AddGameState ("maze_overworld", Content.Environment.Default, null);
var state = game.GetGameState ("maze_overworld");
state.Scene = new CoreScene (rendererContext, messageProvider);
state.Scene.SceneName = "MazeOverworld";
state.Scene.Active = false;
state.Scene.BackgroundColor = Color4.Fuchsia;
state.Scene.DistanceFogIntensity = 0.07f;
state.Scene.AmbientColor = Color4.White;
state.Scene.AmbientIntensity = 0.3f;
state.Scene.MaxRenderingDistance = 1000.0f;
state.AudioContext = new AudioContext (state.MessageProxy);
state.MessageProxy.StartProcessing ();
loadingScreen = new LoadingScreen (application, messageProvider, "Content/loading.png",
"MazeLoadingScreen",
new[] { new Tuple<string, GameStateTransition> ("main_menu", GameStateTransition.DefaultTransition) },
new[] { new Tuple<string, GameStateTransition> (state.Name, new GameStateTransition (0)) });
endScreen = new EndScreen (application, rendererContext, new Tuple<string, GameStateTransition>[] {
new Tuple<string, GameStateTransition> ("maze_overworld", GameStateTransition.DefaultTransition),
new Tuple<string, GameStateTransition> ("maze_underworld", GameStateTransition.DefaultTransition)
});
game.SwitchToGameState ("MazeLoadingScreen");
Player = EntityFactory.Instance.CreateWith ("player", state.MessageProxy, new[] {
typeof(HealthComponent),
typeof(StaminaComponent)
}, new[] {
typeof(MovementSystem),
typeof(KeyboardControllerSystem),
typeof(MouseControllerSystem),
typeof(SkyboxSystem),
typeof(PhysicsSystem)
});
inventoryGui = new InventoryGUI (app, state, Player, messageProvider, warpingNode);
var inventory = new Inventory (messageProvider, state, Player, new Vector2i (5, 7), 9);
inventoryGui.Init (rendererContext.Canvas, inventory);
PauseMenu = new PauseMenu (application, ColorCorrectionNode, rendererContext.Canvas,
() => maze [currentMaze].AIManager.StartThinking (), () => maze [currentMaze].AIManager.StopThinking ());
AddAudio (state);
// embed new maze into game state logic and create a MoveEntityToScene
SkyboxSystem.CreateSkybox (state.Scene, Player);
Player.GetComponent<TransformComponent> ().Position = new Vector3 (0, 1.85f, 0);
var maze_cam_entity = EntityFactory.Instance.CreateWith ("maze_cam_transform", state.MessageProxy, new[] { typeof(TransformComponent) });
var maze_cam_transform = maze_cam_entity.GetComponent<TransformComponent> ();
var maze_cam = new BaseCamera (maze_cam_entity, state.MessageProxy, orthographic: true);
state.Scene.CameraManager.AddCamera (maze_cam, "maze");
maze_cam_transform.Position = new Vector3 (115, 240, 110);
maze_cam_transform.Rotation = Quaternion.FromAxisAngle (Vector3.UnitX, MathHelper.PiOver2);
state.Scene.CameraManager.AddCamera (new BaseCamera (Player, state.MessageProxy), "player");
RigidBody playerBody = new RigidBody (new SphereShape (1f));
playerBody.Position = Player.GetComponent<TransformComponent> ().Position.ToJitterVector ();
playerBody.AllowDeactivation = false;
playerBody.Material.StaticFriction = 0f;
playerBody.Material.KineticFriction = 0f;
playerBody.Material.Restitution = 0.1f;
//playerBody.Mass = 1000000.0f;
playerBody.Update ();
Player.GetComponent<PhysicsComponent> ().RigidBody = playerBody;
Player.GetComponent<PhysicsComponent> ().World = state.PhysicsManager.World;
Player.GetComponent<PhysicsComponent> ().PhysicsApplying = AffectedByPhysics.Position;
#if PRESENTATION
Player.GetComponent<HealthComponent>().MaximumHealth = 500;
Player.GetComponent<HealthComponent>().Health = 500;
#endif
state.PhysicsManager.World.AddBody (playerBody);
int seed = new FastRandom ().Next ();
var rand = new FastRandom (seed);
Logger.Log.AddLogEntry (LogLevel.Debug, "MazeTest", "Seed: {0}", seed);
#if PRESENTATION
maze [0] = mazeGenerator.CreateMaze<OverworldMazeTheme> (rand.Next (), state.MessageProxy, state.PhysicsManager, app.AudioManager, 10, 10);
#else
maze [0] = mazeGenerator.CreateMaze<OverworldMazeTheme> (rand.Next (), state.MessageProxy, state.PhysicsManager, app.AudioManager, 30, 30);
#endif
maze [0].PlayerPosition += Player.GetComponent<TransformComponent> ().Position;
maze [0].AIManager.RegisterEntity (Player);
for (int i = 0; i < OverworldScobisCount; i++)
{
ScobisInstances.Add (new Scobis (state, maze [0].AIManager, rendererContext));
}
for (int i = 0; i < OverworldCaligoCount; i++)
{
CaligoInstances.Add (new Caligo (state, maze [0].AIManager, rendererContext, warpingNode));
}
for (int i = 0; i < OverworldViridionCount; i++)
{
ViridionInstances.Add (new Viridion (state, maze [0].AIManager, rendererContext, ColorCorrectionNode));
}
for (int i = 0; i < OverworldGhostCount; i++)
{
GhostInstances.Add (new Ghost (state, maze [0].AIManager, rendererContext, ColorCorrectionNode));
}
game.AddGameState ("maze_underworld", Content.Environment.Default,
new[] { new Tuple<string, GameStateTransition> ("maze_overworld", new GameStateTransition (0)) },
new[] { new Tuple<string, GameStateTransition> ("maze_overworld", new GameStateTransition (0)),
new Tuple<string, GameStateTransition> ("endscreen_state", new GameStateTransition (0))
});
state = game.GetGameState ("maze_underworld");
state.Scene = new CoreScene (rendererContext, messageProvider);
state.Scene.SceneName = "MazeUnderworld";
state.Scene.Active = false;
state.Scene.BackgroundColor = Color4.AliceBlue;
state.Scene.DistanceFogIntensity = 0.07f;
state.Scene.AmbientColor = Color4.White;
state.Scene.AmbientIntensity = 0.3f;
state.Scene.MaxRenderingDistance = 1000.0f;
state.AudioContext = new AudioContext (state.MessageProxy);
AddAudio (state);
state.Scene.CameraManager.AddCamera (new BaseCamera (Player, state.MessageProxy), "player");
#if PRESENTATION
maze [1] = mazeGenerator.CreateMaze<UnderworldMazeTheme> (rand.Next (), state.MessageProxy, state.PhysicsManager, app.AudioManager, 10, 10);
#else
maze [1] = mazeGenerator.CreateMaze<UnderworldMazeTheme> (rand.Next (), state.MessageProxy, state.PhysicsManager, app.AudioManager, 30, 30);
#endif
maze [1].PlayerPosition += Player.GetComponent<TransformComponent> ().Position;
maze [1].AIManager.RegisterEntity (Player);
Func<int, int, bool> containsPortalFunc = (x, y) =>
{
foreach (var m in maze)
{
var cell = m.entities [x, y].GetComponent<PhysicsComponent> ().RigidBody.Tag as MazeCell;
if (cell != null && cell.IsPortal)
{
return true;
}
}
return false;
};
mazeWallMover = new MazeWallMover (maze [0], maze [1], game.GetGameState ("maze_overworld"), containsPortalFunc);
state.MessageProxy.StopProcessing ();
//game.SwitchToGameState("maze_overworld");
for (int i = 0; i < UnderworldCaligoCount; i++)
{
CaligoInstances.Add (new Caligo (state, maze [1].AIManager, rendererContext, warpingNode));
}
for (int i = 0; i < UnderworldPassusCount; i++)
{
PassusInstances.Add (new Passus (ColorCorrectionNode, state, maze [1].AIManager, rendererContext));
}
for (int i = 0; i < UnderworldRoachesCount; i++)
{
RoachesInstances.Add(new Roaches (state, maze [0].AIManager, rendererContext));
}
for (int i = 0; i < UnderworldFenFireCount; i++)
{
FenFireInstances.Add (new FenFire (state, maze [1].AIManager, rendererContext));
}
}
