public override void LoadContent()
{
_spriteBatch = Game.Services.GetService <SpriteBatch>();
_paddleFactory = new PaddleFactory(Game.Services);
_ballFactory = new BallFactory(Game.Services);
}
public void Sets_color()
{
PlayerSlot.Setup(p => p.Color).Returns(new Color(0.8f, 0.9f, 0.7f));
var paddle = PaddleFactory.Create(PlayerSlot.Object);
Assert.That(paddle.Color, Is.EqualTo(new Color(0.8f, 0.9f, 0.7f)));
}
public void CreatePaddleTest2()
{
Paddle p = PaddleFactory.CreatePaddle(PongRoyale_shared.PaddleType.Short, 10);
Type t = typeof(ShortPaddle);
Assert.IsTrue(p.Id == 10 && p.GetType().Equals(t));
}
public void Sets_spawn_position()
{
PlayerSlot.Setup(p => p.SpawnPosition).Returns(new Point(33, 44));
var paddle = PaddleFactory.Create(PlayerSlot.Object);
Assert.That(paddle.Position, Is.EqualTo(new Point(33, 44)));
}
public void InitLogic(Dictionary <byte, NetworkPlayer> players)
{
PlayerCount = players.Count;
Mediator = MainForm.Instance.Mediator;
DoAfterGameLoop = new List <Action>();
PlayerPaddles = new Dictionary <byte, Paddle>();
ArenaBalls = new Dictionary <byte, IBall>();
ArenaObjects = new Dictionary <byte, ArenaObject>();
float deltaAngle = SharedUtilities.PI * 2 / PlayerCount;
float angle = (-SharedUtilities.PI + deltaAngle) / 2f;
foreach (var player in players.Values)
{
PaddleType pType = player.PaddleType;
Paddle paddle = PaddleFactory.CreatePaddle(pType, player.Id);
paddle.SetPosition(SharedUtilities.RadToDeg(angle));
PlayerPaddles.Add(player.Id, paddle);
player.SetLife(paddle.Life);
if (Mediator.GetBool("IdMatches", player.Id))
{
LocalPaddle = paddle;
}
paddle.AddClampAngles(SharedUtilities.RadToDeg(angle - deltaAngle / 2), SharedUtilities.RadToDeg(angle + deltaAngle / 2));
angle += deltaAngle;
}
AlivePaddleCount = PlayerPaddles.Count;
StartingAlivePaddleCount = AlivePaddleCount;
UpdatableRoot = new UpdateComposite();
UpdatableRoot.Add(LocalPaddle.Id, LocalPaddle);
UpdateComponent spawnerBranch = new UpdateComposite();
spawnerBranch.Add(spawnerBranch.GetNextId(), new ObstacleSpawner(GameData.ObstacleSpawnerParams, ArenaObjectFactories.Values.ToArray()));
spawnerBranch.Add(spawnerBranch.GetNextId(), new PowerUpSpawner(GameData.PowerUpSpawnerParams, ArenaObjectFactories.Values.ToArray()));
UpdatableRoot.Add(UpdatableRoot.GetNextId(), spawnerBranch);
UpdateComponent objectBranch = new UpdateComposite();
ObjectBranchId = UpdatableRoot.GetNextId();
UpdatableRoot.Add(ObjectBranchId, objectBranch);
UpdateComponent ballBranch = new UpdateComposite();
BallBranchId = UpdatableRoot.GetNextId();
UpdatableRoot.Add(BallBranchId, ballBranch);
BallType bType = RoomSettings.Instance.BallType;
Ball ball = Ball.CreateBall(0, bType, ArenaDimensions.Center, GameData.DefaultBallSpeed, Vector2.RandomInUnitCircle(), GameData.DefaultBallSize);
ArenaBalls.Add(0, ball);
ballBranch.Add(0, ball);
IsInitted = true;
PauseGame(false);
}
public void OnCollisionTest()
{
Vector2 startingDir = new Vector2(1, 1);
Paddle paddle = PaddleFactory.CreatePaddle(PaddleType.Normal, (byte)0);
Ball testBall = Ball.CreateBall(0, BallType.Normal, new Vector2(225.5 + 200.5, 225.5), GameData.DefaultBallSpeed, startingDir, GameData.DefaultBallSize);
testBall.OnCollision(paddle, null);
Vector2 dirAfterCollision = testBall.Direction;
Assert.AreNotEqual(startingDir, dirAfterCollision);
}
public void CheckCollisionWithPaddlesTest()
{
Vector2 startingDir = new Vector2(1, 1);
Paddle paddle = PaddleFactory.CreatePaddle(PaddleType.Normal, (byte)0);
paddle.SetPosition(-5);
Ball testBall = Ball.CreateBall(0, BallType.Normal, new Vector2(225.5 + 200.5, 225.5), GameData.DefaultBallSpeed, startingDir, GameData.DefaultBallSize);
Dictionary <byte, Paddle> paddleDict = new Dictionary <byte, Paddle>();
paddleDict.Add(paddle.Id, paddle);
testBall.CheckCollisionWithPaddles(paddleDict);
Vector2 dirAfterCollision = testBall.Direction;
Assert.AreNotEqual(startingDir, dirAfterCollision);
}
public void CheckOutOfBoundsTest()
{
Paddle paddle = PaddleFactory.CreatePaddle(PaddleType.Normal, (byte)0);
Paddle paddle2 = PaddleFactory.CreatePaddle(PaddleType.Short, (byte)1);
Paddle paddle3 = PaddleFactory.CreatePaddle(PaddleType.Long, (byte)2);
paddle.SetPosition(-5);
paddle2.SetPosition(-10);
Ball testBall = Ball.CreateBall(0, BallType.Normal, new Vector2(225.5 + 200.5, 225.5), GameData.DefaultBallSpeed, Vector2.RandomInUnitCircle(), GameData.DefaultBallSize);
Dictionary <byte, Paddle> paddleDict = new Dictionary <byte, Paddle>();
paddleDict.Add(paddle.Id, paddle);
paddleDict.Add(paddle2.Id, paddle2);
paddleDict.Add(paddle3.Id, paddle3);
bool isOutOfBounds = testBall.CheckOutOfBounds(0, paddleDict, out byte paddleId);
Assert.IsTrue(isOutOfBounds);
}
private static void DoWithFlyweight(int n)
{
Stopwatch sw = new Stopwatch();
long before, after;
sw.Reset();
before = GC.GetTotalMemory(false);
sw.Start();
for (int i = 0; i < n; i++)
{
var type = (PaddleType)(i % 4);
PaddleFactory.CreatePaddle(type, 0);
}
sw.Stop();
after = GC.GetTotalMemory(false);
long usedWith = after - before;
long msWith = sw.ElapsedMilliseconds;
Debug.WriteLine($"{n}: With Flyweight: {msWith} milliseconds. {usedWith} bytes");
}
// Validates and alters the settings to fix any invalid values
private void SanitizeSettings(GameSettings settings)
{
GameSettings defaultSettings = GetDefaultSettings();
// Sanitize audio or use defaults
if (settings.Audio == null)
{
settings.Audio = defaultSettings.Audio.Clone();
}
else
{
settings.Audio.Volume = settings.Audio.Volume.Clamp(0, 100);
settings.Audio.SfxSet = settings.Audio.SfxSet.Clamp(1, AudioManager.SfxSetCount);
}
// Sanitize video or use defaults
if (settings.Video == null)
{
settings.Video = defaultSettings.Video.Clone();
}
else
{
GraphicsDeviceManager graphics = _graphics.Value;
bool isSupportedDisplayMode = graphics.GraphicsDevice.Adapter.SupportedDisplayModes.Any(
sdm => sdm.Width == (int)settings.Video.Resolution.X && sdm.Height == (int)settings.Video.Resolution.Y);
if (!isSupportedDisplayMode)
{
settings.Video.Resolution = SettingsConstants.DefaultResolution;
}
}
// Sanitize gameplay or use defaults
if (settings.Gameplay == null)
{
settings.Gameplay = defaultSettings.Gameplay.Clone();
}
else
{
settings.Gameplay.BallCount = settings.Gameplay.BallCount.Clamp(SettingsConstants.BallMinCount, SettingsConstants.BallMaxCount);
settings.Gameplay.GameSpeed = settings.Gameplay.GameSpeed.Clamp(SettingsConstants.GameSpeedMinValue, SettingsConstants.GameSpeedMaxValue);
settings.Gameplay.ScoreLimit = settings.Gameplay.ScoreLimit.Clamp(0, int.MaxValue);
settings.Gameplay.TimeLimit = settings.Gameplay.TimeLimit.Clamp(TimeSpan.Zero, TimeSpan.MaxValue);
if (!PaddleFactory.IsPaddleSupported(settings.Gameplay.LeftPaddleType))
{
settings.Gameplay.LeftPaddleType = defaultSettings.Gameplay.LeftPaddleType;
}
if (!PaddleFactory.IsPaddleSupported(settings.Gameplay.RightPaddleType))
{
settings.Gameplay.RightPaddleType = defaultSettings.Gameplay.RightPaddleType;
}
}
// Sanitize controls or use defaults
if (settings.Controls == null)
{
settings.Controls = defaultSettings.Controls.Clone();
}
else
{
if (settings.Controls.LeftPaddle == null)
{
settings.Controls.LeftPaddle = defaultSettings.Controls.LeftPaddle.Clone();
}
else
{
if (settings.Controls.LeftPaddle.MoveUp == Keys.None)
{
settings.Controls.LeftPaddle.MoveUp = defaultSettings.Controls.LeftPaddle.MoveUp;
}
if (settings.Controls.LeftPaddle.MoveDown == Keys.None)
{
settings.Controls.LeftPaddle.MoveDown = defaultSettings.Controls.LeftPaddle.MoveDown;
}
}
if (settings.Controls.RightPaddle == null)
{
settings.Controls.RightPaddle = defaultSettings.Controls.RightPaddle.Clone();
}
else
{
if (settings.Controls.RightPaddle.MoveUp == Keys.None)
{
settings.Controls.RightPaddle.MoveUp = defaultSettings.Controls.RightPaddle.MoveUp;
}
if (settings.Controls.RightPaddle.MoveDown == Keys.None)
{
settings.Controls.RightPaddle.MoveDown = defaultSettings.Controls.RightPaddle.MoveDown;
}
}
}
}
public void SetUp()
{
PaddleFactory = new PaddleFactory();
PlayerSlot = Stub <IPlayerSlot>();
}
// Sets up the options to show on the page
private void CreateGameplaySettingItems()
{
IGameplaySettings gameplaySettings = _settingsManager.Settings.Gameplay;
// Add player type selection
IList <Type> paddleTypes = PaddleFactory.GetSupportedTypes();
_playersItem = new MenuItem {
Name = StringResources.Players
};
MenuItemOption selectedPlayerOption = null;
// Add all available left+right player combinations, for example: "AI vs. Player"
foreach (Type leftPaddleType in paddleTypes)
{
foreach (Type rightPaddleType in paddleTypes)
{
string text = string.Format("{0} {1} {2}",
StringResources.ResourceManager.GetString("MenuText_Paddle_" + leftPaddleType.Name),
StringResources.versus,
StringResources.ResourceManager.GetString("MenuText_Paddle_" + rightPaddleType.Name));
Tuple <Type, Type> value = new Tuple <Type, Type>(leftPaddleType, rightPaddleType);
MenuItemOption option = new MenuItemOption {
Text = text, Value = value
};
_playersItem.Options.Add(option);
if (leftPaddleType == gameplaySettings.LeftPaddleType && rightPaddleType == gameplaySettings.RightPaddleType)
{
selectedPlayerOption = option;
}
}
}
if (selectedPlayerOption != null)
{
_playersItem.SelectedOption = selectedPlayerOption;
}
Items.Add(_playersItem);
// Add score limit item
_scoreLimitItem = new MenuItem {
Name = StringResources.ScoreLimit
};
_scoreLimitItem.Options.Add(new MenuItemOption {
Text = StringResources.None, Value = 0
});
foreach (int scoreLimit in new[] { 5, 10, 20, 30 })
{
string text = string.Format("{0} {1}", scoreLimit, StringResources.pts);
_scoreLimitItem.Options.Add(new MenuItemOption {
Text = text, Value = scoreLimit
});
}
_scoreLimitItem.SelectedValue = gameplaySettings.ScoreLimit;
Items.Add(_scoreLimitItem);
// Add time limit item
_timeLimitItem = new MenuItem {
Name = StringResources.TimeLimit
};
_timeLimitItem.Options.Add(new MenuItemOption {
Text = StringResources.None, Value = TimeSpan.Zero
});
foreach (int timeLimit in new[] { 5, 10, 20, 30 })
{
string text = string.Format("{0} {1}", timeLimit, StringResources.minutes);
_timeLimitItem.Options.Add(new MenuItemOption {
Text = text, Value = TimeSpan.FromMinutes(timeLimit)
});
}
_timeLimitItem.SelectedValue = gameplaySettings.TimeLimit;
Items.Add(_timeLimitItem);
// Add ball count item
_ballCountItem = new MenuItem {
Name = StringResources.Balls
};
for (int i = SettingsConstants.BallMinCount; i <= SettingsConstants.BallMaxCount; i++)
{
_ballCountItem.Options.Add(new MenuItemOption {
Text = i.ToString(), Value = i
});
}
_ballCountItem.SelectedValue = gameplaySettings.BallCount;
Items.Add(_ballCountItem);
// Add game speed item
_gameSpeedItem = new MenuItem {
Name = StringResources.GameSpeed
};
for (float i = SettingsConstants.GameSpeedMinValue; i <= SettingsConstants.GameSpeedMaxValue; i = (float)Math.Round(i + SettingsConstants.GameSpeedIncreaseFactor, 1))
{
string text = string.Format("{0}%", (int)Math.Round(i * 100F, 1));
_gameSpeedItem.Options.Add(new MenuItemOption {
Text = text, Value = i
});
}
_gameSpeedItem.Options.Add(new MenuItemOption {
Text = StringResources.AutoIncrease, Value = null
});
_gameSpeedItem.SelectedValue = gameplaySettings.AutoIncreaseSpeed ? null : (object)gameplaySettings.GameSpeed;
Items.Add(_gameSpeedItem);
}
public Player(RenderWindow rw)
{
this._points = 0;
this._paddle = PaddleFactory.CreatePaddle(rw, PaddleTypes.Player);
}
public Enemy(RenderWindow rw)
{
this._points = 0;
this._paddle = PaddleFactory.CreatePaddle(rw, PaddleTypes.Enemy);
}
