public void Spawn(Vector2f position, Vector2f direction, float speed, RectangleObject rectangleObject)
{
this.Position = position;
this.Direction = direction;
this.Speed = speed;
this.RectangleObject = rectangleObject;
}
public List <RectangleObject> LoadLevel(string levelName)
{
document.Load("LevelData.xml");
XmlNode level = document.SelectSingleNode("//level/" + levelName);
if (level == null)
{
throw new FileNotFoundException();
}
else
{
List <RectangleObject> bricks = new List <RectangleObject>();
foreach (XmlNode node in level.ChildNodes)
{
Vector2D size = new Vector2D(Double.Parse(node.Attributes.GetNamedItem("SizeX").Value), Double.Parse(node.Attributes.GetNamedItem("SizeY").Value));
Vector2D position = new Vector2D(Double.Parse(node.Attributes.GetNamedItem("PositionX").Value), Double.Parse(node.Attributes.GetNamedItem("PositionY").Value));
RectangleObject brick = new RectangleObject(size, int.Parse(node.Attributes.GetNamedItem("Life").Value));
brick.Rectangle.Position = position;
brick.Life = int.Parse(node.Attributes.GetNamedItem("Life").Value);
brick.ID = int.Parse(node.Attributes.GetNamedItem("ID").Value);
//brick.Rectangle.FillColor = Color.White;
bricks.Add(brick);
}
return(bricks);
}
}
public Ai(RectangleObject rectangleObject, CircleObject circleObject, Vector2f windowSize, Difficulty difficulty)
{
_rectangleObject = rectangleObject;
_circleObject = circleObject;
_windowSize = windowSize;
_nextPosition = windowSize.Y / 2;
_difficulty = difficulty;
}
private void RectangleMovement(RectangleObject rs, Keyboard.Key left, Keyboard.Key right, double elapsedTime)
{
if (Keyboard.IsKeyPressed(left))
{
rs.RectangleMovementLeft(elapsedTime);
}
else if (Keyboard.IsKeyPressed(right))
{
rs.RectangleMovementRight(elapsedTime, Program.windowSize.X);
}
}
private void RectangleMovement(RectangleObject rs, Keyboard.Key up, Keyboard.Key down, double elapsedTime)
{
if (Keyboard.IsKeyPressed(up))
{
rs.RectangleMovementUp(elapsedTime);
}
else if (Keyboard.IsKeyPressed(down))
{
rs.RectangleMovementDown(elapsedTime, _windowSize.Y);
}
}
public override void Update(RectangleObject player, double elapsedTime)
{
if (!_isBig)
{
_originalRectangleSizeX = player.Rectangle.Size.X;
player.Rectangle.Size = new Vector2D(_bigRectangleSizeX, player.Rectangle.Size.Y);
player.Rectangle.Origin = new Vector2D(_bigRectangleSizeX / 2, player.Rectangle.Origin.Y);
_isBig = true;
}
}
private void Initialise(Ai.Difficulty difficultyLeft, Ai.Difficulty difficultyRight)
{
_window = new RenderWindow(new VideoMode((uint)_windowSize.X, (uint)_windowSize.Y), "PONG");
_window.SetActive();
_circlePosition = new Vector2f(_windowSize.X / 2, _windowSize.Y / 2);
_rectangleObject1 = new RectangleObject(new Vector2f(_rectangleSizeX, _rectangleSizeY));
_rectangleObject1.FillColor = Color.White;
_rectangleObject1.Attach(new SoundObserver(_soundManager));
_rectangleObject2 = new RectangleObject(new Vector2f(_rectangleSizeX, _rectangleSizeY));
_rectangleObject2.FillColor = Color.White;
_rectangleObject2.Attach(new SoundObserver(_soundManager));
_circleObject = new CircleObject(_circleSize);
_circleObject.Attach(new SoundObserver(_soundManager));
_circleObject.FillColor = Color.White;
_prefabPowerUps.Add(new SpeedDown(_circleObject));
_prefabPowerUps.Add(new BiggerRectangleObject(_circleObject));
_prefabPowerUps.Add(new BiggerRectangleObject(_circleObject));
_prefabPowerUps.Add(new Disco(_circleObject));
_prefabPowerUps.Add(new Disco(_circleObject));
_circleObject.Position = _circlePosition;
_circleObject.Update(0);
_rectangleObject1.Position = new Vector2f(_rectanglePositionX, _windowSize.Y / 2);
_rectangleObject2.Position = new Vector2f(_windowSize.X - _rectanglePositionX, _windowSize.Y / 2);
_scoreLeftText = new Text(_scoreLeft.ToString(), _font, _characterSizeScore);
_scoreLeftText.Position = new Vector2f(_windowSize.X / 2 - _scoreLeftText.GetGlobalBounds().Width - 100, 100);
_scoreRightText = new Text(_scoreRight.ToString(), _font, _characterSizeScore);
_scoreRightText.Position = new Vector2f(_windowSize.X / 2 + 100, 100);
_middleLine = new Text("I", _font);
_middleLine.Position = new Vector2f(_windowSize.X / 2 - _middleLine.GetGlobalBounds().Width / 2, 0);
while (_middleLine.GetGlobalBounds().Height < _windowSize.Y)
{
_middleLine.DisplayedString += "\n\nI";
}
_aiLeft = new Ai(_rectangleObject1, _circleObject, _windowSize, difficultyLeft);
_aiRight = new Ai(_rectangleObject2, _circleObject, _windowSize, difficultyRight);
_nextPowerUps.Add(Random(0, _prefabPowerUps.Count));
}
public override void Update(RectangleObject player, double elapsedTime)
{
if (!_isSpeedDown)
{
_circleObject.AdditionalSpeed = _circleObject.AdditionalSpeed / 2 - _circleObject.Speed / 2;
if (_circleObject.AdditionalSpeed < 0)
{
_circleObject.AdditionalSpeed = 0;
}
_isSpeedDown = true;
}
}
public void AddState(RectangleObject player, State state, double duration)
{
_stateActive[_states.FindIndex(x => x.ID == state.ID), _players.FindIndex(x => x.GetHashCode() == player.GetHashCode())] = duration;
/*for (int i = 0; i < _states.Count; i++)
* {
* for (int j = 0; j < _players.Count; j++)
* {
* if (state.ID == _states[i].ID && player.GetHashCode() == _players[j].GetHashCode())
* {
* _stateActive[i, j] = duration;
* return;
* }
* }
* }*/
}
private void ReInitialisePlayerAndAI(Ai.Difficulty difficultyLeft, Ai.Difficulty difficultyRight)
{
_firstRectanglePositionY = Program.windowSize.Y - _rectangleSizeY / 2 - 50;
_secondRectanglePositionY = _firstRectanglePositionY + _rectangleSizeY * 2;
if (difficultyLeft != Ai.Difficulty.None)
{
_player1 = new RectangleObject(new Vector2D(_rectangleSizeX, _rectangleSizeY), 0);
_player1.Rectangle.Position = new Vector2D(Program.windowSize.X / 2, _firstRectanglePositionY);
}
else
{
_player1 = null;
}
if (difficultyRight != Ai.Difficulty.None)
{
_player2 = new RectangleObject(new Vector2D(_rectangleSizeX, _rectangleSizeY), 3);
if (_player1 == null)
{
_player2.Rectangle.Position = new Vector2D(Program.windowSize.X / 2, _firstRectanglePositionY);
}
else
{
_player2.Rectangle.Position = new Vector2D(Program.windowSize.X / 2, _secondRectanglePositionY);
}
}
else
{
_player2 = null;
}
_aiLeft = new Ai(_player1, _circleObject, Program.windowSize, difficultyLeft);
_aiRight = new Ai(_player2, _circleObject, Program.windowSize, difficultyRight);
_players.Clear();
_players.Add(_player1);
_players.Add(_player2);
}
public override void Finish(RectangleObject player)
{
_circleObject.Circle.FillColor = Color.White;
}
public override void Update(RectangleObject player, double elapsedTime)
{
_circleObject.Circle.FillColor = RandomColor(elapsedTime);
}
public override void Finish(RectangleObject player)
{
_isSpeedDown = false;
}
private void Update(double elapsedTime)
{
int lifeImagesCount = _lifeImages.Count;
for (int i = lifeImagesCount; i < Program.lifes; i++)
{
Text lifeImage = new Text("|", _font, (uint)_lifeImagesSize);
MainMenu.SetTextOriginToMiddle(lifeImage);
lifeImage.Position = _lifeImagesPosition + (_lifeImagesDistance + Vector2D.Right() * lifeImage.GetGlobalBounds().Width) * i + (Vector2D.Right() * lifeImage.GetGlobalBounds().Width) / 2;
_lifeImages.Add(lifeImage);
}
bool rectangleObject1Collided = false;
bool rectangleObject2Collided = false;
if (_player1 != null)
{
rectangleObject1Collided = _player1.PongCollision(_circleObject);
}
if (_player2 != null)
{
rectangleObject2Collided = _player2.PongCollision(_circleObject);
}
int numberOfBrickCollisions = 0;
List <RectangleObject> collidedBricks = new List <RectangleObject>();
Vector2D oldCircleDirection = _circleObject.Direction;
foreach (RectangleObject brick in _bricks)
{
if (brick.NewReflectionCollision(_circleObject, _animationManager))
{
brick.Life--;
if (brick.Life >= 0)
{
brick.ChangeToPrefab(RectangleObject.rectangleShapePrefabs[brick.Life]);
}
numberOfBrickCollisions++;
collidedBricks.Add(brick);
Vector2D originalPosition = Vector2D.Zero();
foreach (RectangleObject brickPrefab in _bricksPrefab)
{
if (brickPrefab.ID == brick.ID)
{
originalPosition = brickPrefab.Rectangle.Position;
}
}
_animationManager.RemoveAnimationsToObject(brick.Rectangle);
Vector2D animationPosition = brick.Rectangle.Position + oldCircleDirection * 5;
_animationManager.AddAnimation(new Animation(brick.Rectangle.Position, new Transformable[] { brick.Rectangle }, 200, 0, animationPosition));
_animationManager.AddAnimation(new Animation(animationPosition, new Transformable[] { brick.Rectangle }, 200, 200, originalPosition));
}
}
if (numberOfBrickCollisions > 0)
{
if (_player1 != null && _player2 != null)
{
if (_lastHit.Equals(_player1))
{
_score1 += numberOfBrickCollisions;
}
if (_lastHit.Equals(_player2))
{
_score2 += numberOfBrickCollisions;
}
}
else
{
if (_player1 != null)
{
_score1++;
}
if (_player2 != null)
{
_score2++;
}
}
foreach (RectangleObject brick in collidedBricks)
{
if (brick.Life < 0)
{
if (_random.Next(0, _probabilityOfPowerUp) == 0)
{
PowerUp newPowerUp = _prefabPowerUps[_random.Next(0, _prefabPowerUps.Count)].Clone();
double speed = 0.3f;
newPowerUp.Spawn(new Vector2D(brick.Rectangle.Position.X, brick.Rectangle.Position.Y), new Vector2D(0, 1), speed);
_powerUps.Add(newPowerUp);
}
_bricks.Remove(brick);
}
}
}
if (_bricks.Count == 0 && _loadedLevel == _persistenceManager.LoadLevelList()[_persistenceManager.LoadLevelList().Count - 1])
{
Program.windowState = Program.WindowState.GameOver;
}
else if (_bricks.Count == 0 && (rectangleObject1Collided || rectangleObject2Collided))
{
_loadedLevel = _persistenceManager.LoadLevelList()[_levelID++];
_bricks = _persistenceManager.LoadLevel(_loadedLevel);
_bricksPrefab = _persistenceManager.LoadLevel(_loadedLevel);
for (int i = 0; i < _bricks.Count; i++)
{
_bricks[i].Rectangle.Position += _brickPosition;
_bricksPrefab[i].Rectangle.Position += _brickPosition;
}
}
List <PowerUp> usedPowerUps = new List <PowerUp>();
foreach (PowerUp powerUp in _powerUps)
{
powerUp.Update(elapsedTime);
RectangleObject collidedRectangle = null;
if (_player1 != null)
{
if (_player1.PowerUpCollision(powerUp))
{
collidedRectangle = _player1;
}
}
if (_player2 != null)
{
if (_player2.PowerUpCollision(powerUp))
{
collidedRectangle = _player2;
}
}
if (collidedRectangle != null)
{
powerUp.ExecutePowerUp(collidedRectangle);
usedPowerUps.Add(powerUp);
}
else if (powerUp.Position.X < 0 || powerUp.Position.X > Program.windowSize.X)
{
usedPowerUps.Add(powerUp);
}
}
foreach (PowerUp powerUp in usedPowerUps)
{
_powerUps.Remove(powerUp);
}
usedPowerUps.Clear();
_stateManager.Update(elapsedTime);
_circleObject.Update(elapsedTime);
bool resetCircleObject = false;
if (_circleObject.CheckOutOfField((int)Program.windowSize.X, (int)Program.windowSize.Y))
{
Program.lifes--;
_lifeImages.RemoveAt(_lifeImages.Count - 1);
if (Program.lifes <= 0)
{
Program.windowState = Program.WindowState.GameOver;
}
resetCircleObject = true;
_circleObject.ResetPosition(_circlePosition);
_circleObject.Direction = new Vector2D(-_circleObject.Direction.X, _circleObject.Direction.Y);
_circleObject.Update(0);
_powerUps.Clear();
}
if ((rectangleObject1Collided || rectangleObject2Collided) && _player1 != null && _player2 != null)
{
/*Vector2D savedPos = _player1.Rectangle.Position;
* _player1.Rectangle.Position = _player2.Rectangle.Position;
* _player2.Rectangle.Position = savedPos;*/
_animationManager.AddAnimation(new Animation(_player1.Rectangle.Position, new Transformable[] { _player2.Rectangle }, 100, 0, false));
_animationManager.AddAnimation(new Animation(_player2.Rectangle.Position, new Transformable[] { _player1.Rectangle }, 100, 0, false));
if (rectangleObject1Collided)
{
_lastHit = _player1;
}
if (rectangleObject2Collided)
{
_lastHit = _player2;
}
}
_aiLeft.Update(elapsedTime, rectangleObject2Collided, rectangleObject1Collided, resetCircleObject);
_aiRight.Update(elapsedTime, rectangleObject1Collided, rectangleObject2Collided, resetCircleObject);
if (_score1 < 10)
{
_scoreLeftText.DisplayedString = "0" + _score1.ToString();
}
else
{
_scoreLeftText.DisplayedString = _score1.ToString();
}
if (_score2 < 10)
{
_scoreRightText.DisplayedString = "0" + _score2.ToString();
}
else
{
_scoreRightText.DisplayedString = _score2.ToString();
}
_animationManager.Update(elapsedTime);
}
protected void Execute(RectangleObject rectangleObject)
{
_stateManager.AddState(rectangleObject, _state, _state.Duration);
}
public abstract void Update(RectangleObject player, double elapsedTime);
public override void Finish(RectangleObject player)
{
player.Rectangle.Size = new Vector2D(_originalRectangleSizeX, player.Rectangle.Size.Y);
player.Rectangle.Origin = new Vector2D(_originalRectangleSizeX / 2, player.Rectangle.Origin.Y);
_isBig = false;
}
public abstract void Finish(RectangleObject player);
public void ExecutePowerUp(RectangleObject rectangleObject)
{
this.RectangleObject = rectangleObject;
Execute(rectangleObject);
}
