public void exitRoom()
{
buttonSound.Play();
if (isServer && players.Count > 1)
{
return;
}
DbPlayer db = new DbPlayer();
PlayerData Info = db.GetPlayerByUserName(localPlayer.playerPanel.userNameText.text);
Info.Money += localPlayer.money;
db.UpdatePlayer(Info);
RemovePlayer(localPlayer);
if (isServer)
{
LobbyScene.singleton.StopHost();
Destroy(LobbyScene.singleton.gameObject);
return;
}
if (isClient)
{
LobbyScene.singleton.StopClient();
Destroy(localPlayer);
return;
}
}//exit the room after saving the player new score in the data base to the lobby scene
private void AddPlayer(object sender, int position)
{
ListView listview = (ListView)sender;
ZonePlayersListAdapter adapter = listview.Adapter as ZonePlayersListAdapter;
zoneAdapter = adapter;
DbPlayer player = adapter.GetItem(position);
if (player == null)
{
AlertDialog.Builder builder = new AlertDialog.Builder(Activity);
LayoutInflater inflater = LayoutInflater;
View view = inflater.Inflate(Resource.Layout.select_player_layout, null);
ListView playerList = view.FindViewById <ListView>(Resource.Id.playerList);
playerList.Adapter = new DetailedPlayerListAdapter(myVieWModel.GetPlayers(), Activity);
playerList.ItemClick += PlayerList_ItemClick;
//string text = MainViewModel.Instance.GetDb().ToString();
builder.SetView(view)
.SetNegativeButton("Cancel", (s, args) => {
});
alert = builder.Create();
alert.Show();
}
}
}//on start of the object fill in all of the player data
void Awake()
{
Data = new DbPlayer();
info = Data.GetPlayerByUserName(PlayerPrefs.GetString("userName"));
userName.text = info.UserName;
chipsAmount.text = info.Money.ToString();
if (info.Money > 30000)
{
status.sprite = Status[4];
}
else
if (info.Money < 30000 && info.Money > 20000)
{
status.sprite = Status[3];
}
else
if (info.Money < 20000 && info.Money > 15000)
{
status.sprite = Status[2];
}
else
if (info.Money < 15000 && info.Money > 5000)
{
status.sprite = Status[1];
}
else
{
status.sprite = Status[0];
}
playersImage.sprite = avatars[info.PlayerImage];
}
public ActionResult Print(HttpPostedFileBase file)
{
if (file != null && file.ContentLength > 0)
{
var player = Serialization.LoadFromStream(file.InputStream);
using (var db = new ApplicationDbContext())
{
var row = new DbPlayer
{
FullName = player.FullName,
NickName = player.NickName,
PlayerID = player.PlayerID,
SignatureHero = player.SignatureHero,
WinRate = player.WinRate,
PrimaryRole = new Collection <DbCurrency>(),
SoloRating = player.SoloRating,
RateStars = player.RateStars,
};
foreach (var elem in player.PrimaryRole)
{
row.PrimaryRole.Add(new DbCurrency
{
Role = elem,
});
}
db.DbPlayers.Add(row);
db.SaveChanges();
}
return(View(player));
}
return(RedirectToAction("Index"));
}
public void LoginClick()//function that check the user name and the password after a user tries to Login
{
db = new DbPlayer();
if (db.ExistUser(userName.text))
{
if (!db.isUserConnected(userName.text))
{
PlayerData info = db.GetPlayerByUserName(userName.text);
if (info.Password == Password.text)
{
PlayerPrefs.SetString("userName", info.UserName);
PlayerPrefs.SetInt("ImageOffset", info.PlayerImage);
PlayerPrefs.Save();
db.addUserConnection(info.UserName);
SceneManager.LoadScene("lobbytest");
}
else
{
Errors.text = "Worng Password";
}
}
else
{
Errors.text = "This User Allready Conntected";
}
}
else
{
Errors.text = "User Dont Exist In The Data Base";
}
}
}//check that the user name and the password is in the pattern that needed
public void RegisterClick()//make the registraion to the data base and create a profile
{
db = new DbPlayer();
if (check(firstName.text, Errors) && check(lastName.text, Errors) && check(Email.text, Errors) && check(confirm.text, Errors) && patternCheck(password.text, Errors) && patternCheck(userName.text, Errors))
{
if (!db.ExistUser(userName.text))
{
if (password.text.Equals(confirm.text))
{
PlayerData info = new PlayerData();
info.SetPlayer(firstName.text, lastName.text, Email.text, userName.text, password.text, profileImage.value);
db.InsertPlayer(info);
SceneManager.LoadScene("LoginPage");
}
else
{
Errors.text = "You Must Confirm The Password";
}
}
else
{
Errors.text = "User Name Is Allready Taken";
}
}
}
private void PlayersList_ItemClick(object sender, AdapterView.ItemClickEventArgs e)
{
ListView listview = (ListView)sender;
DetailedPlayerListAdapter adapter = listview.Adapter as DetailedPlayerListAdapter;
DbPlayer player = adapter.GetItem(e.Position);
ShowPlayerPopup(player);
}
public void AddPlayer(DbPlayer player)
{
DbUser user = player as DbUser;
string query = CreateInsertStatement(user, "User");
ExecuteSingleQuery(query);
query = $"INSERT INTO Player (Id, Team_Id, Number, Abbrevation) VALUES ('{user.Id}', '{player.TeamId}', '{player.Number}', '{player.Abbrevation}')";
ExecuteSingleQuery(query);
}
public static GridPlayer ToPlayer(this DbPlayer dbPlayer, IGame game)
{
var actions = dbPlayer.Class.Actions.Select(aref => aref.Action).Select(action => new GridTargetAction()
{
Name = action.Name,
TargetType = action.TargetType,
Id = action.Id,
Modifiers = action.Modifiers.Select(m => (IActionModifier) new GridActionModifier()
{
Name = m.Name, TargetType = m.TargetType, ModifierType = m.ModifierType, Min = m.Min, Max = m.Max
}).ToList(),
Element = new Element()
{
Id = action.ElementType.Id, Name = action.ElementType.Name, TextColor = action.ElementType.TextColor, Ranges = action.ElementType.Ranges.Select(r => (IElementRange) new ElementRange()
{
Text = r.Text, Min = r.Min, Max = r.Max, TextColor = r.TextColor
}).ToList()
}
}).ToList();
var player = new GridPlayer(
dbPlayer.Id,
dbPlayer.Name,
new List <EntityType>()
{
EntityType.Normal, EntityType.Combat
},
new List <IEntityComponent>()
{
},
dbPlayer.Items.Select(dbItem => dbItem.BaseItem.ToItem(
dbItem.Stats.Select(s =>
new BasicStat(s.Name, s.Base, s.Current)).ToList()
)).ToList(),
dbPlayer.Stats.Select(s => new BasicStat(s.Name, s.Base, s.Current)).ToList(),
game.World.Maps.FirstOrDefault(m => m.Id == dbPlayer.LastMap)
);
player.EntityTypes.ForEach(e =>
{
switch (e)
{
case EntityType.Combat:
var playerIntelligence = new PlayerIntelligence(actions.FirstOrDefault());
player.EntityComponents.Add(new GridCombatant()
{
AllowedActions = actions, Intelligence = playerIntelligence
});
playerIntelligence.Configure(player);
break;
}
});
return(player);
}
public ActionResult Edit([Bind(Include = "Id,FullName,NickName,PlayerID,SignatureHero,WinRate,SoloRating,RateStars")] DbPlayer dbPlayer)
{
if (ModelState.IsValid)
{
db.Entry(dbPlayer).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(dbPlayer));
}
public override void Save(Game entity)
{
var dbGame = DbGame.FromDomainModel(entity);
_unitOfWork.Store(dbGame, tran => GameDatabase.Temp(tran).GamesTable);
foreach (var dbPlayer in entity.Players.Select(p => DbPlayer.FromDomainModel(p, entity.Id)))
{
_unitOfWork.Store(dbPlayer, tran => GameDatabase.Temp(tran).PlayersTable);
}
}
public void UpdatePlayer(DbPlayer updatedPlayer)
{
SetDateAndUserUpdatedInfo(updatedPlayer);
var existingPlayer = _context.Players.FirstOrDefault(p => p.PlayerId == updatedPlayer.PlayerId);
existingPlayer.MapFrom(updatedPlayer);
_context.Players.AddOrUpdate(existingPlayer);
_context.SaveChanges();
}
public void DeletePlayer(DbPlayer deletedPlayer)
{
var existingPlayer = _context.Players.FirstOrDefault(p => p.PlayerId == deletedPlayer.PlayerId);
existingPlayer.IsDeleted = true;
SetDateAndUserUpdatedInfo(existingPlayer);
_context.Players.AddOrUpdate(existingPlayer);
_context.SaveChanges();
}
public ActionResult Create([Bind(Include = "Id,FullName,NickName,PlayerID,SignatureHero,WinRate,SoloRating,RateStars")] DbPlayer dbPlayer)
{
if (ModelState.IsValid)
{
db.DbPlayers.Add(dbPlayer);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(dbPlayer));
}
private void PlayerList_ItemClick(object sender, AdapterView.ItemClickEventArgs e)
{
ListView listview = (ListView)sender;
DetailedPlayerListAdapter adapter = listview.Adapter as DetailedPlayerListAdapter;
DbPlayer player = adapter.GetItem(e.Position);
zoneAdapter.Add(player);
addPlayerAction.Invoke(player);
zoneAdapter = null;
alert.Cancel();
}
private static DbPlayer MapDbPlayer(IDataRecord reader)
{
var dbPlayer = new DbPlayer
{
Id = reader.GetInt32(0),
Name = reader.GetString(1),
IdSite = reader.GetInt32(2),
IdAlias = reader.GetInt32(3)
};
return(dbPlayer);
}
/// <summary>
/// Creates a user.
/// </summary>
/// <returns><c>true</c>, if user was created, <c>false</c> otherwise.</returns>
/// <param name="name">The players name.</param>
/// <param name="password">Password.</param>
/// <param name="op">If set to <c>true</c> op.</param>
public static DbPlayer CreatePlayer(string name, string password, bool op = false)
{
#if DAPPER
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
{
var player = new DbPlayer(name, password)
{
Operator = op,
DateAdded = DateTime.UtcNow
};
player.Id = ctx.Insert(player, transaction: txn);
var hc = new HookContext();
var ha = new Events.HookArgs.PlayerRegistered()
{
Connection = ctx,
Transaction = txn,
Player = player
};
Events.HookPoints.PlayerRegistered.Invoke(ref hc, ref ha);
if (hc.Result == HookResult.DEFAULT)
{
txn.Commit();
return(player);
}
else
{
txn.Rollback();
return(null);
}
}
}
#else
using (var ctx = new TContext())
{
DbPlayer player;
ctx.Players.Add(player = new DbPlayer(name, password)
{
Operator = op,
DateAddedUTC = DateTime.UtcNow
});
ctx.SaveChanges();
return(player);
}
#endif
}
/// <summary>
/// Creates a new player.
/// </summary>
/// <param name="account">The account to associate with it.</param>
/// <returns>The newly created player.</returns>
public static Models.DbPlayer Create(Models.DbAccount account)
{
var player = new DbPlayer();
player.AccountId = account.Id;
player.Server = account.LastServer;
player.New = true;
player.Create();
player._account = account;
return(player);
}
}//check that the user name and the password is in the pattern that needed
public void RegisterClick()//make the registraion to the data base and create a profile
{
string patternA = @"[A-Za-z]$";//check if all are alfabet.
db = new DbPlayer();
Match matchFname = Regex.Match(firstName.text, patternA);
Match matchLname = Regex.Match(firstName.text, patternA);
Match matchEmail = Regex.Match(Email.text,
@"^(?("")("".+?(?<!\\)""@)|(([0-9a-z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-z])@))" +
@"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-z][-0-9a-z]*[0-9a-z]*\.)+[a-z0-9][\-a-z0-9]{0,22}[a-z0-9]))$");
if (check(firstName.text, Errors) && check(lastName.text, Errors) && check(Email.text, Errors) && check(confirm.text, Errors) && patternCheck(password.text, Errors) && patternCheck(userName.text, Errors))
{
if (matchEmail.Success && matchFname.Success && matchLname.Success)
{
if (!db.ExistUser(userName.text))
{
if (password.text.Equals(confirm.text))
{
PlayerData info = new PlayerData();
info.SetPlayer(firstName.text, lastName.text, Email.text, userName.text, password.text, profileImage.value);
db.InsertPlayer(info);
SceneManager.LoadScene("LoginPage");
}
else
{
Errors.text = "You Must Confirm The Password";
}
}
else
{
Errors.text = "User Name Is Allready Taken";
}
}
else
{
Errors.text = "Wrong input Email/First Name/Last Name";
}
}
}
// GET: DbPlayers/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
DbPlayer dbPlayer = db.DbPlayers.Find(id);
if (dbPlayer == null)
{
return(HttpNotFound());
}
return(View(dbPlayer));
}
public Player[] GetFormationForGame(Guid gameId)
{
List <Player> players = new List <Player>();
List <DbFormation> formation = myFormationDbManager.GetFormationByGameId(gameId).ToList();
formation.ForEach(f => {
DbPlayer dbPlayer = DbManager.Instance.PlayerDbManager.GetPlayerById(f.PlayerId);
EPlayerFunction currentFunction;
if (f.CurrentFunction.Equals("A"))
{
currentFunction = EPlayerFunction.Attack;
}
else if (f.CurrentFunction.Equals("D"))
{
currentFunction = EPlayerFunction.Defence;
}
else
{
currentFunction = EPlayerFunction.Substitute;
}
EPlayerFunction startFunction;
if (f.StartFunction.Equals("A"))
{
startFunction = EPlayerFunction.Attack;
}
else if (f.StartFunction.Equals("D"))
{
startFunction = EPlayerFunction.Defence;
}
else
{
startFunction = EPlayerFunction.Substitute;
}
players.Add(new Player
{
Id = dbPlayer.Id,
Abbrevation = dbPlayer.Abbrevation,
Number = dbPlayer.Number,
CurrentZoneFunction = currentFunction,
StartZoneFunction = startFunction,
Name = dbPlayer.Name,
FirstName = dbPlayer.FirstName
});
});
return(players.ToArray());
}
private void ShowPlayerPopup(DbPlayer player = null)
{
AlertDialog.Builder builder = new AlertDialog.Builder(this);
LayoutInflater inflater = LayoutInflater;
View view = inflater.Inflate(Resource.Layout.update_add_player_view, null);
EditText playerName = view.FindViewById <EditText>(Resource.Id.playerName);
EditText abbrevationName = view.FindViewById <EditText>(Resource.Id.playerAbbrevation);
EditText numberName = view.FindViewById <EditText>(Resource.Id.playerNumber);
bool newPlayer = false;
if (player != null)
{
playerName.Text = player.Name;
abbrevationName.Text = player.Abbrevation;
numberName.Text = player.Number.ToString();
}
else
{
player = new DbPlayer();
newPlayer = true;
}
//string text = MainViewModel.Instance.GetDb().ToString();
builder.SetView(view)
.SetPositiveButton("OK", (s, args) =>
{
player.Id = Guid.NewGuid();
player.Name = playerName.Text;
player.Abbrevation = abbrevationName.Text;
player.Number = Convert.ToInt16(numberName.Text);
player.TeamId = MainViewModel.Instance.Team.Id;
if (newPlayer)
{
myViewModel.AddPlayer(player);
}
else
{
myViewModel.UpdatePlayer(player);
}
})
.SetNegativeButton("Cancel", (s, args) => {
});
builder.Show();
}
public void UpdatePlayer_MapFrom_WorksCorrectly()
{
var originalPlayerLastName = _context.Players.FirstOrDefault(p => p.PlayerId == playerId).LastName;
var existingPlayer = _context.Players.FirstOrDefault(p => p.PlayerId == playerId);
var updatedPlayer = new DbPlayer
{
PlayerId = playerId,
FirstName = "John",
LastName = "Prufung",
Position = Position.Center,
TeamId = 1,
Status = Status.Available,
Salary = 3000,
GamesPlayed = 5,
Goals = 5,
Assists = 5,
Points = 10,
Wins = 0,
Losses = 0,
GoalsAgainstAverage = 0,
SavePercentage = 0,
LastModified = DateTime.UtcNow,
LastModifiedBy = "System Admin"
};
existingPlayer.MapFrom(updatedPlayer);
Assert.That(existingPlayer.FirstName, Is.EqualTo(updatedPlayer.FirstName));
Assert.That(existingPlayer.LastName, Is.EqualTo(updatedPlayer.LastName));
Assert.That(existingPlayer.Position, Is.EqualTo(updatedPlayer.Position));
Assert.That(existingPlayer.TeamId, Is.EqualTo(updatedPlayer.TeamId));
Assert.That(existingPlayer.Status, Is.EqualTo(updatedPlayer.Status));
Assert.That(existingPlayer.Salary, Is.EqualTo(updatedPlayer.Salary));
Assert.That(existingPlayer.GamesPlayed, Is.EqualTo(updatedPlayer.GamesPlayed));
Assert.That(existingPlayer.Goals, Is.EqualTo(updatedPlayer.Goals));
Assert.That(existingPlayer.Assists, Is.EqualTo(updatedPlayer.Assists));
Assert.That(existingPlayer.Points, Is.EqualTo(updatedPlayer.Points));
Assert.That(existingPlayer.Wins, Is.EqualTo(updatedPlayer.Wins));
Assert.That(existingPlayer.Losses, Is.EqualTo(updatedPlayer.Losses));
Assert.That(existingPlayer.GoalsAgainstAverage, Is.EqualTo(updatedPlayer.GoalsAgainstAverage));
Assert.That(existingPlayer.SavePercentage, Is.EqualTo(updatedPlayer.SavePercentage));
Assert.That(existingPlayer.LastModified, Is.EqualTo(updatedPlayer.LastModified));
Assert.That(existingPlayer.LastModifiedBy, Is.EqualTo(updatedPlayer.LastModifiedBy));
Assert.That(existingPlayer.LastName, Is.Not.EqualTo(originalPlayerLastName));
}
public void exitRoom()
{
buttonSound.Play();
DbRoom dbRoom = new DbRoom();
Room room = dbRoom.getRoomInfo();
if (isServer && players.Count > 1)
{
return;
}
DbPlayer db = new DbPlayer();
PlayerData Info = db.GetPlayerByUserName(localPlayer.playerPanel.userNameText.text);
Info.Money += localPlayer.money - 1000;
db.UpdatePlayer(Info);
RemovePlayer(localPlayer);
room.amountOfPlayers--;
dbRoom.UpdateRoom(room);
if (isServer)
{
dbRoom.deleteRoom(room);
NetworkManager.singleton.StopHost();
RemovePlayer(localPlayer);
//Destroy(LobbyScene.singleton.gameObject);
NetworkManager.singleton.StopClient();
Destroy(localPlayer);
NetworkManager.Shutdown();
//Debug.Log("after destroying the local player");
return;
}
if (!isServer && isClient)
{
RemovePlayer(localPlayer);
NetworkManager.singleton.StopClient();
Destroy(localPlayer);
return;
}
}//exit the room after saving the player new score in the data base to the lobby scene
public DbPlayer GetPlayerById(Guid playerId)
{
var localPlayer = myDbConnection.Table <DbPlayer>().FirstOrDefault(player => player.Id.Equals(playerId));
if (localPlayer != null)
{
return(localPlayer);
}
DbPlayer remotePlayer = myRemoteDb.GetPlayerById(playerId);
if (remotePlayer != null)
{
SaveToLocal(remotePlayer);
}
return(remotePlayer);
}
public ActionResult DeleteConfirmed(int id)
{
DbPlayer dbPlayer = db.DbPlayers.Find(id);
if (dbPlayer.PrimaryRole.Count > 0)
{
var firstRoleId = dbPlayer.PrimaryRole[0].Id;
for (int i = firstRoleId; i <= firstRoleId + dbPlayer.PrimaryRole.Count; i++)
{
var role = db.DbCurrencies.Find(i);
db.DbCurrencies.Remove(role);
}
}
db.DbPlayers.Remove(dbPlayer);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static void MapFrom(this DbPlayer existingPlayer, DbPlayer updatedPlayer)
{
existingPlayer.FirstName = updatedPlayer.FirstName;
existingPlayer.LastName = updatedPlayer.LastName;
existingPlayer.Position = updatedPlayer.Position;
existingPlayer.TeamId = updatedPlayer.TeamId;
existingPlayer.Status = updatedPlayer.Status;
existingPlayer.Salary = updatedPlayer.Salary;
existingPlayer.GamesPlayed = updatedPlayer.GamesPlayed;
existingPlayer.Goals = updatedPlayer.Goals;
existingPlayer.Assists = updatedPlayer.Assists;
existingPlayer.Points = updatedPlayer.Points;
existingPlayer.Wins = updatedPlayer.Wins;
existingPlayer.Losses = updatedPlayer.Losses;
existingPlayer.GoalsAgainstAverage = updatedPlayer.GoalsAgainstAverage;
existingPlayer.SavePercentage = updatedPlayer.SavePercentage;
existingPlayer.LastModified = updatedPlayer.LastModified;
existingPlayer.LastModifiedBy = updatedPlayer.LastModifiedBy;
}
public void ServerNextHand()//the Game restart
{
nextHandWaiting = true;
MainPot = 0;
ServerClearHands();
ServerEnterGameState(CardConstants.GameTurnState.ShufflingDeck, "Start Game", MainPot);
if (localPlayer.money == 0)
{
DbPlayer db = new DbPlayer();
PlayerData Info = db.GetPlayerByUserName(localPlayer.playerPanel.userNameText.text);
localPlayer.money += 1000;
Info.Money -= 1000;
db.UpdatePlayer(Info);
}
ServerNextState("ServerState_StartDeck");
}//stating the game after show down function
public static void MapFrom(this DbPlayer existingPlayer, DbPlayer updatedPlayer)
{
existingPlayer.FirstName = updatedPlayer.FirstName;
existingPlayer.LastName = updatedPlayer.LastName;
existingPlayer.Position = updatedPlayer.Position;
existingPlayer.TeamId = updatedPlayer.TeamId;
existingPlayer.Status = updatedPlayer.Status;
existingPlayer.Salary = updatedPlayer.Salary;
existingPlayer.GamesPlayed = updatedPlayer.GamesPlayed;
existingPlayer.Goals = updatedPlayer.Goals;
existingPlayer.Assists = updatedPlayer.Assists;
existingPlayer.Points = updatedPlayer.Points;
existingPlayer.Wins = updatedPlayer.Wins;
existingPlayer.Losses = updatedPlayer.Losses;
existingPlayer.GoalsAgainstAverage = updatedPlayer.GoalsAgainstAverage;
existingPlayer.SavePercentage = updatedPlayer.SavePercentage;
existingPlayer.LastModified = updatedPlayer.LastModified;
existingPlayer.LastModifiedBy = updatedPlayer.LastModifiedBy;
}
private void SavePlayers(Game gameEntity)
{
var existingPlayerIds = GetBaseQuery()
.Select("id").From(PlayerTableName).Where("game_id").Is(gameEntity.Id)
.ListLongs();
foreach (var playerEntity in gameEntity.Players)
{
var obj = DbPlayer.FromDomainModel(playerEntity, gameEntity.Id);
if (existingPlayerIds.Contains(playerEntity.Id))
{
GetBaseQuery().Update(PlayerTableName).SetWithoutIdFrom(obj).Where("id").Is(playerEntity.Id).Execute();
}
else
{
GetBaseQuery().InsertInto(PlayerTableName).InsertFrom(obj).Execute();
}
}
}
public async Task <IPlayer> NewPlayerAsync(IGame game, IPlayer player, string pass)
{
try
{
var gridPlayer = (GridPlayer)player;
var dbPlayer = new DbPlayer()
{
RecordBy = "notlinktoausercontextyet",
RecordDate = DateTimeOffset.Now,
Name = player.Name,
ClassId = 1,
Password = PasswordStorage.CreateHash(pass),
Stats = gridPlayer.Stats.Select(s => new DbPlayerStat()
{
Base = s.Base,
Current = s.Value,
Name = s.Name
}).ToList(),
Items = gridPlayer.Items.Select(i => new DbPlayerItem()
{
BaseItemId = i.Id,
Stats = i.Stats.Select(s => new DbPlayerItemStat()
{
Base = s.Base, Current = s.Value, Name = s.Name
}).ToList()
}
).ToList()
};
using (var context = new GameDbContext())
{
var trackedPlayer = context.Players.Add(dbPlayer);
await context.SaveChangesAsync();
return(trackedPlayer.Entity.ToPlayer(game));
}
}
catch (Exception ex)
{
_logger.LogWarning("new player rejected: " + ex.Message);
return(null);
}
}
/// <summary>
/// Creates a user.
/// </summary>
/// <returns><c>true</c>, if user was created, <c>false</c> otherwise.</returns>
/// <param name="name">The players name.</param>
/// <param name="password">Password.</param>
/// <param name="op">If set to <c>true</c> op.</param>
public static DbPlayer CreatePlayer(string name, string password, bool op = false)
{
#if DAPPER
using (var ctx = DatabaseFactory.CreateConnection())
{
using (var txn = ctx.BeginTransaction())
{
var player = new DbPlayer(name, password)
{
Operator = op,
DateAdded = DateTime.UtcNow
};
player.Id = ctx.Insert(player, transaction: txn);
var hc = new HookContext();
var ha = new Events.HookArgs.PlayerRegistered()
{
Connection = ctx,
Transaction = txn,
Player = player
};
Events.HookPoints.PlayerRegistered.Invoke(ref hc, ref ha);
if (hc.Result == HookResult.DEFAULT)
{
txn.Commit();
return player;
}
else
{
txn.Rollback();
return null;
}
}
}
#else
using (var ctx = new TContext())
{
DbPlayer player;
ctx.Players.Add(player = new DbPlayer(name, password)
{
Operator = op,
DateAddedUTC = DateTime.UtcNow
});
ctx.SaveChanges();
return player;
}
#endif
}
