private void DisplayShotHistory(PlayerDto inDto)
{
var dto = inDto;
Console.WriteLine();
string header = " A B C D E F G H I J".PadLeft(33, ' ');
Console.WriteLine(header);
Console.WriteLine("-----------------------------".PadLeft(33, ' '));
for (int i = 1; i < 11; i++)
{
Console.Write("{0}| ", i.ToString().PadLeft(2, ' '));
for (int j = 1; j < 11; j++)
{
var myCoord = new Coordinate(j, i);
if (dto.Board.ShotHistory.ContainsKey(myCoord))
{
if (dto.Board.ShotHistory[myCoord] == ShotHistory.Hit)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Write(" H ");
Console.ResetColor();
}
else if (dto.Board.ShotHistory[myCoord] == ShotHistory.Miss)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(" m ");
Console.ResetColor();
}
}
else
{
Console.Write(" * ");
}
}
Console.WriteLine();
//Console.Write(" |{0}\n", i);
}
}
private PlayerDto toDto(PlayerModel model)
{
PlayerDto dto = new PlayerDto()
{
id = model.Id,
exp = model.Exp,
loseCount = model.LoseCount,
lv = model.lv,
name = model.Name,
power = model.Power,
runCount = model.RunCount,
winCount = model.WinCount
};
string[] heroIds = model.HeroIdList.Split(',');
dto.heroIds = new int[heroIds.Length];
for (int i = 0; i < heroIds.Length; i++)
{
dto.heroIds[i] = int.Parse(heroIds[i]);
}
//赋值好友列表
string[] friends = model.FriendIdList.Split(',');
dto.friends = new Friend[friends.Length];
for (int i = 0; i < friends.Length; i++)
{
if (string.IsNullOrEmpty(friends[i]))
{
continue;
}
int id = int.Parse(friends[i]);
string name = playerCache.GetModel(id).Name;
bool online = playerCache.isOnline(id);
dto.friends[i] = new Friend(id, name, online);
}
//赋值！！！
return(dto);
}
public PlayerDto GetData(string userUrl)
{
const string BaseUri = "https://www.laczynaspilka.pl/zawodnik/";
var player = new PlayerDto();
var urlUser = Path.Combine(BaseUri, userUrl);
HtmlWeb web = new HtmlWeb();
var doc = web.Load(urlUser);
var statistics = doc.QuerySelectorAll("section .season__stats .stats--player div .season__stats-item");
var clubs = doc.QuerySelectorAll("div .player-clubs__item");
try
{
player.FirstName = doc.QuerySelector("section .profile-page a").InnerText.Split(" ").First();
player.LastName = doc.QuerySelector("section .profile-page a").InnerText.Split(" ").Last();
player.PlayerAge = Int16.Parse(doc.QuerySelector("div .about-player ").InnerText.Trim().Split('\n').Last().Trim().Split(" ").Last());
player.CurrentClub = doc.QuerySelector("section .fav-team").InnerText.Trim().Split('\n').Last().Trim();
player.MatchesPlayed = Int16.Parse(statistics[0].QuerySelectorAll("span").Last().InnerHtml);
player.MinutesOnThePitch = Int16.Parse(statistics[1].QuerySelectorAll("span").Last().InnerHtml);
player.Goals = Int16.Parse(statistics[2].QuerySelectorAll("span").Last().InnerHtml);
player.YellowCards = Int16.Parse(statistics[3].QuerySelectorAll("span")[1].InnerText);
player.RedCards = Int16.Parse(statistics[3].QuerySelectorAll("span")[2].InnerText);
foreach (var club in clubs)
{
var c = new ClubDto();
c.Season = club.QuerySelector("span .date").InnerText;
c.Name = club.QuerySelector("span .club").InnerText;
player.Clubs.Add(c);
}
}
catch
{
return(null);
}
return(player);
}
public async Task <IActionResult> GetPlayer([FromRoute] string id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var getPlayer = await _repo.GetFirstAsync <Player>(x => x.Id.Equals(id), null,
String.Join(",", new object[] { nameof(Player.Country), nameof(Player.Game), nameof(Player.Team) }));
if (!getPlayer.Success)
{
return(NotFound());
}
var player = getPlayer.Data;
var playerDto = new PlayerDto
{
Id = player.Id,
FirstName = player.FirstName,
LastName = player.LastName,
Nickname = player.Nickname,
Country = player.Country.Name,
DateOfBirth = player.DateOfBirth,
Team = player.Team.Name,
Game = player.Game.Name
};
return(Ok(playerDto));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
/// <summary>
/// 客户端比牌的处理
/// </summary>
/// <param name="compareClient"></param>
/// <param name="comparedID"></param>
private void CompareCard(ClientPeer compareClient, int comparedID)
{
SingleExecute.Instance.Exeecute(() => {
if (fightCache.IsFighting(compareClient.Id) == false)
{
return;
}
FightRoom room = fightCache.GetFightRoomByUserId(compareClient.Id);
room.stakesSum += room.lastPlayerStakes;
int stakesSum = room.UpdatePlayerStakesSum(compareClient.Id, room.lastPlayerStakes);
int remainCoin = DatabaseManager.UpdateCoin(compareClient.Id, -room.lastPlayerStakes);
stakesDto.Change(compareClient.Id, remainCoin, room.lastPlayerStakes, stakesSum, StakesDto.StakesType.Look);
room.Broadcast(OpCode.Fight, FightCode.PutStakes_BRO, stakesDto);
// 拿到 3 个玩家的 DTO
PlayerDto c1Dto = null, c2Dto = null, otherDto = null;
foreach (var player in room.playerList)
{
if (player.id == compareClient.Id)
{
c1Dto = player;
}
else if (player.id == comparedID)
{
c2Dto = player;
}
else
{
otherDto = player;
}
}
ClientPeer otherClient = DatabaseManager.GetClientPeerByUserId(otherDto.id);
// 比牌
CompareCard(room, compareClient, c1Dto, c2Dto, otherClient);
});
}
public IHttpActionResult GetPlayers()
{
List <Player> Players = db.Players.ToList();
List <PlayerDto> PlayerDtos = new List <PlayerDto> {
};
//Here you can choose which information is exposed to the API
foreach (var Player in Players)
{
PlayerDto NewPlayer = new PlayerDto
{
PlayerID = Player.PlayerID,
PlayerBio = Player.PlayerBio,
PlayerFirstName = Player.PlayerFirstName,
PlayerLastName = Player.PlayerLastName,
PlayerHasPic = Player.PlayerHasPic,
PicExtension = Player.PicExtension,
TeamID = Player.TeamID
};
PlayerDtos.Add(NewPlayer);
}
return(Ok(PlayerDtos));
}
public IHttpActionResult GetPlayersForTeam(int id)
{
List <Player> Players = db.Players.Where(p => p.TeamID == id)
.ToList();
List <PlayerDto> PlayerDtos = new List <PlayerDto> {
};
//Here you can choose which information is exposed to the API
foreach (var Player in Players)
{
PlayerDto NewPlayer = new PlayerDto
{
PlayerID = Player.PlayerID,
PlayerName = Player.PlayerName,
PlayerNumber = Player.PlayerNumber,
PlayerPosition = Player.PlayerPosition,
PlayerInjuryDescription = Player.PlayerInjuryDescription,
TeamID = Player.TeamID
};
PlayerDtos.Add(NewPlayer);
}
return(Ok(PlayerDtos));
}
public IHttpActionResult GetPlayersPage(int StartIndex, int PerPage)
{
List <Player> Players = db.Players.OrderBy(p => p.PlayerID).Skip(StartIndex).Take(PerPage).ToList();
List <PlayerDto> PlayerDtos = new List <PlayerDto> {
};
//Here you can choose which information is exposed to the API
foreach (var Player in Players)
{
PlayerDto NewPlayer = new PlayerDto
{
PlayerID = Player.PlayerID,
PlayerBio = Player.PlayerBio,
PlayerFirstName = Player.PlayerFirstName,
PlayerLastName = Player.PlayerLastName,
PlayerHasPic = Player.PlayerHasPic,
PicExtension = Player.PicExtension,
TeamID = Player.TeamID
};
PlayerDtos.Add(NewPlayer);
}
return(Ok(PlayerDtos));
}
public async void damagePlayer()
{
/* Attaque du Joueur */
this.monsterCurrent.HP = this.monsterCurrent.HP - this.player.Attack; /* + obgectDmg */
await this.zorkService.MonsterServices.EditAsync(this.monsterCurrent);
Console.WriteLine($"Vous attaquez ! {this.monsterCurrent.Name} a {this.monsterCurrent.HP} HP");
if (this.monsterCurrent.HP <= 0)
{
Console.WriteLine($"{this.monsterCurrent.Name} est mort...");
this.player.XP++;
await this.zorkService.PlayerServices.editUserLifeXP(this.player);
await this.zorkService.MonsterServices.DeleteAsync(this.monsterCurrent);
if (this.monsterCurrent.Name == "Dragon")
{
Console.WriteLine("\n\n\n (¯`·¯`·.¸¸.·´¯`·.¸¸.·´¯`·´¯)\n ( \\ / )\n ( ) Vous avez gagner ! ( )\n (/ \\)\n (.·´¯`·.¸¸.·´¯`·.¸¸.·)");
this.exit = true;
this.player = await this.zorkService.PlayerServices.finishPlayer();
}
}
}
public Player NewCharacter()
{
if (_playerRepository.PlayerCount() == 10)
{
_printService.Type("There are too many saves, you need to delete one to cotinue with your creation.");
pickPlayerToRemove();
}
_printService.ClearConsole();
_printService.Type("Now we are going to create a new character for your adventure.");
Thread.Sleep(2000);
var playerDto = new PlayerDto();
pickRace(playerDto);
pickGender(playerDto);
pickName(playerDto);
pickClass(playerDto);
var startingClass = _classRepository.GetClass(playerDto.Class);
var player = new Player(playerDto);
loadNewInventory(startingClass, player);
_playerRepository.AddPlayer(player);
_playerRepository.SavePlayers();
Console.WriteLine($"{Environment.NewLine}Name: {playerDto.Name}");
Console.WriteLine($"Gender: {playerDto.Gender}");
Console.WriteLine($"Race: {playerDto.Race}");
Console.WriteLine($"Class: {playerDto.Class}");
return(player);
}
public void UpdateAllPlayers(ExportMethodEnum ExportMethod, bool AddCharacters)
{
int count = 0;
for (int i = 0; i < PlayerNames.Count; i++)
{
count++;
SwGoh.PlayerDto player = new PlayerDto(PlayerNames[i]);
int ret = player.ParseSwGoh(ExportMethod, AddCharacters);
if (ret == 1)
{
player.LastClassUpdated = DateTime.UtcNow;
player.Export(ExportMethod);
if (Players == null)
{
Players = new List <PlayerDto>();
}
Players.Add(player);
Thread.Sleep(mDelayPlayer);
}
else if (ret == 0)
{
Thread.Sleep(mDelayError);
i--;
}
else
{
if (Players == null)
{
Players = new List <PlayerDto>();
}
Players.Add(player);
}
}
Export(ExportMethod, false);
}
public void ResetPosition(int bankerId)
{
//x a b
if (playerList[0].userId == bankerId)
{
PlayerDto dto = playerList[1];
playerList[1] = playerList[2];
playerList[2] = dto;
}
//a x b
if (playerList[1].userId == bankerId)
{
PlayerDto dto = playerList[0];
playerList[0] = playerList[2];
playerList[2] = dto;
}
//a b x
if (playerList[2].userId == bankerId)
{
PlayerDto dto = playerList[0];
playerList[0] = playerList[1];
playerList[1] = dto;
}
}
public async Task <IActionResult> UpdateRiotId(string riotName)
{
AramIdentityUser user;
if (User != null && User.Identity != null)
{
user = await userManager.FindByNameAsync(User.Identity.Name);
using (var httpClient = new HttpClient())
{
var resp = await httpClient.GetAsync($"https://euw1.api.riotgames.com/lol/summoner/v4/summoners/by-name/{riotName}?api_key={options.Value.ApiRiotKey}");
if (resp.IsSuccessStatusCode)
{
PlayerDto player = JsonConvert.DeserializeObject <PlayerDto>(await resp.Content.ReadAsStringAsync());
user.riotId = player.accountId;
user.riotName = player.name;
}
}
await userManager.UpdateAsync(user);
}
ViewBag.RiotName = riotName;
return(View("Index"));
}
public PlayerDto Convert(Tuple <Player, Bet, string> source, PlayerDto destination, ResolutionContext context)
{
var chips = new List <int>();
if (source.Item2?.Amount is null)
{
chips = null;
}
else if (source.Item2.IsSplitted)
{
chips.Add(source.Item2.Amount.Value / 2);
chips.Add(source.Item2.Amount.Value / 2);
}
else
{
chips.Add(source.Item2.Amount.Value);
}
return(new PlayerDto
{
Username = source.Item1.Username,
Chips = chips
});
}
public void AddRemovePlayerTest()
{
PlayerDto dto = new PlayerDto()
{
PlayerId = TEST_ID,
Name = TEST_NAME,
UserName = TEST_USERNAME,
Password = TEST_PASSWORD,
EmailAddress = TEST_EMAIL,
ShouldSync = false
};
var addResult = PlayerService.AddNew(dto);
Assert.IsTrue(addResult.IsSuccess);
dto.Name = TEST_NAME2;
dto.ShouldSync = true;
var updateResult = PlayerService.Update(dto);
Assert.IsTrue(updateResult.IsSuccess);
var player = PlayerService.GetPlayer(TEST_ID);
Assert.IsNotNull(player);
Assert.AreEqual(TEST_NAME2, player.Name);
Assert.AreEqual(true, player.ShouldSync);
var players = PlayerService.GetPlayers();
Assert.IsTrue(players.Count >= 1);
var deleteResult = PlayerService.Remove(TEST_ID);
Assert.IsTrue(deleteResult.IsSuccess);
}
public static PlayerRemovedFromVesselRoleEvent FromPlayerInGameVesselRole(Guid gameId, VesselDto vessel, string vesselRole, PlayerDto player) =>
new PlayerRemovedFromVesselRoleEvent(
EventBase.GetDateIsoString(),
gameId,
vessel,
vesselRole,
player
);
} // For model binding / deserialization
private PlayerRemovedFromVesselRoleEvent(string eventDateIsoString, Guid gameId, VesselDto vessel, string vesselRole, PlayerDto player) : base(eventDateIsoString)
{
GameId = gameId;
Vessel = vessel;
VesselRole = vesselRole;
Player = player;
}
/// <summary>
/// Initialize the Component.
/// Edit player is selected.
/// </summary>
/// <param name="player"></param>
public PlayerEditor(PlayerDto player)
{
InitializeComponent();
Player = player;
UpdateValues();
}
/// <summary>
/// Initailize the Component.
/// Create player is selected.
/// </summary>
public PlayerEditor()
{
InitializeComponent();
uxID.Enabled = true;
Player = new PlayerDto();
}
public ActionResult <PlayerDto> Post(PlayerDto playerDto)
{
_playerService.Add(playerDto);
return(Ok(playerDto));
}
public override async Task OnConnectedAsync()
{
if (IsAlreadyConnected())
{
var duel = GetCurrentDuel();
await Groups.AddToGroupAsync(Context.ConnectionId, duel.GroupName);
await Clients.Caller.SendAsync("DuelStarts", duel);
return;
}
var firstPlayer = new PlayerDto
{
ConnectionId = Context.ConnectionId,
Name = Context.User.FindFirstValue(ClaimTypes.GivenName),
Email = Context.User.FindFirstValue(ClaimTypes.Email),
Picture = _userRepository.GetUser(Context.User).Picture
};
if (UserHandler.WaitingPlayers.Count > 0)
{
PlayerDto secondPlayer = null;
int? taskId = null;
for (int i = 0; i < UserHandler.WaitingPlayers.Count; i++)
{
secondPlayer = UserHandler.WaitingPlayers.Skip(i).First();
taskId = await _taskManager.GetTaskIdForDuelAsync(new List <string>
{
firstPlayer.Email, secondPlayer.Email
});
if (taskId != null)
{
break;
}
}
if (taskId == null)
{
AddWaitingPlayer(firstPlayer);
return;
}
RemoveWaitingPlayer(secondPlayer);
var task = await _taskManager.GetCachedTaskByIdAsync((int)taskId);
var duration = _duelLogic.CalculateDuelDuration(_hostingEnv.EnvironmentName, task.Value);
var duel = _duelLogic.CreateDuel(task, firstPlayer,
secondPlayer, duration);
UserHandler.ActiveDuels.Add(duel);
var timer = new Timer
{
Interval = duration * 60 * 1000
};
timer.Elapsed += (sender, e) => DuelTimeElapsed(duel, timer);
timer.Start();
await Groups.AddToGroupAsync(firstPlayer.ConnectionId, duel.GroupName);
await Groups.AddToGroupAsync(secondPlayer.ConnectionId, duel.GroupName);
await Clients.Group(duel.GroupName).SendAsync("DuelStarts", duel);
}
else
{
AddWaitingPlayer(firstPlayer);
}
await base.OnConnectedAsync();
}
private void ProcessTurn(PlayerDto inDto)
{
Shoot(inDto);
Console.WriteLine("\n\n> Press enter to continue...\n");
Console.ReadLine();
Console.Clear();
}
/// <summary>
/// 上线
/// </summary>
private void OnLine(PlayerDto dto)
{
//保存数据
GameData.Player = dto;
view.UpdateView(dto);
}
private static EntityType WhichPlayerIsGiven(PlayerDto player) =>
player.EntityType == EntityType.PlayerOne
? EntityType.PlayerOne
: EntityType.PlayerTwo;
public Task UpdatePlayer2Async(Guid gameId, int gameVersion, PlayerDto player)
{
return(UpdatePlayerAsync(gameId, gameVersion, player, 2));
}
// ctor
public BattleshipGame()
{
_p1Dto = new PlayerDto();
_p2Dto = new PlayerDto();
_quit = 2;
}
private void Shoot(PlayerDto inDto)
{
bool isShotValid = false;
while (!isShotValid)
{
var coordGetter = new CoordGetter();
//Console.Clear();
DisplayShotHistory(inDto);
var coord = coordGetter.GetCoord("> Enter Shot Coord (Ex: a1, b6) : ");
var response = inDto.Board.FireShot(coord);
Console.Clear();
Console.WriteLine("\n Shot result: ");
DisplayShotHistory(inDto);
if (response.ShotStatus == ShotStatus.Duplicate || response.ShotStatus == ShotStatus.Invalid)
{
Console.WriteLine("\nThat was not a valid shot, ({0}), Take another shot!", response.ShotStatus.ToString());
Console.WriteLine("\n Press Enter to re-take shot...");
Console.ReadLine();
Console.Clear();
Console.WriteLine("\n Shot result: ");
//mt
//Console.ReadLine();
//Console.Clear();
}
else if (response.ShotStatus == ShotStatus.Miss)
{
Console.Write("\nSplash! - You MISSED...");
isShotValid = true;
}
else if (response.ShotStatus == ShotStatus.Hit)
{
Console.Write("\nBOOM! *** You hit something!");
isShotValid = true;
}
else if (response.ShotStatus == ShotStatus.HitAndSunk)
{
Console.Write("\nBAAM! *** You hit and SUNK a {0}", response.ShipImpacted.ToString());
isShotValid = true;
}
else
{
Console.WriteLine("\nVICTORY! - you just WON!!!");
_isVictory = true;
break;
}
}
}
public void SendPlayerData(PlayerDto player)
{
Console.Write(player);
Program.server.Token = player.Id;
}
public ActionResult New()
{
var viewModel = new PlayerDto();
return(View("PlayerForm", viewModel));
}
public IEnumerable <PlayerDto> GetOtherPlayers(PlayerDto player)
{
var allPlayersExceptGiven = _unitOfWork.PlayerRepository.GetAll().Where(x => !x.Name.Equals(player.Name));
return(_mapper.Map <IEnumerable <PlayerDto> >(allPlayersExceptGiven));
}
private void PlaceShips(PlayerDto inDto)
{
int a = Enum.GetNames(typeof(ShipType)).Length;
for (int i = 0; i < a; i++)
{
bool isPlacementOk = false;
while (!isPlacementOk)
{
string shipType = ((ShipType)i).ToString();
var coordGetter = new CoordGetter();
var shipPointer = new ShipPointer();
PlaceShipRequest request = new PlaceShipRequest()
{
Coordinate = coordGetter.GetCoord((i + 1).ToString() + ". " + "Enter coordinate for your " + shipType.ToString() + ": "),
Direction = shipPointer.PointShip(" Ship direction: (L-left, R-right, U-up, D-down): "),
ShipType = (ShipType)i
};
var responce = inDto.Board.PlaceShip(request);
string r = responce.ToString();
if (r == ShipPlacement.Ok.ToString())
{
isPlacementOk = true;
Console.WriteLine(" Ship placement status: {0}", r);
}
else Console.WriteLine(" Ship NOT PLACED! : {0}", r);
}
}
}
public static void Player(this ScenarioContext context, PlayerDto playerDto)
{
context.Set(PlayerKey, playerDto);
}
static void Main(string[] args)
{
//string pname = "41st";
//Command command = Command.UpdateGuild;
SwGoh.CharactersConfig.ExportCharacterFilesToDB();
ExportMethodEnum mExportMethod = ExportMethodEnum.Database;
string pname = "newholborn";
Command command = Command.UpdatePlayer;
if (args.Length > 0)
{
string commandstr = args[0];
if (args.Length > 2 && commandstr == "ups")
{
command = Command.UpdatePlayers;
}
else if (commandstr == "up")
{
command = Command.UpdatePlayer;
}
else if (commandstr == "ug")
{
command = Command.UpdateGuild;
}
else if (commandstr == "ugnochars")
{
command = Command.UpdateGuildWithNoChars;
}
else if (commandstr == "help")
{
command = Command.Help;
}
else if (commandstr == "test")
{
command = Command.Test;
}
else
{
command = Command.UnKnown;
}
if (args.Length > 1)
{
pname = args[1];
}
}
switch (command)
{
case Command.UpdatePlayer:
{
SwGoh.PlayerDto player = new PlayerDto(pname);
int ret = player.ParseSwGoh(mExportMethod, true);
if (ret == 1)
{
player.Export(mExportMethod);
}
break;
}
case Command.UpdateGuild:
{
SwGoh.GuildDto guild = new GuildDto();
guild.Name = guild.GetGuildNameFromAlias(pname);
guild.ParseSwGoh();
if (guild.PlayerNames != null && guild.PlayerNames.Count > 0)
{
guild.UpdateAllPlayers(mExportMethod, true);
}
break;
}
case Command.UpdatePlayers:
{
for (int i = 1; i < args.Length; i++)
{
SwGoh.PlayerDto player = new PlayerDto(args[i]);
int ret = player.ParseSwGoh(mExportMethod, true);
if (ret == 1)
{
player.Export(mExportMethod);
}
}
break;
}
case Command.UpdateGuildWithNoChars:
{
SwGoh.GuildDto guild = new GuildDto();
guild.Name = guild.GetGuildNameFromAlias(pname);
guild.ParseSwGoh();
if (guild.PlayerNames != null && guild.PlayerNames.Count > 0)
{
guild.UpdateOnlyGuildWithNoChars(mExportMethod);
}
break;
}
case Command.Help:
{
Console.WriteLine("Command Update Player");
Console.WriteLine("Usage : <app> up <playername>");
Console.WriteLine("Update only one player with his characters.");
Console.WriteLine("");
Console.WriteLine("Command Update Players");
Console.WriteLine("Usage : <app> ups <playername1> <playername2> <playername3>");
Console.WriteLine("Update provided players with their characters.");
Console.WriteLine("");
Console.WriteLine("Command Update Guild");
Console.WriteLine("Usage : <app> ug <guildname>");
Console.WriteLine("Update all players with their characters and at the end update the guild file.");
Console.WriteLine("");
Console.WriteLine("Command Update Guild without the characters of the players");
Console.WriteLine("Usage : <app> ugnochars <guildname>");
Console.WriteLine("Update the guild file.");
Console.WriteLine("");
Console.WriteLine("Command Help");
Console.WriteLine("Usage : <app> help");
Console.WriteLine("You already know this command!!!!!");
break;
}
case Command.Test:
{
SwGoh.CharactersConfig.ExportCharacterFilesToDB();
break;
}
default:
{
Console.WriteLine("Unknown command , please try again.!!!!");
break;
}
}
Console.WriteLine("");
Console.WriteLine("Press Enter to close!!!!");
Console.Read();
}
public async Task LoginHandler(GameSession session, CLoginReqMessage message)
{
Logger.Info()
.Account(message.AccountId, message.Username)
.Message($"Login from {session.RemoteEndPoint}")
.Write();
if (message.Version != s_version)
{
Logger.Error()
.Account(message.AccountId, message.Username)
.Message($"Invalid client version {message.Version}")
.Write();
session.SendAsync(new SLoginAckMessage(GameLoginResult.WrongVersion));
return;
}
if (GameServer.Instance.PlayerManager.Count >= Config.Instance.PlayerLimit)
{
Logger.Error()
.Account(message.AccountId, message.Username)
.Message("Server is full")
.Write();
session.SendAsync(new SLoginAckMessage(GameLoginResult.ServerFull));
return;
}
#region Validate Login
AccountDto accountDto;
using (var db = AuthDatabase.Open())
{
accountDto = (await db.FindAsync <AccountDto>(statement => statement
.Include <BanDto>(join => join.LeftOuterJoin())
.Where($"{nameof(AccountDto.Id):C} = @Id")
.WithParameters(new { Id = message.AccountId })))
.FirstOrDefault();
}
if (accountDto == null)
{
Logger.Error()
.Account(message.AccountId, message.Username)
.Message("Wrong login")
.Write();
session.SendAsync(new SLoginAckMessage(GameLoginResult.SessionTimeout));
return;
}
uint inputSessionId;
if (!uint.TryParse(message.SessionId, out inputSessionId))
{
Logger.Error()
.Account(message.AccountId, message.Username)
.Message("Wrong login")
.Write();
session.SendAsync(new SLoginAckMessage(GameLoginResult.SessionTimeout));
return;
}
var sessionId = Hash.GetUInt32 <CRC32>($"<{accountDto.Username}+{accountDto.Password}>");
if (sessionId != inputSessionId)
{
Logger.Error()
.Account(message.AccountId, message.Username)
.Message("Wrong login")
.Write();
session.SendAsync(new SLoginAckMessage(GameLoginResult.SessionTimeout));
return;
}
var now = DateTimeOffset.Now.ToUnixTimeSeconds();
var ban = accountDto.Bans.FirstOrDefault(b => b.Date + (b.Duration ?? 0) > now);
if (ban != null)
{
var unbanDate = DateTimeOffset.FromUnixTimeSeconds(ban.Date + (ban.Duration ?? 0));
Logger.Error()
.Account(message.AccountId, message.Username)
.Message($"Banned until {unbanDate}")
.Write();
session.SendAsync(new SLoginAckMessage(GameLoginResult.SessionTimeout));
return;
}
var account = new Account(accountDto);
#endregion
if (account.SecurityLevel < Config.Instance.SecurityLevel)
{
Logger.Error()
.Account(account)
.Message($"No permission to enter this server({Config.Instance.SecurityLevel} or above required)")
.Write();
session.SendAsync(new SLoginAckMessage((GameLoginResult)9));
return;
}
if (message.KickConnection)
{
Logger.Info()
.Account(account)
.Message("Kicking old connection")
.Write();
var oldPlr = GameServer.Instance.PlayerManager.Get(account.Id);
oldPlr?.Disconnect();
}
if (GameServer.Instance.PlayerManager.Contains(account.Id))
{
Logger.Error()
.Account(account)
.Message("Already online")
.Write();
session.SendAsync(new SLoginAckMessage(GameLoginResult.TerminateOtherConnection));
return;
}
using (var db = GameDatabase.Open())
{
var plrDto = (await db.FindAsync <PlayerDto>(statement => statement
.Include <PlayerCharacterDto>(join => join.LeftOuterJoin())
.Include <PlayerDenyDto>(join => join.LeftOuterJoin())
.Include <PlayerItemDto>(join => join.LeftOuterJoin())
.Include <PlayerLicenseDto>(join => join.LeftOuterJoin())
.Include <PlayerMailDto>(join => join.LeftOuterJoin())
.Include <PlayerSettingDto>(join => join.LeftOuterJoin())
.Where($"{nameof(PlayerDto.Id):C} = @Id")
.WithParameters(new { Id = message.AccountId })))
.FirstOrDefault();
if (plrDto == null)
{
// first time connecting to this server
var expTable = GameServer.Instance.ResourceCache.GetExperience();
Experience expValue;
if (!expTable.TryGetValue(Config.Instance.Game.StartLevel, out expValue))
{
expValue = new Experience();
expValue.TotalExperience = 0;
Logger.Warn($"Given start level is not found in the experience table");
}
plrDto = new PlayerDto
{
Id = (int)account.Id,
Level = Config.Instance.Game.StartLevel,
PEN = Config.Instance.Game.StartPEN,
AP = Config.Instance.Game.StartAP,
Coins1 = Config.Instance.Game.StartCoins1,
Coins2 = Config.Instance.Game.StartCoins2,
TotalExperience = (int)expValue.TotalExperience
};
await db.InsertAsync(plrDto);
}
session.Player = new Player(session, account, plrDto);
}
if (GameServer.Instance.PlayerManager.Contains(session.Player))
{
session.Player = null;
Logger.Error()
.Account(account)
.Message("Already online")
.Write();
session.SendAsync(new SLoginAckMessage(GameLoginResult.TerminateOtherConnection));
return;
}
GameServer.Instance.PlayerManager.Add(session.Player);
Logger.Info()
.Account(account)
.Message("Login success")
.Write();
var result = string.IsNullOrWhiteSpace(account.Nickname)
? GameLoginResult.ChooseNickname
: GameLoginResult.OK;
await session.SendAsync(new SLoginAckMessage(result, session.Player.Account.Id));
if (!string.IsNullOrWhiteSpace(account.Nickname))
{
await LoginAsync(session);
}
}
public ClientMessage <RegistrationResult> Register(PlayerDto dto)
{
var clientMessage = new ClientMessage <RegistrationResult>();
try
{
var player = _mapper.Map <Player>(dto);
var alreadyExist = _dbContext.Players.Include(t => t.Transactions).ThenInclude(t => t.Answer)
.ThenInclude(t => t.Question).FirstOrDefault(t => t.EmailAddress == player.EmailAddress);
if (alreadyExist != null)
{
var personalityQuestions = alreadyExist.Transactions.Select(t => t.Answer.Question)
.Where(t => t.QuestionTypeId == (int)AppEnum.QuestionTypes.Level_3).Select(t => t.Id).Distinct();
if (personalityQuestions.Count() == 7)
{
clientMessage.ReturnedData = new RegistrationResult {
PlayerId = alreadyExist.Id, NewPlayer = false
};
clientMessage.ClientStatusCode = DataEnum.OperationStatus.Ok;
return(clientMessage);
}
else
{
_dbContext.Players.Remove(alreadyExist);
_dbContext.SaveChanges();
}
}
if (dto.PlayerCV != null)
{
var physicalFileName = Guid.NewGuid().ToString();
physicalFileName += Path.GetExtension(dto.PlayerCV.FileName);
var virtualFileName = dto.PlayerCV.FileName;
var filePath = Path.Combine(_hostingEnvironment.WebRootPath, "App_Files/");
using (var fileStream = new FileStream(Path.Combine(filePath, physicalFileName), FileMode.Create))
{
dto.PlayerCV.CopyTo(fileStream);
}
player.CvPhysicalName = physicalFileName;
player.CvVirtualName = virtualFileName;
}
player.CreatedById = -1;
player.CreatedDate = DateTime.Now;
player.IsActive = true;
_dbContext.Players.Add(player);
_dbContext.SaveChanges();
clientMessage.ClientMessageContent = new List <string> {
"Player created successfully"
};
clientMessage.ReturnedData = new RegistrationResult {
PlayerId = player.Id, NewPlayer = true
};
clientMessage.ClientStatusCode = DataEnum.OperationStatus.Ok;
return(clientMessage);
}
catch (Exception ex)
{
clientMessage.ClientMessageContent = new List <string> {
ex.Message + " " + ex.InnerException
};
clientMessage.ReturnedData = new RegistrationResult();
clientMessage.ClientStatusCode = DataEnum.OperationStatus.Error;
return(clientMessage);
}
}
