public void SetUp()
{
_factory = new PlayersFactory();
var idGeneratorServiceStub = new Mock <IIdGenerator>();
idGeneratorServiceStub.Setup(id => id.NewGuid()).Returns(_factory.CreatedPlayerId);
var dateTimeServiceStub = new Mock <IDateTimeService>();
dateTimeServiceStub.Setup(dt => dt.UtcNow).Returns(new DateTime(2020, 12, 12));
var playersServiceStub = new Mock <IPlayersService>();
playersServiceStub.Setup(ps => ps.IsNicknameUniqueAsync(PlayersFactory.Player1NickName, null))
.Returns(Task.FromResult(false));
playersServiceStub.Setup(ps => ps.IsNicknameUniqueAsync(PlayersFactory.Player3NickName, null))
.Returns(Task.FromResult(true));
_sut = new AddPlayerCommandHandler(
Context,
new NullLogger <AddPlayerCommandHandler>(),
playersServiceStub.Object,
dateTimeServiceStub.Object,
idGeneratorServiceStub.Object);
}
public void Initialize(ICollection <PlayerInfo> inputs, GameRestriction restriction)
{
if (inputs.Count < restriction.MinPlayers ||
inputs.Count > restriction.MaxPlayers)
{
throw new ArgumentException("Players count does not meet minimum or maximum requirement", nameof(inputs));
}
Restriction = restriction;
_basket = new Basket(Restriction.MinWeight, Restriction.MaxWeight);
Players = new List <GenericPlayer <IGuessStrategy> >(inputs.Count);
_finilizerThread = new Thread(FinalizeProc);
_finalizeEvent = new ManualResetEvent(false);
_state = new GameState();
PlayersFactory.PreparePlayersType(restriction);
foreach (var input in inputs)
{
var newPlayer = PlayersFactory.GetPlayer(input.Name, input.PlayerType);
Players.Add(newPlayer);
newPlayer.OnNumberGuessed += OnNumberGuessedHandler;
}
// All cheaters are subscribed to all players guess events
foreach (var player in Players)
{
var cheaterPlayer = player as GenericCheaterPlayer;
cheaterPlayer?.SubscribeToOtherPlayersGuesses(Players);
}
_initialized = true;
}
private void Start()
{
float cameraX = Camera.main.orthographicSize * Screen.width / Screen.height;
float cameraY = Camera.main.orthographicSize;
cameraXBound = new Bounds(-cameraX, cameraX);
cameraYBound = new Bounds(-cameraY, cameraY);
ColdCry.Graphic.Graphics.LoadGraphics();
tower = TowerFactory.GetInstance();
Subscribe(tower);
innerMask = GameObject.Find("Mask").GetComponent <SpriteMask>();
outerMask = GameObject.Find("Mask_Platform").GetComponent <SpriteMask>();
// humanPlayer = PlayersFactory.GetHumanPlayer();
hairPlayer = PlayersFactory.GetHairPlayer();
hairPlayer.GetComponent <HairMove>().Tower = tower;
humanPlayer = GameObject.Find("PlayerMainPrefab");
// Vector3 firstPlatformPos = tower.GetLowestPlatform( 1 ).transform.position;
//humanPlayer.transform.position = firstPlatformPos + new Vector3( 0, 0.25f );
// Timers initialization
Instance.gameTimerId = TimerManager.Create(easyTimer, this);
}
public ChessGame(string id, string player1, string player2, string actualStateTx)
{
Type = GameTypes.ChessGame;
try
{
Id = new Guid(id);
}
catch (Exception ex)
{
log.Error("Chess Game - Wrong format of GUID. New one will be created!", ex);
Id = Guid.NewGuid();
}
ActualStateTxId = actualStateTx;
GameHistoryTxIds = new List <string>();
GameHistory = new List <ChessGameDto>();
Bets = new Dictionary <string, Bet>();
Players = new Dictionary <string, ChessPlayer>();
Player1Address = player1;
Player2Address = player2;
ChessPlayer pl1 = (ChessPlayer)PlayersFactory.GetPlayer(PlayerTypes.ChessPlayer, player1, string.Empty, string.Empty, string.Empty, 0.0);
pl1.FigureType = FigureTypes.White;
ChessPlayer pl2 = (ChessPlayer)PlayersFactory.GetPlayer(PlayerTypes.ChessPlayer, player2, string.Empty, string.Empty, string.Empty, 0.0);
pl2.FigureType = FigureTypes.Black;
Players.TryAdd(player1, pl1);
Players.TryAdd(player2, pl2);
}
private void Awake()
{
if (Instance != null)
{
throw new ColdCry.Exception.SingletonException("There can be only one object of PlayersFactory on scene!");
}
Instance = this;
}
public IHttpActionResult PlayWithComputer(int playerInput)
{
string gameOutcomeMessage = _rspGame.Play((Shapes)playerInput, PlayersFactory.PlayAsComputer());
return(Ok(new GameResultDto {
GameResultMessage = gameOutcomeMessage, Player1Score = _rspGame.GetPlayer1Score(), Player2Score = _rspGame.GetPlayer2Score()
}));
}
public GameStats(PlayersFactory PlayersFactory, BuildingsFactory BuildingsFactory, MobsFactory MobsFactory)
{
this.PlayersFactory = PlayersFactory;
this.BuildingsFactory = BuildingsFactory;
this.MobsFactory = MobsFactory;
_timeUpMoney = 3;
_timeUpWood = 2;
}
public void Second_Player_Have_Circle()
{
_diceMock.SetupSequence(x => x.Throw())
.Returns(2)
.Returns(1);
var players = new PlayersFactory(_player1, _player2).Create(_diceMock.Object);
players.SecondPlayer.MarkType.Should().Be(MarkTypeEnum.Circle);
}
public void First_Player_Have_Cross()
{
_diceMock.SetupSequence(x => x.Throw())
.Returns(2)
.Returns(1);
var players = new PlayersFactory(_player1, _player2).Create(_diceMock.Object);
players.FirstPlayer.MarkType.Should().Be(MarkTypeEnum.Cross);
}
// Use this for initialization
void Awake()
{
if (factoryInstance == null)
{
factoryInstance = this;
}
else
{
Destroy(this);
}
}
public void Player2_Be_First_Player_And_Player1_Be_Second_Player()
{
_diceMock.SetupSequence(x => x.Throw())
.Returns(1)
.Returns(2);
var players = new PlayersFactory(_player1, _player2).Create(_diceMock.Object);
players.FirstPlayer.Should()
.Be(_player2);
players.SecondPlayer.Should()
.Be(_player1);
}
public void SetUp()
{
_factory = new PlayersFactory();
var idGeneratorServiceMock = new Mock <IIdGenerator>();
idGeneratorServiceMock.Setup(id => id.NewGuid()).Returns(_factory.CreatedPlayerId);
var playersServiceMock = new Mock <IPlayersService>();
playersServiceMock.Setup(ps => ps.IsNicknameUniqueAsync(PlayersFactory.Player1NickName, null))
.Returns(Task.FromResult(false));
playersServiceMock.Setup(ps => ps.IsNicknameUniqueAsync(UpdateNickname, _factory.Player2Id))
.Returns(Task.FromResult(true));
_sut = new EditPlayerCommandHandler(
Context,
new NullLogger <EditPlayerCommandHandler>(),
playersServiceMock.Object);
}
protected override void Initialize(DemoConfiguration demoConfiguration)
{
base.Initialize(demoConfiguration);
_infoGamePanel = Helpers.LoadFromFile(RenderTarget2D, "gameInfo.png");
GameInterface = new GameInterface(RenderTarget2D, RESOLUTION, FactoryDWrite);
BuildingsFactory = new BuildingsFactory(RenderTarget2D, GameInterface);
_myCharacter = new Character(RenderTarget2D, BuildingsFactory, "Серафим");
PlayersFactory = new PlayersFactory(RenderTarget2D, GameInterface, _myCharacter);
MobsFactory = new MobsFactory(RenderTarget2D, GameInterface);
GameStats = new GameStats(PlayersFactory, BuildingsFactory, null);
GameStats.Money = 100;
GameStats.Woods = 100;
_myCharacter.eventCreateTower += (CommonTower tower) =>
{
GameStats.Money -= (int)tower.Id;
GameStats.Woods -= (int)tower.Id;
};
GameInterface.SetGameStats(GameStats);
_timeLastDraw = 0;
_timeLastUpdate = 0;
gameState = new GameState();
mainMenu = new MainMenu(RenderTarget2D, RESOLUTION);
SoundsManager.init();
AudioPlayer sound = new AudioPlayer("goobye.mp3");
sound.Volume = 0.04f;
sound.Play();
Connector.ConnectWithServer();
}
public GameMaster(GameType gameType, int size, int targetLength, Strategy[] computerStrategies, bool isComputerFirst)
{
this.GameType = gameType;
this.Size = size;
this.TargetLength = targetLength;
this.guiController = new GuiController();
List <List <Field> > allPossibilities;
do
{
this.Board = new Board(size);
allPossibilities = APFinder.FindAllSequences(Board, TargetLength, Size);
} while (allPossibilities.Count == 0);
StartPossibilitiesCount = allPossibilities.Count;
this.Players = PlayersFactory.CreatePlayers(gameType, computerStrategies, isComputerFirst);
this.playerAPPossibilities = new List <List <Field> > [Players.Length];
for (int i = 0; i < playerAPPossibilities.Length; i++)
{
playerAPPossibilities[i] = allPossibilities.ToList();
}
}
public void WhenWrongInputValuesAreProvidedThenCallingPlayShouldThrowInvalidInputException()
{
PlayersFactory.PlayAsHuman(100);
}
public IHttpActionResult PlayAsComputer() => Ok(PlayersFactory.PlayAsComputer());
public BattleMapParser(PlayersFactory playersFactory)
{
this.playersFactory = playersFactory;
}
public void WhenPlayAsComputerThenInputMustBeValid() => Assert.AreEqual(!((int)PlayersFactory.PlayAsComputer()).IsNotValidShape(), true);
private void CreatePlayers()
{
Players = PlayersFactory.GetPlayers(_numHumanPlayers);
}
public void SetUp()
{
_factory = new PlayersFactory();
_sut = new SearchPlayersQueryHandler(Context, NullLogger <SearchPlayersQueryHandler> .Instance, Mapper);
}
