private void AddPlayer()
{
PrintSpecial(Label("ADD PLAYER"));
try
{
Player player = new Player();
Print("Name:");
player.Name = Console.ReadLine();
Print("");
Print("Age:");
player.Age = int.Parse(Console.ReadLine());
Print("");
playerService.AddPlayer(player);
Print("Player added successfully!");
}
catch (ArgumentException e)
{
Print(e.Message);
}
catch (Exception)
{
Print(SomethingWentWrong());
}
}
public async Task Add(string name, string alliance, string location, int?level)
{
try
{
if (string.IsNullOrWhiteSpace(name))
{
await ReplyAsync("Enter a name before adding a player!");
return;
}
var result = await _playerService.AddPlayer(name, alliance, location, Context.User.Username, level);
if (result == PlayerCreationResult.OK)
{
await Context.AddConfirmation();
}
else
{
await ReplyAsync("Player already exists please use `assign` to change alliance or `spot` to change location");
}
}
catch (Exception ex)
{
Log.Error(ex, "Failed getting player by name {name}", name);
}
}
public override async Task OnConnectedAsync()
{
int playerId = _playerService.GetEmptyId();
Console.WriteLine("Client Connected:" + this.Context.ConnectionId + " " + playerId);
var newPlayer = PlayerDirector.Build(playerId, Context.ConnectionId);
if (_playerService.GetCount() == 0)
{ // load map for first player
_mapService.LoadMap(); // TODO: send map id from client side ant then load it?
}
if (!_playerService.AddPlayer(newPlayer))
{
// TODO: player limit exceeded
Console.WriteLine("Player limit exceeded");
}
await Clients.Caller.SendAsync("ClientConnected", newPlayer, _mapService.GetMap()); // Sends back the newly created player and map to the owner
Console.WriteLine(newPlayer.ToString());
Console.WriteLine("Clients Count:" + _playerService.GetCount());
if (_playerService.GetCount() > 1) // If there are other clients connected, notify them of the new player
{
await Clients.AllExcept(this.Context.ConnectionId).SendAsync("ReceiveNewClient", newPlayer);
}
}
public IActionResult Player(PlayerModel request)
{
Player player = request.ToEntity();
_playerService.AddPlayer(player);
ViewBag.Message = "Success.";
return(View());
}
public void PlayerService_AddPlayer_GetById_Success()
{
Player p = new Player {
Forename = "Gregory", Surname = "Sloggett", TotalPoints = 24, ClubId = 1, Position = Position.Midfielder
};
p = svc.AddPlayer(p);
Player newPlayer = svc.GetPlayerById(p.Id);
Assert.NotNull(newPlayer);
}
public async Task <ActionResult <PlayerResponse> > PostPlayer([FromBody] PlayerRequest player)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var playerResponce = await _service.AddPlayer(player);
return(CreatedAtAction("GetPlayer", new { id = playerResponce.Id }, playerResponce));
}
public bool Post([FromRoute] Guid lobbyId, [FromBody] Player player)
{
var success = playerService.AddPlayer(lobbyId, player);
if (success)
{
clientNotifier.PlayerAddedToLobbyNotifyGroup(lobbyId.ToString(), new HubMessage {
data = player
});
}
return(success);
}
public async Task <IActionResult> Create([Bind("Name,Description")] Player player, string[] selectedTeams)
{
var newPlayer = _service.CreatePlayer(player, selectedTeams);
if (ModelState.IsValid)
{
await _service.AddPlayer(newPlayer);
return(RedirectToAction(nameof(Index)));
}
ViewData["Teams"] = await _service.GetPopulatedAssignedTeamData(newPlayer);
return(View(newPlayer));
}
public async Task <ActionResult> AddPlayer([FromBody] FullPlayerDTO player)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (await _playerService.AddPlayer(player))
{
return(Created(String.Empty, null));
}
else
{
return(BadRequest());
}
}
public IActionResult Post(PlayerModel Player)
{
bool Playerexist = _PlayerServices.GetPlayersList().Any(x => x.Value.PlayerName == Player.PlayerName);
if (!Playerexist)
{
using (var scope = new TransactionScope())
{
_PlayerServices.AddPlayer(Player);
scope.Complete();
return(CreatedAtAction(nameof(Get), new { id = Player.PlayerID }, Player));
}
}
return(StatusCode(StatusCodes.Status500InternalServerError, new { message = "Player already exist" }));
}
public async Task <ActionResult> Add(AddPlayerViewModel player)
{
try
{
await _playerService.AddPlayer(player);
return(RedirectToAction("StartGame", "Game"));
return(View());
}
catch (Exception e)
{
return(View("Error"));
}
}
public async Task <ActionResult <Player> > Create([FromBody] Player player)
{
try
{
var playerSaved = await _playerService.AddPlayer(player);
_log.LogInformation($"Returning {playerSaved.Name}");
return(Ok(playerSaved));
}
catch (Exception ex)
{
_log.LogError($"Something went wrong: {ex}");
return(StatusCode(500, ex));
}
}
public async Task <IActionResult> Add([FromBody] Player newPlayer)
{
CUDMessage message = await playerService.AddPlayer(newPlayer);
if (message.OK)
{
message.Message = "Successfuly added the new player: " + newPlayer.DBName;
return(Ok(message));
}
else
{
message.Message = "Failed to add the player: " + newPlayer.DBName + "!";
Response.StatusCode = 500;
return(new JsonResult(message));
}
}
public async Task <IActionResult> AddPlayer(PlayerViewModel model)
{
if (ModelState.IsValid)
{
Player player = new Player()
{
Name = model.Name,
Age = model.Age,
TeamId = model.TeamId
};
await _PlayerService.AddPlayer(player);
return(RedirectToAction("TeamHome", "Team", new { id = model.TeamId }));
}
return(View(model));
}
public async Task <IHttpActionResult> Register(PlayerRegisterDto newPlayer)
{
if (newPlayer == null || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!service.CheckUsernameAvailability(newPlayer.UserName))
{
return(BadRequest("This username has been already taken. Try another one."));
}
var player = mapper.Map <Player>(newPlayer);
var result = await service.AddPlayer(player, newPlayer.UserName, newPlayer.Password, newPlayer.Email);
_achievementsService.AssignAchievementToUser(newPlayer.UserName, "AccountCreated");
return(!result.Succeeded ? GetErrorResult(result) : Ok());
}
public IActionResult PlayerCreated(Player Player)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError(string.Empty, "Something went wrong");
return(View("CreatePlayer"));
}
_logger.LogInformation("PlayerController- Model state VALID");
_PlayerService.AddPlayer(Player);
_logger.LogInformation("PlayerController- Player succesfully created.");
return(RedirectToAction("AllPlayers"));
}
public async Task Connect(string roomId, string player)
{
PlayerInfo playerInfo = _playerService.GetPlayerByName(player);
// If we don't have a player create one
if (playerInfo == null)
{
playerInfo = new PlayerInfo
{
Name = player,
Address = Context.Request.HttpContext.Connection.RemoteIpAddress.ToString(),
ConnectionId = Context.ConnectionId
};
_playerService.AddPlayer(playerInfo);
}
await _roomService.AddPlayerToRoom(playerInfo, roomId);
}
public async Task <IActionResult> Index(string steamId, string steamKey)
{
if (!string.IsNullOrEmpty(steamId) || !string.IsNullOrEmpty(steamKey))
{
SetEnvironmentVariables(steamId, steamKey);
}
PlayerDto steamUser = await _playerService.GetPlayer(steamId);
if (steamUser == null)
{
steamUser = await _steamService.GetSteamUser();
await _playerService.AddPlayer(steamUser);
}
_logger.LogInformation($"Steam user loading: {steamUser?.Personaname}");
return(View(steamUser));
}
public async Task <IActionResult> Index()
{
await _playerSvc.AddPlayer(new DAL.Player()
{
FirstName = "Player8",
LastName = "Fake Player8",
NickName = "Player8",
DoB = DateTime.Now,
});
//await _playerSvc.AddPlayer(new DAL.Player()
//{
// FirstName = "Player9",
// LastName = "Fake Player9",
// NickName = "Player9",
// DoB = DateTime.Now,
//});
return(View());
}
private async Task CreatePlayer(int PlayerNumber)
{
Console.WriteLine($"Creating Player {PlayerNumber} ...");
Random r = new Random();
try
{
await _playerService.AddPlayer(new Player
{
PlayerName = PlayerNames[r.Next(PlayerNames.Count)],
PlayerNumber = PlayerNumber,
});
Console.WriteLine($"Player {PlayerNumber} created succefully");
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex}");
}
}
public ActionResult Post(Player player)
{
try
{
player = playerService.AddPlayer(player);
return(Ok(player));
}
catch (BusinessLogicException e)
{
return(BadRequest(e.Message));
}
catch (PersistentStoreException e)
{
Console.WriteLine(e.Message, e.ToString());
return(StatusCode(500));
}
catch (Exception e)
{
Console.WriteLine(e.Message, e.ToString());
return(StatusCode(500));
}
}
public void AddPlayer()
{
string name = null;
while (string.IsNullOrEmpty(name) || name.Length < 3)
{
Console.WriteLine("\n\nEscribe nombre del jugador (y presiona enter):");
name = Console.ReadLine();
}
Gender?gender = null;
while (gender == null)
{
Console.WriteLine("\nElige sexo:\n1. Femenino\n2. Masculino");
var genderKey = Console.ReadKey(true);
if (genderKey.KeyChar == '1')
{
gender = Gender.Female;
}
else if (genderKey.KeyChar == '2')
{
gender = Gender.Male;
}
}
var player = new Player
{
Gender = gender.Value,
Name = name,
Power = GameModel.DefaultPower,
Lives = GameModel.DefaultLives
};
_playerService.AddPlayer(player);
ConsoleHelper.Write($"\n{player.Name} ha sido añadido", ConsoleColor.Yellow);
}
public ActionResult <Tournament> CreatePlayer(PlayerDto player)
{
return(Ok(playerService.AddPlayer(player)));
}
public async Task <ActionResult> Post([FromBody] Player player)
{
await _playerService.AddPlayer(player);
return(Ok());
}
public IActionResult Add(Player model)
{
_playerService.AddPlayer(model);
return(NoContent());
}
public async Task <IActionResult> AddPlayer(AddPlayerDto newPlayer)
{
return(Ok(await _playerService.AddPlayer(newPlayer)));
}
public IActionResult Post([FromBody] Player player)
{
_playerService.AddPlayer(player);
return(new CreatedResult($"api/players/{player.Id}", player));
}
public void Post([FromBody] Player player)
{
_service.AddPlayer(player);
}
public async Task <string> AddPlayer(Player player)
{
return(await _playerService.AddPlayer(player));
}
