public LevelScreen(LoderGame game, SystemManager systemManager, EntityManager entityManager)
: base(game.screenSystem, ScreenType.Level)
{
_game = game;
_systemManager = systemManager;
_entityManager = entityManager;
_levelSystem = (LevelSystem)_systemManager.getSystem(SystemType.Level);
_content = new ContentManager(_game.Services);
_content.RootDirectory = "Content";
_equipmentSystem = (EquipmentSystem)_systemManager.getSystem(SystemType.Equipment);
_playerId = PlayerSystem.PLAYER_ID;
_pixel = new Texture2D(_game.GraphicsDevice, 1, 1);
_pixel.SetData <Color>(new[] { Color.White });
_arial = _content.Load <SpriteFont>("arial");
_dialogePanes = new List <InteractiveDialoguePane>();
_dialogueFont = _content.Load <SpriteFont>("shared_ui/dialogue_font");
_dialogueOptionFont = _content.Load <SpriteFont>("shared_ui/dialogue_option_font");
ToolbarComponent toolbarComponent = (ToolbarComponent)_entityManager.getComponent(LevelSystem.currentLevelUid, _playerId, ComponentType.Toolbar);
_toolbarDisplay = new ToolbarDisplay(_game.spriteBatch, _equipmentSystem, toolbarComponent);
_inventoryDisplay = new InventoryDisplay(_game.spriteBatch, _equipmentSystem, (InventoryComponent)_entityManager.getComponent(LevelSystem.currentLevelUid, _playerId, ComponentType.Inventory), toolbarComponent);
_inventoryDisplay.inFocus = false;
_toolbarDisplay.inFocus = true;
_healthBar = new LargeHealthBar(_game.spriteBatch);
}
public ToolbarDisplay(SpriteBatch spriteBatch, EquipmentSystem equipmentSystem, ToolbarComponent toolbarComponent)
{
_spriteBatch = spriteBatch;
_toolbarComponent = toolbarComponent;
_equipmentSystem = equipmentSystem;
_pixel = new Texture2D(_spriteBatch.GraphicsDevice, 1, 1);
_pixel.SetData<Color>(new[] { Color.White });
}
public ToolbarDisplay(SpriteBatch spriteBatch, EquipmentSystem equipmentSystem, ToolbarComponent toolbarComponent)
{
_spriteBatch = spriteBatch;
_toolbarComponent = toolbarComponent;
_equipmentSystem = equipmentSystem;
_pixel = new Texture2D(_spriteBatch.GraphicsDevice, 1, 1);
_pixel.SetData <Color>(new[] { Color.White });
}
public void TestStartup()
{
tinyMCE = pageObjectFactory.PrepareComponent(
new TinyMCEComponent(
By.CssSelector("textarea"),
pageObjectFactory,
driver,
new TinyMCEOptions()));
toolbar = tinyMCE.Toolbar;
}
// selectToolbarSlot
public void selectToolbarSlot(string levelUid, ToolbarComponent toolbarComponent, int slot)
{
ItemComponent itemComponent = toolbarComponent.selectedItem;
if (itemComponent != null && itemComponent.definition.hasAimingComponent)
{
_entityManager.removeComponent(levelUid, toolbarComponent.entityId, ComponentType.Aim);
}
toolbarComponent.selectedIndex = slot;
itemComponent = toolbarComponent.selectedItem;
if (itemComponent != null && itemComponent.definition.hasAimingComponent)
{
Console.WriteLine("Adding aim component");
_entityManager.addComponent(levelUid, toolbarComponent.entityId, new AimComponent(new Vector2(10f, 0f), 0f, 10f));
}
}
// Load player toolbar
public static void loadPlayerToolbar()
{
XElement toolbarData = _playerData.Element("ToolbarState");
ToolbarComponent toolbarComponent = new ToolbarComponent(int.Parse(toolbarData.Attribute("slots").Value), PlayerSystem.PLAYER_ID);
EquipmentSystem equipmentSystem = _systemManager.getSystem(SystemType.Equipment) as EquipmentSystem;
InventoryComponent inventoryComponent = _entityManager.getComponent("global", PlayerSystem.PLAYER_ID, ComponentType.Inventory) as InventoryComponent;
_entityManager.addComponent("global", PlayerSystem.PLAYER_ID, toolbarComponent);
foreach (XElement slotData in toolbarData.Elements("Slot"))
{
equipmentSystem.assignItemToToolbar(
"global",
equipmentSystem.getInventoryItem(inventoryComponent, int.Parse(slotData.Attribute("inventory_slot").Value)),
toolbarComponent,
int.Parse(slotData.Attribute("slot_id").Value));
}
equipmentSystem.selectToolbarSlot("global", toolbarComponent, int.Parse(toolbarData.Attribute("selected_index").Value));
}
// Save player data
public static void savePlayerData()
{
Logger.log("DataManager.savePlayerData method starting.");
string filePath = _playersDirectory + string.Format("player_data_{0}.xml", _playerSlot);
using (FileStream fs = new FileStream(filePath, FileMode.Create))
{
XDocument doc = new XDocument();
InventoryComponent inventoryComponent = _entityManager.getComponent("global", PlayerSystem.PLAYER_ID, ComponentType.Inventory) as InventoryComponent;
ToolbarComponent toolbarComponent = _entityManager.getComponent("global", PlayerSystem.PLAYER_ID, ComponentType.Toolbar) as ToolbarComponent;
EquipmentSystem equipmentSystem = _systemManager.getSystem(SystemType.Equipment) as EquipmentSystem;
XElement inventoryData = new XElement("InventoryState");
XElement toolbarData = new XElement("ToolbarState");
List <XElement> customFlagsData = new List <XElement>();
List <XElement> customValuesData = new List <XElement>();
List <XElement> customStringsData = new List <XElement>();
// Basic player data
_playerData = new XElement(
"PlayerData",
new XAttribute("name", _playerName),
new XAttribute("slot", _playerSlot));
// World map states
foreach (WorldMapState worldMapState in _worldMapManager.worldMapStates.Values)
{
XElement worldMapStateData = new XElement(
"WorldMapState",
new XAttribute("world_map_uid", worldMapState.definition.uid),
new XAttribute("discovered", worldMapState.discovered));
foreach (LevelIconState levelIconState in worldMapState.levelIconStates)
{
worldMapStateData.Add(
new XElement("LevelIconState",
new XAttribute("level_icon_uid", levelIconState.definition.uid),
new XAttribute("discovered", levelIconState.discovered),
new XAttribute("finished", levelIconState.finished)));
}
foreach (LevelPathState levelPathState in worldMapState.levelPathState)
{
worldMapStateData.Add(new XElement("LevelPathState", new XAttribute("discovered", levelPathState.discovered)));
}
_playerData.Add(worldMapStateData);
}
// Quest states
_playerData.Add(_questManager.createData());
// Inventory states
inventoryData.SetAttributeValue("slots", inventoryComponent.slots);
foreach (KeyValuePair <int, ItemComponent> slotItemPair in inventoryComponent.inventory)
{
inventoryData.Add(
new XElement(
"ItemState",
new XAttribute("slot_id", slotItemPair.Key),
new XAttribute("item_uid", slotItemPair.Value.definition.uid),
new XAttribute("quantity", slotItemPair.Value.state.quantity),
new XAttribute("current_range_limit", slotItemPair.Value.state.currentRangeLimit)));
}
_playerData.Add(inventoryData);
// Toolbar states
toolbarData.SetAttributeValue("slots", toolbarComponent.slots);
toolbarData.SetAttributeValue("selected_index", toolbarComponent.selectedIndex);
foreach (KeyValuePair <int, ItemComponent> slotItemPair in toolbarComponent.inventory)
{
if (slotItemPair.Value != null)
{
toolbarData.Add(
new XElement(
"Slot",
new XAttribute("slot_id", slotItemPair.Key),
new XAttribute("inventory_slot", equipmentSystem.getInventorySlot(inventoryComponent, slotItemPair.Value))));
}
}
_playerData.Add(toolbarData);
// Custom flags
foreach (KeyValuePair <string, bool> uidFlagPair in _customFlags)
{
customFlagsData.Add(new XElement("CustomFlag", new XAttribute("uid", uidFlagPair.Key), new XAttribute("value", uidFlagPair.Value)));
}
_playerData.Add(customFlagsData);
// Custom values
foreach (KeyValuePair <string, int> uidValuePair in _customValues)
{
customValuesData.Add(new XElement("CustomValue", new XAttribute("uid", uidValuePair.Key), new XAttribute("value", uidValuePair.Value)));
}
_playerData.Add(customValuesData);
// Custom values
foreach (KeyValuePair <string, string> uidStringPair in _customStrings)
{
customStringsData.Add(new XElement("CustomString", new XAttribute("uid", uidStringPair.Key), new XAttribute("value", uidStringPair.Value)));
}
_playerData.Add(customStringsData);
doc.Add(_playerData);
doc.Save(fs);
}
Logger.log("DataManager.savePlayerData method finished.");
}
// assignItemToToolbar
public void assignItemToToolbar(string levelUid, ItemComponent itemComponent, ToolbarComponent toolbarComponent, int toolbarSlot)
{
toolbarComponent.inventory[toolbarSlot] = itemComponent;
selectToolbarSlot(levelUid, toolbarComponent, toolbarComponent.selectedIndex);
}
// update
public void update(GameTime gameTime)
{
if (_singleStep || !_paused)
{
string levelUid = LevelSystem.currentLevelUid;
LevelSystem levelSystem = _systemManager.getSystem(SystemType.Level) as LevelSystem;
if (levelSystem.finalized)
{
PlayerSystem playerSystem = _systemManager.getSystem(SystemType.Player) as PlayerSystem;
RopeSystem ropeSystem = _systemManager.getSystem(SystemType.Rope) as RopeSystem;
PhysicsComponent playerPhysicsComponent = _entityManager.getComponent(levelUid, PlayerSystem.PLAYER_ID, ComponentType.Physics) as PhysicsComponent;
List <int> toolbarEntities = _entityManager.getEntitiesPosessing(levelUid, ComponentType.Toolbar);
// Player equipment
if (playerSystem != null)
{
ToolbarComponent playerToolbar = _entityManager.getComponent(levelUid, PlayerSystem.PLAYER_ID, ComponentType.Toolbar) as ToolbarComponent;
WorldPositionComponent playerPositionComponent = _entityManager.getComponent(levelUid, PlayerSystem.PLAYER_ID, ComponentType.WorldPosition) as WorldPositionComponent;
ItemComponent selectedItem = playerToolbar.selectedItem;
if (selectedItem != null)
{
selectedItem.primaryContinuousAction = InputSystem.newMouseState.LeftButton == ButtonState.Pressed;
selectedItem.primarySingleAction = selectedItem.primaryContinuousAction && InputSystem.oldMouseState.LeftButton == ButtonState.Released;
selectedItem.secondaryContinuousAction = InputSystem.newMouseState.RightButton == ButtonState.Pressed;
selectedItem.secondarySingleAction = selectedItem.secondaryContinuousAction && InputSystem.oldMouseState.RightButton == ButtonState.Released;
//bool leftTriggerDown = InputSystem.usingGamepad && InputSystem.newGamepadState.Triggers.Left > 0.5f && InputSystem.oldGamepadState.Triggers.Left <= 0.5f;
//bool rightTriggerDown = InputSystem.usingGamepad && InputSystem.newGamepadState.Triggers.Right > 0.5f && InputSystem.oldGamepadState.Triggers.Right <= 0.5f;
AimComponent aimComponent = _entityManager.getComponent(levelUid, PlayerSystem.PLAYER_ID, ComponentType.Aim) as AimComponent;
if (selectedItem.definition.hasAimingComponent && aimComponent != null)
{
WorldPositionComponent worldPositionComponent = _entityManager.getComponent(levelUid, PlayerSystem.PLAYER_ID, ComponentType.WorldPosition) as WorldPositionComponent;
if (worldPositionComponent != null)
{
Vector2 worldPosition = worldPositionComponent.position;
if (InputSystem.usingGamepad)
{
Vector2 vector = InputSystem.newGamepadState.ThumbSticks.Left * selectedItem.state.currentRangeLimit;
vector.Y *= -1;
aimComponent.angle = (float)Math.Atan2(vector.Y, vector.X);
aimComponent.length = vector.Length();
aimComponent.vector = vector;
}
else
{
Vector2 relative = (InputSystem.worldMouse - worldPosition);
aimComponent.angle = (float)Math.Atan2(relative.Y, relative.X);
aimComponent.length = Math.Min(relative.Length(), selectedItem.state.currentRangeLimit);
aimComponent.vector = relative;
}
}
}
}
}
// All toolbars
for (int i = 0; i < toolbarEntities.Count; i++)
{
ToolbarComponent toolbarComponent = _entityManager.getComponent(levelUid, toolbarEntities[i], ComponentType.Toolbar) as ToolbarComponent;
ItemComponent selectedItem = toolbarComponent.selectedItem;
if (selectedItem != null)
{
if (selectedItem.secondarySingleAction)
{
Console.WriteLine("secondary action");
}
switch (selectedItem.definition.uid)
{
// RopeGun
case "ropegun":
if (selectedItem.primarySingleAction)
{
AimComponent aimComponent = _entityManager.getComponent(levelUid, toolbarEntities[i], ComponentType.Aim) as AimComponent;
Vector2 initialPointA = (_entityManager.getComponent(levelUid, toolbarEntities[i], ComponentType.WorldPosition) as WorldPositionComponent).position;
Vector2 initialPointB = initialPointA + new Vector2((float)Math.Cos(aimComponent.angle), (float)Math.Sin(aimComponent.angle)) * aimComponent.length;
int ropeEntityId = _entityManager.factory.createSingleAnchorRope(levelUid, initialPointA, initialPointB, _defaultRopeMaterial, true);
if (ropeEntityId != -1)
{
RopeGrabComponent ropeGrabComponent = _entityManager.getComponent(levelUid, toolbarComponent.entityId, ComponentType.RopeGrab) as RopeGrabComponent;
RopeComponent ropeComponent = _entityManager.getComponent(levelUid, ropeEntityId, ComponentType.Rope) as RopeComponent;
PhysicsComponent physicsComponent = _entityManager.getComponent(levelUid, toolbarEntities[i], ComponentType.Physics) as PhysicsComponent;
RopeGrabComponent newRopeGrabComponent = null;
Vector2 initialVelocity = physicsComponent.body.LinearVelocity;
RopeNode currentNode = null;
int ropeSegmentCount;
if (physicsComponent == null)
{
break;
}
// Handle initial velocity
currentNode = ropeComponent.ropeNodeHead;
ropeSegmentCount = currentNode.count;
System.Diagnostics.Debug.Assert(ropeSegmentCount != 0);
int count = ropeSegmentCount;
while (currentNode != null)
{
float weight = (float)count / (float)ropeSegmentCount;
currentNode.body.LinearVelocity = currentNode.body.LinearVelocity + initialVelocity * weight;
count--;
currentNode = currentNode.next;
}
// Handle previous grabs
if (ropeGrabComponent != null)
{
RopeComponent previouslyGrabbedRope = _entityManager.getComponent(levelUid, ropeGrabComponent.ropeEntityId, ComponentType.Rope) as RopeComponent;
ropeSystem.releaseRope(ropeGrabComponent, physicsComponent.body);
if (previouslyGrabbedRope.destroyAfterRelease)
{
previouslyGrabbedRope.timeToLive = 100;
}
_entityManager.removeComponent(levelUid, toolbarComponent.entityId, ropeGrabComponent);
ropeGrabComponent = null;
}
newRopeGrabComponent = new RopeGrabComponent(ropeEntityId, ropeComponent.ropeNodeHead, 0f, ropeComponent.reverseClimbDirection);
ropeSystem.grabRope(newRopeGrabComponent, physicsComponent.body);
_entityManager.addComponent(levelUid, toolbarComponent.entityId, newRopeGrabComponent);
}
}
break;
// Dynamite
case "dynamite":
if (selectedItem.primarySingleAction)
{
AimComponent aimComponent = _entityManager.getComponent(levelUid, toolbarEntities[i], ComponentType.Aim) as AimComponent;
_entityManager.factory.createDynamite(levelUid, playerPhysicsComponent.body.Position, aimComponent.vector * 80f);
}
break;
// Water gun
case "watergun":
if (selectedItem.primaryContinuousAction)
{
FluidSystem fluidSystem = _systemManager.getSystem(SystemType.Fluid) as FluidSystem;
AimComponent aimComponent = _entityManager.getComponent(levelUid, toolbarEntities[i], ComponentType.Aim) as AimComponent;
Vector2 aimUnitVector = Vector2.Normalize(aimComponent.vector);
Vector2 particlePosition =
playerPhysicsComponent.body.Position +
aimUnitVector +
new Vector2(StasisMathHelper.floatBetween(-0.1f, 0.1f, _rng), StasisMathHelper.floatBetween(-0.1f, 0.1f, _rng));
Vector2 particleVelocity = aimUnitVector * 0.4f;
fluidSystem.createParticle(particlePosition, particleVelocity);
}
break;
}
selectedItem.primarySingleAction = false;
selectedItem.secondarySingleAction = false;
selectedItem.primaryContinuousAction = false;
selectedItem.secondaryContinuousAction = false;
}
}
}
}
_singleStep = false;
}
// assignItemToToolbar
public void assignItemToToolbar(string levelUid, ItemComponent itemComponent, ToolbarComponent toolbarComponent, int toolbarSlot)
{
toolbarComponent.inventory[toolbarSlot] = itemComponent;
selectToolbarSlot(levelUid, toolbarComponent, toolbarComponent.selectedIndex);
}
// selectToolbarSlot
public void selectToolbarSlot(string levelUid, ToolbarComponent toolbarComponent, int slot)
{
ItemComponent itemComponent = toolbarComponent.selectedItem;
if (itemComponent != null && itemComponent.definition.hasAimingComponent)
{
_entityManager.removeComponent(levelUid, toolbarComponent.entityId, ComponentType.Aim);
}
toolbarComponent.selectedIndex = slot;
itemComponent = toolbarComponent.selectedItem;
if (itemComponent != null && itemComponent.definition.hasAimingComponent)
{
Console.WriteLine("Adding aim component");
_entityManager.addComponent(levelUid, toolbarComponent.entityId, new AimComponent(new Vector2(10f, 0f), 0f, 10f));
}
}
public static bool TryParseNode(IParser parser, out ToolbarAttribute node, ToolbarComponent component)
{
node = null;
bool result = false;
switch (parser.PeekToken().Kind)
{
case TokenKind.ButtonTextHiddenKeyword:
{
if (component == ToolbarComponent.Toolbar)
{
parser.NextToken();
result = true;
node = new ToolbarAttribute();
node.StartIndex = parser.Token.Span.Start;
node.EndIndex = parser.Token.Span.End;
}
else
{
parser.ReportSyntaxError("Toolbar attribute \"BUTTONTEXTHIDDEN\" is only allowed within a TOOLBAR block.");
}
}
break;
case TokenKind.StyleKeyword:
case TokenKind.TagKeyword:
{
parser.NextToken();
result = true;
node = new ToolbarAttribute();
node.StartIndex = parser.Token.Span.Start;
if (parser.PeekToken(TokenKind.Equals))
{
parser.NextToken();
if (parser.PeekToken(TokenCategory.StringLiteral))
{
parser.NextToken();
node.EndIndex = parser.Token.Span.End;
}
else
{
parser.ReportSyntaxError("Invalid option found. Expecting string literal.");
}
}
else
{
parser.ReportSyntaxError("Expected equals token for toolbar attribute.");
}
}
break;
case TokenKind.CommentKeyword:
case TokenKind.ImageKeyword:
case TokenKind.TextKeyword:
{
if (component == ToolbarComponent.Item)
{
parser.NextToken();
result = true;
node = new ToolbarAttribute();
node.StartIndex = parser.Token.Span.Start;
if (parser.PeekToken(TokenKind.Equals))
{
parser.NextToken();
if (parser.PeekToken(TokenCategory.StringLiteral))
{
parser.NextToken();
node.EndIndex = parser.Token.Span.End;
}
else
{
parser.ReportSyntaxError("Invalid option found. Expecting string literal.");
}
}
else
{
parser.ReportSyntaxError("Expected equals token for toolbar attribute.");
}
}
else
{
parser.ReportSyntaxError("Toolbar attribute not allowed for this block.");
}
}
break;
case TokenKind.HiddenKeyword:
{
if (component == ToolbarComponent.Item ||
component == ToolbarComponent.Separator)
{
parser.NextToken();
result = true;
node = new ToolbarAttribute();
node.StartIndex = parser.Token.Span.Start;
if (parser.PeekToken(TokenKind.Equals))
{
if (parser.PeekToken(TokenKind.UserKeyword))
{
parser.NextToken();
}
else
{
parser.ReportSyntaxError("Invalid token found. Expecting \"USER\".");
}
}
node.EndIndex = parser.Token.Span.End;
}
else
{
parser.ReportSyntaxError("Toolbar attribute \"HIDDEN\" not allowed for the current toolbar block.");
}
}
break;
}
return(result);
}
// Load player toolbar
public static void loadPlayerToolbar()
{
XElement toolbarData = _playerData.Element("ToolbarState");
ToolbarComponent toolbarComponent = new ToolbarComponent(int.Parse(toolbarData.Attribute("slots").Value), PlayerSystem.PLAYER_ID);
EquipmentSystem equipmentSystem = _systemManager.getSystem(SystemType.Equipment) as EquipmentSystem;
InventoryComponent inventoryComponent = _entityManager.getComponent("global", PlayerSystem.PLAYER_ID, ComponentType.Inventory) as InventoryComponent;
_entityManager.addComponent("global", PlayerSystem.PLAYER_ID, toolbarComponent);
foreach (XElement slotData in toolbarData.Elements("Slot"))
{
equipmentSystem.assignItemToToolbar(
"global",
equipmentSystem.getInventoryItem(inventoryComponent, int.Parse(slotData.Attribute("inventory_slot").Value)),
toolbarComponent,
int.Parse(slotData.Attribute("slot_id").Value));
}
equipmentSystem.selectToolbarSlot("global", toolbarComponent, int.Parse(toolbarData.Attribute("selected_index").Value));
}
