private void ChooseColors()
{
string input;
do
{
Console.WriteLine("Player 1 choose your color........(b = black / w = white):");
input = Console.ReadLine();
} while(ColorCodeNotValid(input));
_player1 = _playerFactory.Create(_boardMoveService, GetColor(input));
_player2 = _playerFactory.Create(_boardMoveService, GetColor(input, true));
_currentPlayer = _player1;
}
private void NameMethod(IPlayerFactory playerFactory)
{
IPlayer player = playerFactory.Create(6, TypePlayer.Mag);
IPlayer player3 = Player.Factory.Create(6, TypePlayer.Player);
Task.Factory.StartNew(Action);
}
public PlayerInitialization(IPlayerFactory factory)
{
_player = factory.Create();
Transform = _player.transform;
SpriteRenderer = _player.GetComponentInChildren <SpriteRenderer>();
Collider = _player.GetOrAddComponent <Collider2D>();
Rigidbody = _player.GetOrAddComponent <Rigidbody2D>();
}
private void CreatePlayer(PlayerData playerData)
{
var clone = _playerFactory.Create(playerData);
clone.transform.position = new Vector3(Random.Range(-2, 2), 0, Random.Range(-2, 2));
clone.transform.rotation = Quaternion.identity;
_playerList.Add(clone);
}
private async UniTaskVoid RoundStartTask(GamePlaySettingData gamePlaySettingData)
{
Debug.Log("なんかいっぱい準備する");
// なんかスタートする
var players = _playerProvider.GetCurrentPlayers();
var spawnPoints = new Queue <Transform>();
_stageMapSetting.GetPlayerSpawnPoints().ForEach(x => spawnPoints.Enqueue(x));
players.ForEach(x => _stageScoreManager.AddPlayer(x));
players.ForEach(x =>
{
var player = _playerFactory.Create(x);
var spawnPoint = spawnPoints.Dequeue();
player.transform.position = spawnPoint.position;
player.transform.rotation = spawnPoint.rotation;
var basket = _basketFactory.Create();
player.SetBasket(basket);
basket.transform.localPosition = Vector3.zero;
});
// debug用
var gameObject = new GameObject();
var scoreView = gameObject.AddComponent <DebugPlayerScoreView>();
scoreView.Setup(_scoreManager);
var correctedCount = 0;
while (correctedCount < _currentGamePlaySetting.CorrectCount)
{
correctedCount++;
// 次の便まで待つ
await UniTask.Delay(TimeSpan.FromSeconds(_currentGamePlaySetting.CorrectInterval));
// 便がくる
// 回収装置が満タンになるまで待つ
// 回収装置が退場する
// ポイントが精算される。
}
if (_cancellationTokenSource.IsCancellationRequested)
{
return;
}
// 終了～～～～～
SceneManager.LoadScene("ResultScene");
}
public List <Player> GetTeam()
{
var list = new List <Player>();
for (int i = 0; i < 10; i++)
{
list.Add(_playerFactory.Create());
}
return(list);
}
public void TestCreatePlayers()
{
List <Player> players = new List <Player>();
for (int i = 0; i < 3; i++)
{
players.Add(playerFactory.Create(PlayerTypes.Player, ControlTypes.Player));
}
Assert.IsNotNull(players);
//Assert.IsTrue(players.Count == 3);
}
private void _Create_Players()
{
string name;
string symbol;
//Création des players
_displayer.Show("Prénom du joueur 1 : ");
name = _reader.Read();
do
{
_displayer.Show("Symbole du joueur 1 : ");
symbol = _reader.Read();
if (symbol != null)
{
symbol = symbol.ToUpper();
}
} while(Array.IndexOf(choices, symbol) == -1);
_game.Player1 = _player_factory.Create(name, symbol);
_displayer.Show("Prénom du joueur 2 : ");
name = _reader.Read();
if (_game.Player1.Symbol == choices [0])
{
symbol = choices [1];
}
else
{
symbol = choices [0];
}
_displayer.Show(name + " votre symbole est: " + symbol);
_displayer.Show("\nAppuyez sur une touche pour continuer", ConsoleColor.Yellow);
_reader.Read();
_game.Player2 = _player_factory.Create(name, symbol);
}
public IPlayerCollection Create()
{
this.textInterface.Write($"Enter the number of players, between {this.playerSettings.MinimumPlayerCount} and {this.playerSettings.MaximumPlayerCount}: ");
var playerCount = this.textInterface.ReadIntegerInRange(
this.playerSettings.MinimumPlayerCount,
this.playerSettings.MaximumPlayerCount);
this.textInterface.WriteLine();
var nameEachPlayer = this.textInterface.GetYesOrNoResponse("Enter player names?");
var playerCollection = new PlayerCollection()
{
Capacity = playerCount
};
if (nameEachPlayer)
{
this.textInterface.WriteLine();
this.textInterface.WriteLine();
this.textInterface.WriteLine($"Enter a unique name for each player, between {this.playerSettings.MinimumNameLength} and {this.playerSettings.MaximumNameLength} characters.");
for (int i = 0; i < playerCount; i++)
{
this.textInterface.Write($"Player {i + 1}: ");
while (true)
{
var line = this.textInterface.ReadLine(this.playerSettings.MaximumNameLength, this.playerSettings.MinimumNameLength);
if (String.IsNullOrWhiteSpace(line) || playerCollection.FirstOrDefault(player => String.Equals(player.Name, line)) != null)
{
this.textInterface.WriteLine("Error: Player name must be unique and contain at least one character.");
this.textInterface.Write($"Enter a unique name for Player {i + 1}: ");
}
else
{
playerCollection.Add(this.playerFactory.Create(line));
break;
}
}
}
}
else
{
var players = Enumerable.Range(1, playerCount)
.Select(index => playerFactory.Create("Player " + index));
playerCollection.AddRange(players);
}
return(playerCollection);
}
public void Join(IPlayerSlot playerSlot)
{
if (playerSlot.Ready)
{
return;
}
var wasStarted = HasStarted;
playerSlot.Join(playerFactory.Create(playerSlot));
if (!wasStarted && HasStarted)
{
foreach (var player in Players)
{
playerInitializer.Initialize(player);
}
Ball = ballFactory.Create(new Point(Width / 2, Height / 2));
ballInitializer.Initialize(Ball);
}
}
public Game(
ICardDeckFactory cardDeckFactory,
IPlayerFactory playerFactory,
IActionStepper actionStepper,
int playerCount)
{
CardDeck = cardDeckFactory.CreateDeck(this);
var players = new List <IPlayer>();
for (var i = 0; i < playerCount; i++)
{
players.Add(playerFactory.Create(this));
}
Players = players.ToArray();
_actionStepper = actionStepper;
Step();
}
public async void StartGame(GameType type, string level = "")
{
logger.Info("Game started");
try
{
if (MoveReceived == null)
{
logger?.Error("InvalidOperationException: " + StringResources.TheGameCanNotBeStartedBecauseOfMoveReceivedIsNull());
throw new InvalidOperationException(
StringResources.TheGameCanNotBeStartedBecauseOfMoveReceivedIsNull());
}
var players = new List <IPlayer>();
switch (type)
{
case GameType.SinglePlayer:
players.Add(playerFactory.Create(PlayerType.Human, 1));
players.Add(playerFactory.Create(PlayerType.Bot, 2));
break;
case GameType.TwoPlayers:
players.Add(playerFactory.Create(PlayerType.Human, 0));
players.Add(playerFactory.Create(PlayerType.Human, 0));
break;
case GameType.Online:
if (proxy == null)
{
logger?.Error("InvalidOperationException: " +
StringResources.TheGameCanNotBeStartedBecauseOfProxyIsNull());
throw new InvalidOperationException(
StringResources.TheGameCanNotBeStartedBecauseOfProxyIsNull());
}
isOnlineGameRequestCancelled = false;
if (!isRequestingOnlineGame)
{
players = await Task.Factory.StartNew(RequestOnlinePlayer).Result;
}
if (players.Count != 2)
{
return;
}
if (players[0].Type.Equals(PlayerType.OnlinePlayer))
{
GetFirstMove(myOnlineId);
}
break;
case GameType.Bluetooth:
break;
case GameType.Wifi:
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
CurrentGame = gameFactory.Create(players, level);
}
catch (TimeoutException ex)
{
string exceptionMessage = StringResources.TimeoutExceptionOccured("StartGame", ex.Message);
logger?.Error(exceptionMessage);
throw new GameServerException(exceptionMessage, ex);
}
catch (FaultException ex)
{
string exceptionMessage = StringResources.ExceptionOccuredOnServerSide("StartGame", ex.Message);
logger?.Error(exceptionMessage);
throw new GameServerException(exceptionMessage, ex);
}
catch (CommunicationException ex)
{
string exceptionMessage = StringResources.CommunicationProblemOccured("StartGame", ex.Message);
logger?.Error(exceptionMessage);
throw new GameServerException(exceptionMessage, ex);
}
}
/// <summary>
/// Process skeleton data associated with an AllFramesReady event.
/// </summary>
/// <param name="skeletons">
/// Skeletons to process.
/// </param>
/// <param name="e">
/// Event arguments.
/// </param>
private void ProcessSkeletons(Skeleton[] skeletons, AllFramesReadyEventArgs e)
{
IEnumerable <Skeleton> filteredSkeletons = skeletons;
if (null != SkeletonFilter)
{
filteredSkeletons = SkeletonFilter.Filter(skeletons).ToList();
ChooseSkeletons(filteredSkeletons);
}
var idsSeen = new HashSet <int>();
foreach (Skeleton skeleton in filteredSkeletons)
{
if (SkeletonTrackingState.Tracked == skeleton.TrackingState)
{
TPlayer player;
// Determine if we're already tracking this player
if (id2PlayerMap.ContainsKey(skeleton.TrackingId))
{
player = id2PlayerMap[skeleton.TrackingId];
}
else
{
// If we're not yet tracking player, create one and let client know that
// a new player has started interacting with Kinect sensor.
player = playerFactory.Create();
id2PlayerMap.Add(skeleton.TrackingId, player);
OnPlayerStatusChanged(PlayerStatus.Joined, player);
}
// Update player data and let client know that player has been changed
player.Update(skeleton, e);
OnPlayerStatusChanged(PlayerStatus.Updated, player);
idsSeen.Add(skeleton.TrackingId);
}
}
// Check if any players have left the scene
var leftScene = new HashSet <int>();
foreach (int tracked in id2PlayerMap.Keys)
{
if (!idsSeen.Contains(tracked))
{
leftScene.Add(tracked);
}
}
// Let client know if any players have stopped interacting with Kinect sensor
foreach (int id in leftScene)
{
var leavingPlayer = id2PlayerMap[id];
OnPlayerStatusChanged(PlayerStatus.Left, leavingPlayer);
id2PlayerMap.Remove(id);
playerFactory.Cleanup(leavingPlayer);
}
}
public IPlayerModel Create(ICharacterModel character, IPull <IGrenadeModel> grenadePull, IPull <IMineModel> minePull)
{
return(_playerFactory.Create(character, grenadePull, minePull));
}
private IPlayCoordinator ConstructPlayCoordinator(IEnumerable <string> playerNames)
{
var players = _playerFactory.Create(playerNames);
return(_playCoordinatorFactory.Create(players));
}
private void Create_Regular_Player()
{
_sut.Create(_mockChoseSideOfTrack.Object, _mockChooseSecondBet.Object,
_mockselectRacingCardInCardsTurn.Object).Should().BeOfType <RegularPlayer>();
}
public IPlayer NewPlayer(int playerId = 0)
{
int id = playerId == 0 ? nextPlayerId++ : playerId;
return(playerFactory.Create(PlayerType.OnlinePlayer, id));
}
