/// <summary>
///
/// </summary>
/// <param name="Id"></param>
/// <param name="gameTime"></param>
private void KeyBoardMove(int Id, GameTime gameTime)
{
KeyBoardComponent kbc = ComponentManager.Instance.GetEntityComponent <KeyBoardComponent>(Id);
PositionComponent p = ComponentManager.Instance.GetEntityComponent <PositionComponent>(Id);
PlayerComponent pc = ComponentManager.Instance.GetEntityComponent <PlayerComponent>(Id);
VelocityComponent v = ComponentManager.Instance.GetEntityComponent <VelocityComponent>(Id);
DirectionComponent dc = ComponentManager.Instance.GetEntityComponent <DirectionComponent>(Id);
JumpComponent jump = ComponentManager.Instance.GetEntityComponent <JumpComponent>(Id);
p.prevPosition = p.position;
if (dc != null && v != null)
{
v.velocity.X = sideMovement * (int)dc.directio;
}
if (p != null && v != null && kbc != null && jump != null && dc != null)
{
if (kbc.state[ActionsEnum.Jump] == ButtonStates.Pressed && !pc.isFalling)
{
if (dc.directio == Direction.Still)
{
dc.directio = dc.preDir;
}
if (v.velocity.Y > -jump.maxJumpHeight)
{
v.velocity.Y -= jump.jumpHeight;
ComponentManager.Instance.AddComponentToEntity(Id, new SoundEffectComponent("jump"));
}
}
v.velocity.Y += gravity * (float)gameTime.ElapsedGameTime.TotalSeconds;
p.position += v.velocity * (float)gameTime.ElapsedGameTime.TotalSeconds;
}
}
public static void RemoveKeyFromAction(ref KeyBoardComponent k, string action, Keys key)
{
if (k.Actions.ContainsKey(action))
{
k.Actions[action].Remove(key);
}
}
public void UpdateActionStates(KeyBoardComponent keyboardComp)
{
foreach (string action in keyboardComp.Actions.Keys)
{
foreach (Keys key in keyboardComp.Actions[action])
{
bool newState = keyboardComp.NewState.IsKeyDown(key);
bool oldState = keyboardComp.OldState.IsKeyDown(key);
if (newState && !oldState)
{
keyboardComp.ActionStates[action] = BUTTON_STATE.PRESSED;
break;
}
else if (newState && oldState)
{
keyboardComp.ActionStates[action] = BUTTON_STATE.HELD;
break;
}
else if (!newState && oldState)
{
keyboardComp.ActionStates[action] = BUTTON_STATE.RELEASED;
break;
}
else
{
keyboardComp.ActionStates[action] = BUTTON_STATE.NOT_PRESSED;
}
}
}
}
/// <summary>
/// updates the states of all the Keyboard actions in a keyboard Component
/// </summary>
/// <param name="keyboardComp"></param>
public void UpdateActionStates(KeyBoardComponent keyboardComp)
{
foreach (ActionsEnum action in keyboardComp.keyBoardActions.Keys)
{
Keys key = keyboardComp.keyBoardActions[action];
bool newState = curState.IsKeyDown(key);
bool oldState = prevState.IsKeyDown(key);
if (newState && !oldState)
{
keyboardComp.state[action] = ButtonStates.Pressed;
}
else if (newState && oldState)
{
keyboardComp.state[action] = ButtonStates.Hold;
}
else if (!newState && oldState)
{
keyboardComp.state[action] = ButtonStates.Released;
}
else
{
keyboardComp.state[action] = ButtonStates.Not_Pressed;
}
}
}
/// <summary>
/// Creates an new Player with Controlls
/// </summary>
/// <param name="pixlePer"> True if pixelPerfect shall be used </param>
/// <param name="GamePade"> True if GamePad the player uses a gamepad </param>
/// <param name="PadJump"> Key binding to gamePad </param>
/// <param name="Jump"> key binding to keybord </param>
/// <param name="position"> Player start Position </param>
/// <param name="name"> The name off the player</param>
/// <param name="dir"> The players starting direction</param>
/// <param name="index"> Playerindex For GamePad </param>
/// <returns></returns>
public int CreatePlayer(bool pixlePer, bool GamePade, Buttons PadJump, Keys Jump, Vector2 position, string name, Direction dir, PlayerIndex index, Color colour)
{
SpriteEffects flip;
GamePadComponent gam;
KeyBoardComponent kcb;
int id = ComponentManager.Instance.CreateID();
if (dir == Direction.Left)
{
flip = SpriteEffects.FlipHorizontally;
}
else
{
flip = SpriteEffects.None;
}
if (GamePade == true)
{
gam = new GamePadComponent(index);
gam.gamepadActions.Add(ActionsEnum.Jump, PadJump);
ComponentManager.Instance.AddComponentToEntity(id, gam);
}
else
{
kcb = new KeyBoardComponent();
kcb.keyBoardActions.Add(ActionsEnum.Jump, Jump);
ComponentManager.Instance.AddComponentToEntity(id, kcb);
}
DirectionComponent dc = new DirectionComponent(dir);
DrawableComponent comp = new DrawableComponent(Game.Instance.GetContent <Texture2D>("Pic/kanin1"), flip);
PositionComponent pos = new PositionComponent(position);
VelocityComponent vel = new VelocityComponent(new Vector2(200F, 0), 50F);
JumpComponent jump = new JumpComponent(300F, 200F);
CollisionRectangleComponent CRC = new CollisionRectangleComponent(new Rectangle((int)pos.position.X, (int)pos.position.Y, comp.texture.Width, comp.texture.Height));
CollisionComponent CC = new CollisionComponent(pixlePer);
PlayerComponent pc = new PlayerComponent(name);
DrawableTextComponent dtc = new DrawableTextComponent(name, Color.Black, Game.Instance.GetContent <SpriteFont>("Fonts/TestFont"));
HUDComponent hudc = new HUDComponent(Game.Instance.GetContent <Texture2D>("Pic/PowerUp"), new Vector2(pos.position.X, pos.position.Y));
HUDComponent hudc2 = new HUDComponent(Game.Instance.GetContent <Texture2D>("Pic/PowerUp"), Vector2.One);
HealthComponent hc = new HealthComponent(3, false);
//AnimationComponent ani = new AnimationComponent(100, 114, comp.texture.Width, comp.texture.Height, 0.2);
comp.colour = colour;
ComponentManager.Instance.AddComponentToEntity(id, vel);
ComponentManager.Instance.AddComponentToEntity(id, comp);
ComponentManager.Instance.AddComponentToEntity(id, pos);
ComponentManager.Instance.AddComponentToEntity(id, CRC);
ComponentManager.Instance.AddComponentToEntity(id, CC);
ComponentManager.Instance.AddComponentToEntity(id, pc);
ComponentManager.Instance.AddComponentToEntity(id, dtc);
ComponentManager.Instance.AddComponentToEntity(id, hudc);
ComponentManager.Instance.AddComponentToEntity(id, hc);
//ComponentManager.Instance.AddComponentToEntity(id, ani);
ComponentManager.Instance.AddComponentToEntity(id, dc);
ComponentManager.Instance.AddComponentToEntity(id, jump);
return(id);
}
/// <summary>
/// onSceneCreated this function is called whenever the current gamestate is changed. This function should contain logic that
/// needs to be processed before the state is shown for the player. This could be enteties that's not able to be created pre-runtime.
/// </summary>
public void onSceneCreated()
{
DrawableTextComponent text1 = new DrawableTextComponent("Map:", Color.Black, Game.Instance.GetContent <SpriteFont>("Fonts/Menufont"));
PositionComponent pos1 = new PositionComponent(new Vector2(0, Game.Instance.GraphicsDevice.Viewport.Height - 80));
int id1 = ComponentManager.Instance.CreateID();
FadeComponent fc2 = new FadeComponent(1, 3);
ComponentManager.Instance.AddComponentToEntity(id1, text1);
ComponentManager.Instance.AddComponentToEntity(id1, pos1);
ComponentManager.Instance.AddComponentToEntity(id1, fc2);
entitiesInState.Add(id1);
draw = new DrawableTextComponent("Whiteboard", Color.Black, Game.Instance.GetContent <SpriteFont>("Fonts/Menufont"));
PositionComponent pos2 = new PositionComponent(new Vector2(105, Game.Instance.GraphicsDevice.Viewport.Height - 80));
kbc1 = new KeyBoardComponent();
FadeComponent fc = new FadeComponent(1, 3);
kbc1.keyBoardActions.Add(ActionsEnum.Left, Keys.Right);
newId = ComponentManager.Instance.CreateID();
ComponentManager.Instance.AddComponentToEntity(newId, fc);
ComponentManager.Instance.AddComponentToEntity(newId, draw);
ComponentManager.Instance.AddComponentToEntity(newId, pos2);
ComponentManager.Instance.AddComponentToEntity(newId, kbc1);
DrawableTextComponent text = new DrawableTextComponent("Press Enter To Start", Color.Black, Game.Instance.GetContent <SpriteFont>("Fonts/Menufont"));
PositionComponent pos = new PositionComponent(new Vector2(300, 0));
KeyBoardComponent kbc = new KeyBoardComponent();
FadeComponent fc3 = new FadeComponent(1, 3);
kbc.keyBoardActions.Add(ActionsEnum.Enter, Keys.Enter);
textId = ComponentManager.Instance.CreateID();
ComponentManager.Instance.AddComponentToEntity(textId, kbc);
ComponentManager.Instance.AddComponentToEntity(textId, text);
ComponentManager.Instance.AddComponentToEntity(textId, pos);
ComponentManager.Instance.AddComponentToEntity(textId, fc3);
entitiesInState.Add(textId);
DrawableTextComponent text2 = new DrawableTextComponent("Press Right-Arrow key To Change Map", Color.Black, Game.Instance.GetContent <SpriteFont>("Fonts/Menufont"));
PositionComponent pos3 = new PositionComponent(new Vector2(180, 50));
int textId2 = ComponentManager.Instance.CreateID();
FadeComponent fc4 = new FadeComponent(1, 3);
ComponentManager.Instance.AddComponentToEntity(textId2, text2);
ComponentManager.Instance.AddComponentToEntity(textId2, pos3);
ComponentManager.Instance.AddComponentToEntity(textId2, fc4);
entitiesInState.Add(textId2);
DrawableTextComponent text3 = new DrawableTextComponent("Register Character By pressing a Key", Color.Black, Game.Instance.GetContent <SpriteFont>("Fonts/Menufont"));
PositionComponent pos4 = new PositionComponent(new Vector2(150, 100));
FadeComponent fc5 = new FadeComponent(1, 3);
int textId3 = ComponentManager.Instance.CreateID();
ComponentManager.Instance.AddComponentToEntity(textId3, text3);
ComponentManager.Instance.AddComponentToEntity(textId3, pos4);
ComponentManager.Instance.AddComponentToEntity(textId3, fc5);
entitiesInState.Add(textId3);
}
public static void AddKeyToAction(ref KeyBoardComponent k, string action, Keys key)
{
if (!k.Actions.ContainsKey(action))
{
k.Actions[action] = new List <Keys>();
k.ActionStates[action] = BUTTON_STATE.NOT_PRESSED;
}
k.Actions[action].Add(key);
}
private void MoveKart(GameTime gameTime, List <Entity> sceneEntities, TransformComponent trsComp, PhysicsComponent physComp)
{
Entity kb = ComponentManager.Instance.GetEntityWithTag("keyboard", sceneEntities);
Vector3 newRot = Vector3.Zero;
if (kb != null)
{
KeyBoardComponent k = ComponentManager.Instance.GetEntityComponent <KeyBoardComponent>(kb);
if (k != null)
{
if (Utilities.Utilities.CheckKeyboardAction("right", BUTTON_STATE.HELD, k))
{
newRot = new Vector3(-PhysicsManager.TurningAcceleration, 0f, 0f) * (float)gameTime.ElapsedGameTime.TotalSeconds;
trsComp.Rotation *= CreateRotation(newRot);
}
else if (Utilities.Utilities.CheckKeyboardAction("left", BUTTON_STATE.HELD, k))
{
newRot = new Vector3(PhysicsManager.TurningAcceleration, 0f, 0f) * (float)gameTime.ElapsedGameTime.TotalSeconds;
trsComp.Rotation *= CreateRotation(newRot);
}
if (Utilities.Utilities.CheckKeyboardAction("quit", BUTTON_STATE.RELEASED, k))
{
SystemManager.Instance.Category = "MainMenu";
SceneManager.Instance.SetActiveScene("MainMenu");
}
if (Utilities.Utilities.CheckKeyboardAction("forward", BUTTON_STATE.HELD, k))
{
if (trsComp.Velocity.X < PhysicsManager.MaxSpeed)
{
var acceleration = physComp.Force.X / physComp.Mass;
trsComp.Velocity.X += acceleration;
}
}
if (Utilities.Utilities.CheckKeyboardAction("back", BUTTON_STATE.HELD, k))
{
if (trsComp.Velocity.X > PhysicsManager.MaxReverseSpeed)
{
var acceleration = physComp.Force.X / physComp.Mass;
trsComp.Velocity.X -= acceleration;
}
}
if (Utilities.Utilities.CheckKeyboardAction("jump", BUTTON_STATE.PRESSED, k))
{
if (!physComp.InAir)
{
var acceleration = physComp.Force.Y / physComp.Mass;
trsComp.Velocity.Y += acceleration;
SoundManager.Instance.PlaySound("jump");
}
}
}
}
}
public WinScreenSystem(ECSEngine engine)
{
SceneManager.Instance.SetActiveScene("WinScreen");
SystemManager.Instance.Category = "WinScreen";
this.engine = engine;
List <Entity> sceneEntities = SceneManager.Instance.GetActiveScene().GetAllEntities();
winScreen = ComponentManager.Instance.GetEntityWithTag("WinScreenImage", sceneEntities);
keyboard = ComponentManager.Instance.GetEntityWithTag("WinScreenKeyboard", sceneEntities);
kbComp = ComponentManager.Instance.GetEntityComponent <KeyBoardComponent>(keyboard);
}
private void InitKeyboard()
{
Entity keyboardControl = EntityFactory.Instance.NewEntityWithTag("LooseScreenKeyboard");
ComponentManager.Instance.AddComponentToEntity(keyboardControl, new KeyBoardComponent());
KeyBoardComponent k = ComponentManager.Instance.GetEntityComponent <KeyBoardComponent>(keyboardControl);
KeyBoardSystem.AddKeyToAction(ref k, "quit", Keys.Escape);
SceneManager.Instance.AddEntityToSceneOnLayer("LooseScreen", 0, keyboardControl);
}
public static bool CheckKeyboardAction(string action, BUTTON_STATE state, KeyBoardComponent kbc)
{
if (kbc != null)
{
if (kbc.GetActionState(action) == state)
{
return(true);
}
}
return(false);
}
public MainMenuSystem(ECSEngine engine)
{
this.engine = engine;
List <Entity> sceneEntities = SceneManager.Instance.GetActiveScene().GetAllEntities();
single = ComponentManager.Instance.GetEntityWithTag("MM_SinglePlayerOption", sceneEntities);
multi = ComponentManager.Instance.GetEntityWithTag("MM_MultiPlayerOption", sceneEntities);
exit = ComponentManager.Instance.GetEntityWithTag("MM_ExitOption", sceneEntities);
keyboard = ComponentManager.Instance.GetEntityWithTag("mainMenuKeyboard", sceneEntities);
kbComp = ComponentManager.Instance.GetEntityComponent <KeyBoardComponent>(keyboard);
}
public MultiPlayerMenuSystem(ECSEngine engine)
{
this.engine = engine;
List <Entity> sceneEntities = SceneManager.Instance.GetActiveScene().GetAllEntities();
join = ComponentManager.Instance.GetEntityWithTag("MP_Join", sceneEntities);
host = ComponentManager.Instance.GetEntityWithTag("MP_Host", sceneEntities);
back = ComponentManager.Instance.GetEntityWithTag("MP_Back", sceneEntities);
keyboard = ComponentManager.Instance.GetEntityWithTag("MP_Keyboard", sceneEntities);
kbComp = ComponentManager.Instance.GetEntityComponent <KeyBoardComponent>(keyboard);
}
/// <summary>
/// onSceneCreated this function is called whenever the current gamestate is changed. This function should contain logic that
/// needs to be processed before the state is shown for the player. This could be enteties that's not able to be created pre-runtime.
/// </summary>
public void onSceneCreated()
{
ChangeCubesSystem ccs = (ChangeCubesSystem)SystemManager.Instance.RetrieveSystem <IUpdate>("ChangeCubesSystem");
ccs.Respawn(3);
SpawnPowerUpSystem sps = (SpawnPowerUpSystem)SystemManager.Instance.RetrieveSystem <IUpdate>("SpawnPowerUpSystem");
sps.Initialize();
List <int> maps = ComponentManager.Instance.GetAllEntitiesWithComponentType <DrawableTextComponent>();
if (maps.Count == 1)
{
int temp = maps.First();
DrawableTextComponent draw = ComponentManager.Instance.GetEntityComponent <DrawableTextComponent>(temp);
switch (draw.text)
{
case "Whiteboard":
WhiteboardMap();
break;
case "Temp":
tempMap();
break;
case "Random":
randomMap();
break;
}
}
SceneSystem.Instance.clearScene(maps);
List <int> Players = ComponentManager.Instance.GetAllEntitiesWithComponentType <PlayerComponent>();
int i = 1;
Random rand = new Random();
foreach (var play in Players)
{
DrawableComponent tempDraw = ComponentManager.Instance.GetEntityComponent <DrawableComponent>(play);
KeyBoardComponent tempkey = ComponentManager.Instance.GetEntityComponent <KeyBoardComponent>(play);
PositionComponent temppos = ComponentManager.Instance.GetEntityComponent <PositionComponent>(play);
Keys key;
tempkey.keyBoardActions.TryGetValue(ActionsEnum.Up, out key);
entitiesInState.Add(GameEntityFactory.Instance.CreatePlayer(true, false, Buttons.A, key, new Vector2(rand.Next((int)(Game.Instance.GraphicsDevice.Viewport.Width)), rand.Next((int)(Game.Instance.GraphicsDevice.Viewport.Height * 0.6))), "Player " + i, Direction.Right, PlayerIndex.One, tempDraw.colour));
i++;
ComponentManager.Instance.RemoveEntity(play);
//ComponentManager.Instance.RecycleID(play);
}
entitiesInState.Add(GameEntityFactory.Instance.CreateAIPlayer(Direction.Right, new Vector2(rand.Next((int)(Game.Instance.GraphicsDevice.Viewport.Width)), rand.Next((int)(Game.Instance.GraphicsDevice.Viewport.Height * 0.8))), true, "AI one", Color.Red));
}
private void InitKeyboard()
{
Entity keyboardControl = EntityFactory.Instance.NewEntityWithTag("mainMenuKeyboard");
ComponentManager.Instance.AddComponentToEntity(keyboardControl, new KeyBoardComponent());
KeyBoardComponent k = ComponentManager.Instance.GetEntityComponent <KeyBoardComponent>(keyboardControl);
KeyBoardSystem.AddKeyToAction(ref k, "down", Keys.Down);
KeyBoardSystem.AddKeyToAction(ref k, "up", Keys.Up);
KeyBoardSystem.AddKeyToAction(ref k, "apply", Keys.Enter);
KeyBoardSystem.AddKeyToAction(ref k, "quit", Keys.Escape);
SceneManager.Instance.AddEntityToSceneOnLayer("MainMenu", 0, keyboardControl);
}
/// <summary>
///
/// </summary>
/// <param name="gameTime"></param>
public void update(GameTime gameTime)
{
updateStates();
List <int> entities = ComponentManager.Instance.GetAllEntitiesWithComponentType <KeyBoardComponent>();
if (entities != null)
{
foreach (var item in entities)
{
KeyBoardComponent kbc = ComponentManager.Instance.GetEntityComponent <KeyBoardComponent>(item);
UpdateActionStates(kbc);
}
}
}
/// <summary>
/// onSceneCreated this function is called whenever the current gamestate is changed. This function should contain logic that
/// needs to be processed before the state is shown for the player. This could be enteties that's not able to be created pre-runtime.
/// </summary>
public void onSceneCreated()
{
SpriteFont font1 = Game.Instance.GetContent <SpriteFont>("Fonts/Menufont");
DrawableTextComponent winner = new DrawableTextComponent("Winner:", Color.Black, font1);
PositionComponent pos = new PositionComponent(new Vector2(Game.Instance.GraphicsDevice.Viewport.Width * 0.5f - ((float)font1.MeasureString("Winner:").X * 0.5f), 0));
kbc = new KeyBoardComponent();
int WinnerId = ComponentManager.Instance.CreateID();
kbc.keyBoardActions.Add(ActionsEnum.Up, Keys.Enter);
ComponentManager.Instance.AddComponentToEntity(WinnerId, winner);
ComponentManager.Instance.AddComponentToEntity(WinnerId, kbc);
ComponentManager.Instance.AddComponentToEntity(WinnerId, pos);
entitiesInState.Add(WinnerId);
HealthSystem hs = (HealthSystem)SystemManager.Instance.RetrieveSystem <IUpdate>("HealthSystem");
int id = hs.deathList.First();
hs.deathList.Clear();
AIComponent ai = new AIComponent();
ComponentManager.Instance.AddComponentToEntity(id, ai);
PlayerComponent player = ComponentManager.Instance.GetEntityComponent <PlayerComponent>(id);
entitiesInState.Add(id);
SpriteFont font2 = Game.Instance.GetContent <SpriteFont>("Fonts/Menufont");
DrawableTextComponent winningPlayer = new DrawableTextComponent(player.playerName, Color.Black, font2);
PositionComponent pos2 = new PositionComponent(new Vector2(Game.Instance.GraphicsDevice.Viewport.Width * 0.5f - ((float)font2.MeasureString(player.playerName).X * 0.5f), 50));
int textId2 = ComponentManager.Instance.CreateID();
ComponentManager.Instance.AddComponentToEntity(textId2, winningPlayer);
ComponentManager.Instance.AddComponentToEntity(textId2, pos2);
entitiesInState.Add(textId2);
SpriteFont font3 = Game.Instance.GetContent <SpriteFont>("Fonts/Menufont");
DrawableTextComponent text = new DrawableTextComponent("Press enter to return to Main menu", Color.Black, font3);
PositionComponent poss = new PositionComponent(new Vector2(Game.Instance.GraphicsDevice.Viewport.Width * 0.5f - ((float)font3.MeasureString("Press enter to return to Main menu").X * 0.5f), Game.Instance.GraphicsDevice.Viewport.Height - 100));
int textId = ComponentManager.Instance.CreateID();
ComponentManager.Instance.AddComponentToEntity(textId, text);
ComponentManager.Instance.AddComponentToEntity(textId, poss);
entitiesInState.Add(textId);
int se = ComponentManager.Instance.CreateID();
ComponentManager.Instance.AddComponentToEntity(se, new SoundEffectComponent("winner"));
entitiesInState.Add(se);
}
/// <summary>
/// onSceneCreated this function is called whenever the current gamestate is changed. This function should contain logic that
/// needs to be processed before the state is shown for the player. This could be enteties that's not able to be created pre-runtime.
/// </summary>
public void onSceneCreated()
{
ScrollingBackgroundSystem temp = (ScrollingBackgroundSystem)SystemManager.Instance.RetrieveSystem <IDraw>("ScrollingBackgroundSystem");
temp.active = true;
Dictionary <Vector2, String> menuList = new Dictionary <Vector2, string>();
int i = 0;
float yvar = this.y;
foreach (string a in menuItems)
{
menuList.Add(new Vector2(this.x, yvar - 200), menuItems[i]);
yvar += 50;
i++;
}
textcomp = new DrawableTextComponent(menuList, Game.Instance.GetContent <SpriteFont>("Fonts/MenuFont"), Color.Black);
index = 0;
int Id = ComponentManager.Instance.CreateID();
ComponentManager.Instance.AddComponentToEntity(Id, textcomp);
entitiesInState.Add(Id);
Texture2D arrowPix = Game.Instance.GetContent <Texture2D>("pic/arrow");
DrawableComponent arrow = new DrawableComponent(arrowPix, SpriteEffects.None);
PositionComponent arrowPos = new PositionComponent(new Vector2(this.x - 35, this.y - 200));
MovementComponent arrowMovement = new MovementComponent(new Vector2(x, y));
arrowId = ComponentManager.Instance.CreateID();
ComponentManager.Instance.AddComponentToEntity(arrowId, arrow);
ComponentManager.Instance.AddComponentToEntity(arrowId, arrowPos);
ComponentManager.Instance.AddComponentToEntity(arrowId, arrowMovement);
kbcArrow = new KeyBoardComponent();
kbcArrow.keyBoardActions.Add(ActionsEnum.Down, Keys.Down);
kbcArrow.keyBoardActions.Add(ActionsEnum.Up, Keys.Up);
kbcArrow.keyBoardActions.Add(ActionsEnum.Enter, Keys.Enter);
ComponentManager.Instance.AddComponentToEntity(arrowId, kbcArrow);
entitiesInState.Add(arrowId);
}
/// <summary>
/// onSceneUpdate this function handles the logic for the state which should be run durring the update partion of the game.
/// For example this could be to check for conditions to continue to the next state of the gameplay.
/// </summary>
public void onSceneUpdate()
{
Game game = Game.Instance;
KeyBoardComponent temp = ComponentManager.Instance.GetEntityComponent <KeyBoardComponent>(textId);
if (kbc1.state[ActionsEnum.Left] == ButtonStates.Pressed)
{
map = map + 1;
if (map > Map.Random)
{
map = Map.Whiteboard;
}
switch (map)
{
case Map.Whiteboard:
draw.text = "Whiteboard";
break;
case Map.Temp:
draw.text = "Temp";
break;
case Map.Random:
draw.text = "Random";
break;
}
}
if (temp.state[ActionsEnum.Enter] == ButtonStates.Pressed)
{
if (Players.Count != 0)
{
DrawableTextComponent temp54 = ComponentManager.Instance.GetEntityComponent <DrawableTextComponent>(newId);
temp54.visible = false;
Players.Clear();
SceneSystem.Instance.clearScene(entitiesInState);
SceneSystem.Instance.setCurrentScene(new PlayingScene());
}
}
KeyboardState tetet = Keyboard.GetState();
List <Keys> key = tetet.GetPressedKeys().ToList <Keys>();
if (key.Count != 0)
{
if (UnAvailableKeys != null && !UnAvailableKeys.Contains(key[0]))
{
if (Players.Count < 4)
{
Keys temo = key[0];
key.Clear();
Dictionary <int, Keys> Dir = new Dictionary <int, Keys>();
int tempId = ComponentManager.Instance.CreateID();
int count = Players.Count;
Players.Add(tempId);
DrawableComponent tempDraw = new DrawableComponent(Game.Instance.GetContent <Texture2D>("Pic/kanin1"), SpriteEffects.None);
PositionComponent temppos = new PositionComponent(new Vector2((Game.Instance.GraphicsDevice.Viewport.Width * 0.25f + 20f) * count, Game.Instance.GraphicsDevice.Viewport.Height * 0.5f));
KeyBoardComponent tempkey = new KeyBoardComponent();
PlayerComponent tempplay = new PlayerComponent();
tempkey.keyBoardActions.Add(ActionsEnum.Up, temo);
ComponentManager.Instance.AddComponentToEntity(tempId, tempDraw);
ComponentManager.Instance.AddComponentToEntity(tempId, temppos);
ComponentManager.Instance.AddComponentToEntity(tempId, tempkey);
ComponentManager.Instance.AddComponentToEntity(tempId, tempplay);
//Keys temp0;
//tempkey.keyBoardActions.TryGetValue(ActionsEnum.Up, out temp0);
//Console.WriteLine(temp0.ToString());
int textId = ComponentManager.Instance.CreateID();
DrawableTextComponent tempDrawtext = new DrawableTextComponent(temo.ToString(), Color.Black, Game.Instance.GetContent <SpriteFont>("Fonts/MenuFont"));
PositionComponent temptextPos = new PositionComponent(new Vector2((Game.Instance.GraphicsDevice.Viewport.Width * 0.25f + 20f) * count, Game.Instance.GraphicsDevice.Viewport.Height * 0.5f + 80f));
ComponentManager.Instance.AddComponentToEntity(textId, tempDrawtext);
ComponentManager.Instance.AddComponentToEntity(textId, temptextPos);
entitiesInState.Add(textId);
UnAvailableKeys.Add(temo);
}
}
else if (UnAvailableKeys.Contains(key[0]) && key[0] != Keys.Enter)
{
foreach (var a in Players)
{
KeyBoardComponent tempa = ComponentManager.Instance.GetEntityComponent <KeyBoardComponent>(a);
Keys key2;
tempa.keyBoardActions.TryGetValue(ActionsEnum.Up, out key2);
if (tempa != null && key2 != Keys.Enter)
{
if (tempa.state[ActionsEnum.Up] == ButtonStates.Pressed)
{
DrawableComponent tempura = ComponentManager.Instance.GetEntityComponent <DrawableComponent>(a);
Random rand = new Random();
tempura.colour = new Color(rand.Next(0, 256), rand.Next(0, 256), rand.Next(0, 256));
}
}
}
}
}
}
public void UpdateState(KeyBoardComponent keyboardComp)
{
keyboardComp.OldState = keyboardComp.NewState;
keyboardComp.NewState = Keyboard.GetState();
}
