public Missile(float x, float y, PlayerShip player)
: base(Name.Missiles, SpriteEnum.Missile, Index.Index_Null, new Azul.Color(1f, 1f, 1f), new Azul.Color(0.0f, 1.0f, 0.0f), x, y)
{
this.sprite = new ProxySprite(SpriteEnum.Missile, Index.Index_Null, x, y);
this.playerInstance = player;
//this.goColor = new Azul.Color(1.0f, 1, 1);
}
public static PlayerShip create(PlayerShip.PlayerName name, float x = 512, float y = 100)
{
PlayerShip player = new PlayerShip(x, y);
Debug.Assert(player.Spr != null);
Instance.playerBatch.attach(player.Spr);
SpriteBatchManager.attachToGroup(player.ColObj.Spr, BatchGroup.BatchType.Collisions);
GameObjectManager.insert(player, Instance.treeRoot);
return player;
}
public static PlayerShip Instance(MatrixPosition position)
{
if (instance == null)
{
instance = new PlayerShip(position);
}
return(instance);
}
public static Missile create(Missile.MissileName m, float x, float y, PlayerShip player)
{
Missile node = new Missile(x, y, player);
GameObject missile = GameObjectManager.find(GameObject.Name.Missiles);
GameObjectManager.insert(node, missile);
Debug.Assert(node.Spr != null);
Instance.batch.attach(node.Spr);
SpriteBatchManager.attachToGroup(node.ColObj.Spr, BatchGroup.BatchType.Collisions);
return node;
}
// Konstruktor pobiera potrzebne dane
public ThreadShipMissileControl(iEnemyShip enemyShip, int xx, int yy, Canvas map, PlayerShip player)
{
this.player = player;
missileCounter = 1;
this.map = map;
x = xx;
y = yy;
this.enemyShip = enemyShip;
this.isMovingRigth = true;
}
public Game(int Width, int Height)
{
random = new Random();
lastSpawn = DateTime.Now;
score = 0;
diedShips = 0;
screen = new Screen(Width, Height);
bullets = new List <Bullet>();
enemyShips = new List <EnemyShip>();
playerShip = new PlayerShip(this, PlayerShip.PLAYER, (screen.Width / 2) - (PlayerShip.PLAYER.Length / 2), screen.Height - 1, PLAYER_LIVES);
}
private void initLivesBars()
{
for (int i = 0; i < PlayersList.Count; i++)
{
PlayerShip currentPlayer = PlayersList[i] as PlayerShip;
Vector2 currentLifeBarPosition = new Vector2(
(Game as BaseGame).GameWindowBounds.Width - currentPlayer.Bounds.Width,
(Game as BaseGame).GameWindowBounds.Y + 10 + (i * currentPlayer.Bounds.Height));
currentPlayer.PlayerLivesBar.Position = currentLifeBarPosition;
r_LivesBarList.Add(currentPlayer.PlayerLivesBar);
}
}
private void initScoreBars()
{
for (int i = 0; i < PlayersList.Count; i++)
{
PlayerShip currentPlayer = PlayersList[i] as PlayerShip;
currentPlayer.PlayerScore.ScoreStaticText = $"P{i+1} Score: ";
currentPlayer.PlayerScore.Value = 0;
currentPlayer.PlayerScore.ScoreTextBlockPosition =
m_InitScorebarPosition + new Vector2(0, i * k_YSpacingBetweenElements);
r_ScoreTextBlocksList.Add(currentPlayer.PlayerScore.r_ScoreTextBlock);
}
}
public static PlayerShip Instance()
{
lock (syncLock)
{
if (PlayerShip.instance == null)
{
PlayerShip.instance = new PlayerShip();
}
return(PlayerShip.instance);
}
}
public Game(Rectangle boundaries, Random random)
{
// O objeto Game precisa criar todos os demais objetos: os Invader, o PlayerShip, as
// listas de tiros e o objeto Stars. O formulário passa um objeto Random inicializado e
// sua própria estrutura DisplayRectangle para que game possa determinar os limites do
// campo de batalha, o que será usado para determinar se os tiros saíram da tela e se os
// invasores atingiram oas bordas.
_boundaries = boundaries;
_random = random;
_invaders = new List <Invader>();
_playerShip = new PlayerShip()
{
Location = new Point(boundaries.X, boundaries.Height - 40)
};
_playerShots = new List <Shot>();
_invaderShots = new List <Shot>();
_stars = new Stars(_boundaries, _random);
NextWave();
}
public List <GameEntity> InitializeEntities()
{
Score = 0;
//Ajout du joueur
p1 = null;
p1 = new PlayerShip(new Vecteur2D(gameSize.Width / 2, 550), 150, 2, GameSprites.Player, GameVariables.defaultShootSpeed);
List <GameEntity> ge = new List <GameEntity>();
ge.Add(p1);
Bunker b1 = new Bunker(new Vecteur2D(gameSize.Width * 0.7, 500), 0, 3, GameSprites.Bunker);
Bunker b2 = new Bunker(new Vecteur2D(gameSize.Width * 0.4, 500), 0, 3, GameSprites.Bunker);
Bunker b3 = new Bunker(new Vecteur2D(gameSize.Width * 0.1, 500), 0, 3, GameSprites.Bunker);
ge.Add(b1);
ge.Add(b2);
ge.Add(b3);
return(ge);
}
static void Initialize(Engine engine)
{
int startRow = 2;
int startCol = 2;
int endCol = WorldCols - 10;
int alienStartRow = startRow;
//for (int i = startCol + 4; i < endCol - 10; i++)
//{
// if (i == startCol + 15)
// {
// alienStartRow++;
// }
// if (i == startCol + 20)
// {
// alienStartRow--;
// }
// AlienShip alien = new AlienShip(new MatrixPosition(alienStartRow, i), new MatrixPosition(0, 1));
// engine.AddObject(alien);
//}
for (int i = startCol; i < endCol; i++)
{
AlienShip alien = new AlienShip(new MatrixPosition(alienStartRow, i), new MatrixPosition(0, 1));
HiveShip hiveAlien = new HiveShip(new MatrixPosition(alienStartRow + 1, i), new MatrixPosition(0, 1));
engine.AddObject(alien);
engine.AddObject(hiveAlien);
}
PlayerShip player = PlayerShip.Instance(new MatrixPosition(WorldRows - 2, WorldCols / 2));
engine.AddObject(player);
}
public void Spawn(GameMessage message)
{
int index = message.index;
int p = BitConverter.ToInt32(message.Message, 16);
if (entities.Keys.Contains<int>(index))
{
if (entities[index].typeID == -1)
{
entities.Remove(index);
}
else
{
return;
}
}
if (idCounter <= index)
idCounter = index + 1;
switch (p)
{
case 0:
var ship = new PlayerShip();
ship.HandleSpawnMessage(message);
AddEntity(index, ship);
break;
case 1:
var enemyShip = new EnemyShip();
enemyShip.HandleSpawnMessage(message);
AddEntity(index, enemyShip);
break;
case 2:
var bullet = new Bullet();
bullet.HandleSpawnMessage(message);
AddEntity(index, bullet);
break;
case 3:
var chunk = new BuildingChunk();
chunk.HandleSpawnMessage(message);
AddEntity(index, chunk);
break;
}
}
private void InitialiseShip(GameMessage message)
{
ship = entities[playerIndex] as PlayerShip;
clientControlled.Add(ship);
_infoStack.Push("Ship attached");
ship.CreationList = createdEntities;
}
void HandleMessage(GameMessage message)
{
if (message.DataType == GameState.DataTypeMetaInfo)
{
switch (message.index)
{
case IndexScoreUpdate:
score = BitConverter.ToInt32(message.Message, 0);
break;
case IndexHealthUpdate:
health = BitConverter.ToInt32(message.Message, 0);
break;
case IndexInitialisePlayerShip:
playerIndex = BitConverter.ToInt32(message.Message, 0);
_infoStack.Push(String.Format("Player Initialised, ship index: {0}", playerIndex));
if (entities.Keys.Contains<int>(playerIndex))
{
InitialiseShip(message);
}
else
Query(playerIndex);
break;
case IndexPlayerDeath:
StartRespawn();
break;
case IndexGameOver:
GameOver();
break;
}
}
else
{
if (message.DataType == DataTypeDespawnEntity)
{
_infoStack.Push("Despawn called for entity: " + message.index.ToString());
if (entities.Keys.Contains<int>(message.index))
{
if (entities[message.index] == ship)
ship = null;
RemoveEntity(entities[message.index]);
}
}
else if (message.DataType == DataTypeSpawnEntity)
{
if (message.index > idCounter)
idCounter = message.index + 1;
if (message.index == playerIndex)
{
RequestInitialisation();
}
HandleEntityUpdates(message, true);
}
else if (message.DataType == DataTypeReassignID)
{
if (!entities.Keys.Contains<int>(message.index))
return;
int newIndex = BitConverter.ToInt32(message.Message, 0);
_infoStack.Push(String.Format("Reassigning object {0}:{1} to ID {2}", entities[message.index].GetType().ToString(), message.index, newIndex));
if (!ReassignID(message.index, newIndex))
{
int nextIndex = GetNextID();
_messages.Add(ReassignIndexMessage(newIndex, nextIndex));
ReassignID(newIndex, nextIndex);
}
}
else
{
if (entities.Keys.Contains<int>(message.index))
{
//_infoStack.Push(String.Format("Entity {0} Update Received, DataType {1}", message.index, message.DataType));
if (clientControlled.Contains(entities[message.index]))
HandleEntityUpdates(message, false);
else
HandleEntityUpdates(message, false);
}
else
{
//_infoStack.Push(String.Format("Entity {0} not found, querying", message.index));
Query(message.index);
}
}
}
}
//iEnemyShip enemyShip;
// The constructor obtains the state information.
public FlyingBooster(Booster booster, PlayerShip player)
{
this.player = player;
this.booster = booster;
}
public static void PositionatePlayerShip(PlayerShip playership)
{
playership.Move(35, 20);
}
public void Start()
{
Console.CursorVisible = false;
PlayerShip playership = new PlayerShip();
Enemy[] enemiesType0 = CreateEnemies(24, '0');
Enemy[] enemiesType1 = CreateEnemies(24, '1');
Enemy[] enemiesType2 = CreateEnemies(12, '2');
List <Enemy> enemyList = new List <Enemy>();
enemyList.AddRange(enemiesType0);
enemyList.AddRange(enemiesType1);
enemyList.AddRange(enemiesType2);
World.AddEntity(playership);
for (int f = 0; f < enemyList.Count; f++)
{
World.AddEntity(enemyList[f]);
}
EntityPositioner.PositionatePlayerShip(playership);
EntityPositioner.PositionateEnemies(enemyList);
while (CheckVictory(enemyList))
{
//Graphics.ClearScreen();
if (RNG.RollForSpecialEnemy() == 1)
{
SpecialEnemy specialEnemy = new SpecialEnemy('>');
EntityPositioner.PositionateSpecialEnemy(specialEnemy);
World.AddEntity(specialEnemy);
}
Graphics.DrawEntities(World.entities);
ScoreBoard.ShowScore();
if (Input.UserPressedGameKey())
{
playership.ProcessInputAction(Input.GetInputAction());
}
//si DrawEntities lo pongo acá, se desarma todo, por qué?
for (int f = 0; f < World.entities.Count; f++)
{
World.entities[f].Update();
}
//si no pongo esto se duplica, por qué?
Console.SetCursorPosition(0, 0);
Thread.Sleep(10);
}
if (gameWon)
{
Graphics.ClearScreen();
Console.SetCursorPosition(35, 10);
Console.WriteLine("You win!");
Console.SetCursorPosition(32, 20);
Console.WriteLine("Final score: " + ScoreBoard.totalScore);
}
else
{
Graphics.ClearScreen();
Console.SetCursorPosition(35, 10);
Console.WriteLine("You lose");
Console.SetCursorPosition(32, 20);
Console.WriteLine("Final score: " + ScoreBoard.totalScore);
}
}
public override void visitPlayer(PlayerShip v, CollisionPair p)
{
p.collision(v, (GameObject)this.child);
}
public MainWindow()
{
playerlife = 2;
InitializeComponent();
Globals.playerMissiles = new List <PlayerMissile>();
PlayerShip statekgracza = PlayerShip.Instance();
Designs designs = new Designs();
highscores = new Dictionary <string, int>();
#region Adding Textures
Uri uri = new Uri(@"/Cruiser.PNG", UriKind.Relative);
designs.addDesign("Cruiser", uri);
uri = new Uri(@"/Destroyer.PNG", UriKind.Relative);
designs.addDesign("Destroyer", uri);
uri = new Uri(@"/PlayerShip.PNG", UriKind.Relative);
designs.addDesign("PlayerShip", uri);
uri = new Uri(@"/bullet.PNG", UriKind.Relative);
designs.addDesign("Missile1", uri);
uri = new Uri(@"/bullet.PNG", UriKind.Relative);
designs.addDesign("Missile2", uri);
uri = new Uri(@"/Booster.PNG", UriKind.Relative);
designs.addDesign("Booster", uri);
#endregion
#region Adding Commands
moveLeft = new MoveLeft(statekgracza);
moveRight = new MoveRight(statekgracza);
shoot = new Shoot(statekgracza);
exit = new Exit(this);
commands = new PlayerCommands();
#endregion
#region Adding Scores
highscores.Add("Kamil", 20);
highscores.Add("Piotr", 30);
highscores.Add("Rafał", 40);
#endregion
#region Initialize Window
main = this;
LifePoints = "5";
mapa = new Canvas();
lifecounter = LifeCounter;
pointscounter = PointCounter;
mapa.Width = 800;
mapa.Height = 600;
mapa.Background = new SolidColorBrush(Colors.White);
mapa.Focusable = true;
Grid.SetRow(mapa, 0);
Grid.SetRow(mapa, 0);
Grid.SetColumnSpan(mapa, 6);
Root.Children.Add(mapa);
statekgracza.CreateShipDynamically(mapa);
GameMaster gameMaster = new GameMaster(mapa, statekgracza);
Thread t = new Thread(new ThreadStart(gameMaster.RunGame));
t.Start();
#endregion
}
public override void shootMissile(PlayerShip player, float x, float y)
{
}
public override void visitPlayer(PlayerShip v, CollisionPair p)
{
p.notify(v, this);
}
public static void HandleCollisions(List <MovingObject> movingObjects, List <GameObject> staticObjects, List <MovingObject> alienShips, PlayerShip playerShip)
{
foreach (var obj in movingObjects)
{
//handle projectile collisions
if (obj is Projectile)
{
//If the owner of the projectile is the player, check if it hits an alien
//else check if the player is hit
if ((obj as Projectile).Owner == ProjectileOwner.Player)
{
foreach (var alien in alienShips)
{
if (obj.TopLeft.Row == alien.TopLeft.Row && obj.TopLeft.Col == alien.TopLeft.Col)
{
alien.RespondToCollision(CollisionType.Destruction);
obj.RespondToCollision(CollisionType.Destruction);
playerShip.IncreaseScore(1);
}
}
//player projecile colliding with a wall
foreach (var staticObj in staticObjects)
{
if (obj.TopLeft.Row == (staticObj.TopLeft.Row + 1) && obj.TopLeft.Col == staticObj.TopLeft.Col)
{
obj.RespondToCollision(CollisionType.Destruction);
}
}
}
else
{
if (obj.TopLeft.Row == playerShip.TopLeft.Row && obj.TopLeft.Col == playerShip.TopLeft.Col)
{
playerShip.RespondToCollision(CollisionType.Destruction);
obj.RespondToCollision(CollisionType.Destruction);
}
}
//alien projectile colliding with a wall
foreach (var staticObj in staticObjects)
{
if (!(staticObj is PlayerShip))
{
if (obj.TopLeft.Row == (staticObj.TopLeft.Row - 1) && obj.TopLeft.Col == staticObj.TopLeft.Col)
{
obj.RespondToCollision(CollisionType.Destruction);
}
}
}
}
}
foreach (var obj in movingObjects)
{
//ensure aliens are bouncing off the walls
if (obj is AlienShip)
{
if (CollidesWithWall(obj, staticObjects))
{
//if one alien hits a wall, change direction for all aliens
ChangeAliensDirection(movingObjects);
break;
}
}
if (obj is Gift)
{
if (obj is GiftPoints)
{
if (obj.TopLeft.Row == playerShip.TopLeft.Row && obj.TopLeft.Col == playerShip.TopLeft.Col)
{
playerShip.IncreaseScore(10);
obj.RespondToCollision(CollisionType.Destruction);
}
}
if (obj is GiftLife)
{
if (obj.TopLeft.Row == playerShip.TopLeft.Row && obj.TopLeft.Col == playerShip.TopLeft.Col)
{
playerShip.BonusLife();
obj.RespondToCollision(CollisionType.Destruction);
}
}
}
}
}
public abstract void shootMissile(PlayerShip player, float x, float y);
public override void shootMissile(PlayerShip player, float x, float y)
{
MissileFactory.create(Missile.MissileName.Missile, x, y, player);
SoundManager.playMissile();
player.request();
}
public MoveRight(PlayerShip ship)
{
_ship = ship;
}
public GameMaster(Canvas mapa, PlayerShip player)
{
this.player = player;
this.mapa = mapa;
}
private void HandleMessages()
{
GameMessage message;
foreach (KeyValuePair<int, MessageStack<GameMessage>> kvp in _messageStacks)
{
while (kvp.Value.Pop(out message))
{
if (message == null)
{
}
else
{
if (message.DataType == GameState.DataTypeEntityQuery)
{
//_infoStack.Push(String.Format("Entity {0} queried, sending info", message.index));
if (entities.Keys.Contains<int>(message.index))
{
_infoStack.Push(String.Format("Received query for entity {0}:{1}", message.index, entities[message.index].GetType().ToString()));
messages[kvp.Key].Add(entities[message.index].GetSpawnMessage());
}
else
{
_infoStack.Push(String.Format("Received query for entity {0}, does not exist, sending despawn message", message.index));
messages[kvp.Key].Add(GameState.DespawnMessage(message.index));
}
}
else if (message.DataType == GameState.DataTypeRequest)
{
switch (message.index)
{
case GameState.IndexInitialisePlayerShip:
InitialisePlayerShip(kvp.Key);
_infoStack.Push(String.Format("Initialisation request from client {0}, ship index {1}", kvp.Key, playerInfo[kvp.Key].EntityID));
break;
case GameState.IndexRespawnShip:
if (ships.Keys.Contains<int>(kvp.Key))
{
ships.Remove(kvp.Key);
}
PlayerShip ship = new PlayerShip();
int clientShipIndex = AddEntity(ship);
ship.Place(new Vector2(rand.Next(Game1.width - 100) + 50, Game1.height - 50.0f));
ship.color = shipColors[kvp.Key % 16];
ships.Add(kvp.Key, ship);
playerInfo[kvp.Key].EntityID = clientShipIndex;
InitialisePlayerShip(kvp.Key);
break;
}
}
else if (message.DataType == GameState.DataTypeReassignID)
{
if (!entities.Keys.Contains<int>(message.index))
return;
int newIndex = BitConverter.ToInt32(message.Message, 0);
_infoStack.Push(String.Format("Reassigning object {0}:{1} to ID {2}", entities[message.index].GetType().ToString(), message.index, newIndex));
if (!ReassignID(message.index, newIndex))
{
int nextIndex = GetNextID();
messages[kvp.Key].Add(ReassignIndexMessage(newIndex, nextIndex));
ReassignID(newIndex, nextIndex);
}
}
else
{
//_infoStack.Push(String.Format("Entity {0} Update Received, DataType {1}", message.index, message.DataType));
if (message.DataType == GameState.DataTypeSpawnEntity)
{
_infoStack.Push(String.Format("Spawning entity. index: {0}, typeID: {1}", message.index, BitConverter.ToInt32(message.Message, 16)));
if (message.index > idCounter)
idCounter = message.index + 1;
if (entities.Keys.Contains<int>(message.index))
{
int nextID = GetNextID();
messages[kvp.Key].Add(ReassignIndexMessage(message.index, nextID));
message.index = nextID;
Spawn(message);
}
else
{
HandleEntityUpdates(message, true);
}
}
else
{
if (message.Message != null)
HandleEntityUpdates(message, true);
}
}
}
}
}
}
public override void visitPlayer(PlayerShip v, CollisionPair p)
{
}
public override void visitPlayer(PlayerShip v, CollisionPair p)
{
base.visitPlayer(v, p);
}
public MoveLeft(PlayerShip ship)
{
_ship = ship;
}
public virtual void visitPlayer(PlayerShip v, CollisionPair p)
{
Debug.Assert(false, "Shouldn't have been called");
}
public Shoot(PlayerShip ship)
{
_ship = ship;
}
public void ClientConnect(int clientNumber, GameMessage message)
{
try
{
playerInfo.Add(clientNumber, new PlayerInfo(clientNumber));
_messageStacks.Add(clientNumber, new MessageStack<GameMessage>(500));
messages.Add(clientNumber, new List<GameMessage>());
_infoStack.Push(String.Format("Client {0} connected from address {1}", clientNumber, _server.Connections[clientNumber].Socket.RemoteEndPoint));
PlayerShip ship = new PlayerShip();
int clientShipIndex = AddEntity(ship);
ship.Place(new Vector2(rand.Next(Game1.width - 100) + 50.0f, Game1.height - 50.0f));
ship.color = shipColors[clientNumber % 16];
ships.Add(clientNumber, ship);
foreach (IEntity entity in entities.Values)
{
if (entity != ship)
{
messages[clientNumber].Add(entity.GetSpawnMessage());
}
}
foreach (KeyValuePair<int, List<GameMessage>> kvp in messages)
{
kvp.Value.Add(ship.GetSpawnMessage());
}
GameMessage initMessage = new GameMessage();
initMessage.DataType = GameState.DataTypeMetaInfo;
initMessage.index = GameState.IndexInitialisePlayerShip;
byte[] arr = new byte[7];
BitConverter.GetBytes(clientShipIndex).CopyTo(arr, 0);
arr[4] = shipColors[clientNumber % 16].R;
arr[5] = shipColors[clientNumber % 16].G;
arr[6] = shipColors[clientNumber % 16].B;
initMessage.SetMessage(arr);
messages[clientNumber].Add(initMessage);
playerInfo[clientNumber].EntityID = clientShipIndex;
lastMessage.Add(clientNumber, lastTime);
}
catch (Exception e)
{
_errorStack.Push(e.Message);
}
}
