public DGVPlayer(DBPlayer dbPlayer, string teamName, Image playerCountryFlag) :
base(dbPlayer.PlayerTournamentId, dbPlayer.PlayerId, dbPlayer.PlayerName,
dbPlayer.PlayerTeamId, dbPlayer.PlayerCountryName)
{
PlayerTeamName = teamName;
PlayerCountryFlag = playerCountryFlag;
}
public List <DBPlayer> GetHighScores()
{
List <DBPlayer> highScores = new List <DBPlayer>();
DataTable dt = Query("usp_GetHighScores");
if (dt != null)
{
foreach (DataRow row in dt.Rows)
{
string name = Convert.ToString(row["Username"]);
int score = Convert.ToInt32(row["Experience"]);
float money = Convert.ToInt32(row["Money"]);
DBPlayer player = new DBPlayer()
{
Username = name,
Experience = score,
Money = money
};
highScores.Add(player);
}
}
else
{
Debug.Log("*SQL - GetHighScores: Table is empty.");
}
return(highScores);
}
public IEnumerator Register(HttpListenerContext sender, string username, string password)
{
Debug.Log("Registration starting");
RestClient.Get <DBPlayer>("https://" + firebaseExtension + ".firebaseio.com/" + username + ".json").Then(response =>
{
if (response != null)
{
Debug.Log("Username taken");
ConstructResponse(sender, "Username taken");
}
else
{
try
{
DBPlayer player = new DBPlayer(username, Hash(password));
RestClient.Put <ResponseHelper>("https://" + firebaseExtension + ".firebaseio.com/" + username + ".json", player);
Debug.Log("Account made");
// return the http response now
string randToken = RandomToken();
Player newPlayer = new Player(player, randToken);
playerHash[randToken] = player.hash;
playerDB[randToken] = newPlayer;
game.PlayerEnter(newPlayer, randToken);
string xmlString = Encode_XML(player, typeof(DBPlayer));
string[][] equipKeys = new string[3][] {
(new List <string>(game.equipments["Clothing"].Keys)).ToArray(),
(new List <string>(game.equipments["Weapons"].Keys)).ToArray(),
(new List <string>(game.equipments["Items"].Keys)).ToArray()
};
string[][] equipVals = new string[3][] {
(new List <string>(game.equipments["Clothing"].Values)).ToArray(),
(new List <string>(game.equipments["Weapons"].Values)).ToArray(),
(new List <string>(game.equipments["Items"].Values)).ToArray()
};
string EquipmentXML1 = Encode_XML(equipKeys, typeof(string[][]));
string EquipmentXML2 = Encode_XML(equipVals, typeof(string[][]));
if (sender != null) // sender is null during testing
{
ConstructResponse(sender, "Creation success, token:" + randToken + ", Equipment Keys:" + EquipmentXML1 +
", Equipment Values:" + EquipmentXML2 + ", Player Data:" + xmlString);
}
}catch (Exception e)
{
Debug.Log(e);
}
}
});
yield return(0);
}
public DBPlayer GetRole(uint roleid)
{
CharacterOBJ c = GetPlayer(roleid);
if (c != null)
{
DBPlayer player = new DBPlayer
{
Base = new DBPlayerBase()
{
UserId = Id,
PlayerId = roleid,
ModelId = (byte)c.SkinId
},
Custom = new DBCustomisation()
{
PlayerName = PlayerName,
SkinColorId = c.SkinColorId,
HairColorId = c.HairColorId,
EyeColorId = c.EyeColorId,
ShirtColorId = c.ShirtColorId,
PantsColorId = c.PantsColorId,
BootsColorId = c.BootsColorId,
GlovesColorId = c.GlovesColorId
},
Status = new DBStatus()
{
Level = (uint)Level,
Exp = (uint)Exp,
MMR = (uint)LeaguePoints,
Kills = (uint)Kills,
Deaths = (uint)Deaths,
Golden = (uint)Gold,
Silver = (uint)Silver
}
};
List <DBPlayerActive> activx = new List <DBPlayerActive>();
foreach (KeyValuePair <int, ActivesOBJ> a in Actives)
{
if (a.Value.CanNetSend())
{
activx.Add(new DBPlayerActive()
{
ActiveId = (uint)a.Value.ActiveId, Value = (uint)a.Value.Value
});
}
}
player.Actives = activx.ToArray();
return(player);
}
return(default(DBPlayer));
}
public bool UpdatePlayer(DBPlayer player)
{
Dictionary <string, object> pars = new Dictionary <string, object>()
{
{ "@username", player.Username },
{ "@experience", player.Experience },
{ "@money", player.Money }
};
return(NonQuery("usp_UpdatePlayer", pars));
}
public static Point GetEntityCoordinates(string id)
{
using (MongoCRUD mongo = new MongoCRUD("Reldawin"))
{
DBPlayer player = mongo.GetRecord <DBPlayer>("player", new Guid(id));
Point p = new Point(player.Entity.WorldPositionX, player.Entity.WorldPositionY);
return(p);
}
}
public static bool DoesUserExist(string username)
{
using (MongoCRUD mongo = new MongoCRUD("Reldawin"))
{
DBPlayer player = mongo.GetRecord <DBPlayer>("player", new MongoCRUD.Condition {
field = "Username", value = username
});
bool doesPlayerExist = player != null ? true : false;
return(doesPlayerExist);
}
}
public bool AddPlayer(DBPlayer player, string password)
{
Dictionary <string, object> pars = new Dictionary <string, object>()
{
{ "@username", player.Username },
{ "@experience", player.Experience },
{ "@money", player.Money },
{ "@password", password }
};
return(NonQuery("usp_AddPlayer", pars));
}
public void ShowPlayerWithIdProfile(long idToShow)
{
DBPlayer player = NetworkDatabase.NDB.GetPlayerById(idToShow);
GameObject playerGO = Instantiate(playerProfilePrefab, transform) as GameObject;
//playerGO.GetComponent<Button>().onClick.AddListener(() => Destroy(playerGO));
Transform playerGOPanel = playerGO.transform.GetChild(1);
if (NetworkDatabase.NDB.TryDownloadPlayerProfile(player))
{
playerGOPanel.GetChild(0).GetComponentInChildren <Image>().sprite = FilePath.loadNewSprite(player.FP.Path);
}
playerGOPanel.gameObject.GetComponentInChildren <TextMeshProUGUI>().text = player.PlayerName;
}
private int GetOwnerPlayerNameId(string newName)
{
DBPlayer ownerPlayer = _players.Find(x => x.PlayerName.Equals(newName,
StringComparison.InvariantCulture));
if (ownerPlayer == null)
{
return(0);
}
else
{
return(ownerPlayer.PlayerId);
}
}
public IEnumerator Logout(HttpListenerContext sender, string token)
{
Player player = playerDB[token];
DBPlayer saveDava = new DBPlayer(player, playerHash[token]);
RestClient.Put <ResponseHelper>("https://" + firebaseExtension + ".firebaseio.com/" + saveDava.username + ".json", saveDava);
if (sender != null) // sender is null during testing
{
ConstructResponse(sender, "You have been logged out");
}
yield return(0);
}
public static string[] GetPlayerPasswordAndID(string username)
{
using (MongoCRUD mongo = new MongoCRUD("Reldawin"))
{
DBPlayer player = mongo.GetRecord <DBPlayer>("player", new MongoCRUD.Condition {
field = "Username", value = username
});
string[] result = new string[2] {
player.Password, player.ID.ToString()
};
return(result);
}
}
public override void Execute()
{
var p = Session.QueryOver <DBPlayer>()
.Where(x => x.PlayerName == this.Player2Save.PlayerName)
.SingleOrDefault();
if (p == null)
{
p = new DBPlayer();
}
AutoMapper.Mapper.Map <Player, DBPlayer>(Player2Save, p);
Session.SaveOrUpdate(p);
Result = AutoMapper.Mapper.Map <Player>(p);
}
public ActorCard(ActorBase pOwner)
{
Owner = pOwner;
this.SetName();
this.SetLevel();
if (Owner is ActorPlayer)
{
int playerId = GameEntry.Database.GetPlayerId();
m_Role = GameEntry.Database.GetDBRow <DBPlayer>(playerId);
this.SetPartnerByPos(1, m_Role.Partner1Id);
this.SetPartnerByPos(2, m_Role.Partner2Id);
this.SetPartnerByPos(3, m_Role.Partner3Id);
}
m_Data = GameEntry.DataTable.GetDataTable <DRActorEntity>().GetDataRow(Owner.Id);
}
public static void CreateAccount(string username, string password)
{
Random rand = new Random();
DBPlayer dBPlayer = new DBPlayer
{
Password = password,
Username = username,
Entity = new DBEntity
{
WorldPositionX = rand.Next(0, Program.MapWidth),
WorldPositionY = rand.Next(0, Program.MapHeight)
}
};
using (MongoCRUD mongo = new MongoCRUD("Reldawin"))
{
mongo.InsertRecord <DBPlayer>("player", dBPlayer);
}
}
/// <summary>
/// Coroutine
/// Use to register the player on the server
/// stores the player locally when succesful
/// </summary>
private IEnumerator RegisterUserToDB(string email, string username, string password)
{
WWWForm form = new WWWForm();
form.AddField("loginEmail", email);
form.AddField("loginUser", username);
form.AddField("loginPass", password);
//POST to RegisterUser.php on my server
using (UnityWebRequest www = UnityWebRequest.Post("https://marlonsijnesael.nl/DB/RegisterUser.php", form))
{
yield return(www.SendWebRequest());
//if there's an error -> show it on the screen
if (www.isNetworkError || www.isHttpError)
{
Debug.LogError(www.error);
statusText.text = www.error;
}
else
{
//RegisterUser.php returns a json string containing information about the player (username, session token, login succesful, errors)
//In order to use it we have to deserialize it into a class called DBPlayer
DBPlayer user = JsonUtility.FromJson <DBPlayer>(www.downloadHandler.text);
if (user.success)
{
statusText.text = "SUCCES!";
if (MasterManager.instance != null)
{
MasterManager.instance.SetDbPlayer(user);
}
}
else
{
statusText.text = user.error;
input_Username.inputField.textComponent.color = Color.red;
}
}
}
}
private bool FillPlayerHeaders(bool shouldSave)
{
if (IsAllPlayersIdsSelected() && !IsPlayerIdRepeated())
{
if (shouldSave)
{
_db.UpdateTableAllPlayersPositions(_table);
}
DBPlayer playerEast = _tablePlayers.Find(x => x.PlayerId == int.Parse(_table.PlayerEastId));
DBPlayer playerSouth = _tablePlayers.Find(x => x.PlayerId == int.Parse(_table.PlayerSouthId));
DBPlayer playerWest = _tablePlayers.Find(x => x.PlayerId == int.Parse(_table.PlayerWestId));
DBPlayer playerNorth = _tablePlayers.Find(x => x.PlayerId == int.Parse(_table.PlayerNorthId));
_form.SetEastPlayerHeader(string.Format("{0} ({1})", playerEast.PlayerName, playerEast.PlayerId));
_form.SetSouthPlayerHeader(string.Format("{0} ({1})", playerSouth.PlayerName, playerSouth.PlayerId));
_form.SetWestPlayerHeader(string.Format("{0} ({1})", playerWest.PlayerName, playerWest.PlayerId));
_form.SetNorthPlayerHeader(string.Format("{0} ({1})", playerNorth.PlayerName, playerNorth.PlayerId));
FillAllPlayersTotalScores();
FillAllPlayersPoints();
return(true);
}
return(false);
}
//log out and return to login screen
//also destroy this object in order to make room for a new singleton instance
//because this one does not have its references anymore
public void LogOut()
{
user = null;
SceneManager.LoadScene(0);
Destroy(this.gameObject);
}
public void SaveGame(int saveSlot, string saveName = null)
{
BinaryFormatter bf = new BinaryFormatter();
GameModeOffice gmOffice = GameModeManager.Office;
GameModeShop gmShop = GameModeManager.Shop;
Player.CharacterCustomizationData = CurrentPlayerObject.GetComponent <CharacterCustomizationScript>().GetCustomizationData();
Player.OfficeCustomizationData = CustomizationManager.Office.GetCustomizationData();
//Save data to GameData object (saveData):
GameData gameData = new GameData
{
Player = this.Player,
Suppliers = SupplierManager.Suppliers,
Orders = OrderManager.Orders,
OrdersCountOpen = OrderManager.CountOpen,
OrdersCountCompleted = OrderManager.CountCompleted,
OrdersCountFailed = OrderManager.CountFailed,
OrdersCountCompletedToday = OrderManager.CountCompletedToday,
OrdersCountFailedToday = OrderManager.CountFailedToday,
Difficulty = this.Difficulty,
GameDateTime = this.GameDateTime,
GameDateTimeStart = this.GameDateTimeStart,
DayDebt = this.DayDebt,
WeekCurrent = this.WeekCurrent,
ChanceNextOrder = gmOffice.ChanceNextOrder,
ShopUnlocked = this.ShopUnlocked,
DayEnd = this.DayEnd,
DayEndCurrent = this.dayEndCurrent,
Notifications = this.Notifications,
GameMode = GameModeManager.GameMode_Current
};
if (saveName == null || saveName == "")
{
saveName = string.Format("{0} {1}", SaveNameDefault, saveSlot.ToString().PadLeft(3, '0'));
}
Debug.Log(saveName);
SaveData saveData = new SaveData
{
Name = saveName,
Date = DateTime.Now,
GameData = gameData
};
FileStream file = File.Create(GetSaveFilePath(saveSlot));
bf.Serialize(file, saveData);
file.Close();
//UPDATE DB:
if (!OfflineMode)
{
DBPlayer p = Player.GetDBPlayer();
Debug.Log(p.Username + p.Experience + p.Money);
bool s = DBManager.UpdatePlayer(Player.GetDBPlayer());
if (!s)
{
Debug.Log("Uh oh");
}
else
{
Debug.Log("Player updated.");
}
}
//LOG:
Debug.Log("[SAVE SLOT: " + saveSlot.ToString() + "] GAME DATA SAVED TO '" + Application.persistentDataPath + "'!");
}
public void Register_RegisterButtonPressed()
{
if (GameMaster.Instance.OfflineMode)
{
GameMaster.Instance.OfflineMode = false;
}
//Called when the player presses the button to register
//Get the username and password and repeated password the player entered
playerUsername = RegisterUsernameField.text;
playerPassword = RegisterPasswordField.text;
string confirmedPassword = RegisterConfirmPasswordField.text;
//Make sure username and password are long enough
if (playerUsername.Length > 3 && playerUsername.Length <= 15)
{
if (!GameMaster.Instance.DBManager.CheckUsername(playerUsername))
{
if (playerPassword.Length > 5 && playerPassword.Length <= 25)
{
//Check the two passwords entered match
if (playerPassword == confirmedPassword)
{
//Username and passwords seem reasonable. Switch to 'Loading...' and start the coroutine to try and register an account on the server
registerP.gameObject.SetActive(false);
loadingP.gameObject.SetActive(true);
StartCoroutine(MainMenus());
DBPlayer player = new DBPlayer()
{
Username = playerUsername,
Experience = 0,
Money = 0f
};
if (GameMaster.Instance.DBManager.AddPlayer(player, playerPassword))
{
Debug.Log("*Player added!");
}
GameMaster.Instance.CurrentUsername = playerUsername;
}
else
{
//Passwords don't match, show error
RegisterErrorText.text = "Error: Passwords do not match";
}
}
else
{
//Password too short so show error
RegisterErrorText.text = "Error: Password must contain 6-25 characters";
}
}
else
{
//Username taken
RegisterErrorText.text = "Error: Username has already been taken";
}
}
else
{
//Username too short so show error
RegisterErrorText.text = "Error: Username must contain 4-15 characters";
}
}
/// <summary>
/// Returns null if player not found
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public Player GetPlayer(int id, IAreaLocator al, IShipLocator sl, IAccountLocator acl, ITeamLocator tl, ITeamManager tm)
{
DBPlayer p = _galacticObjectContext.Players.First(ee => ee.Id == id);
return(p != null ? new Player(p, al, sl, acl, tl, tm) : null);
}
public DBPlayer GetPlayer(string playerId)
{
DBPlayer player = new DBPlayer(playerId);
return(player);
}
private void HTTPRecieved(IAsyncResult result) // callback function for when we get an http request
{
Debug.Log("HTTP recieved");
HttpListener listener = (HttpListener)result.AsyncState;
HttpListenerContext context = listener.EndGetContext(result);
// do stuff
string startData = GetRequestPostData(context.Request);
Debug.Log(startData);
string[] dataSent = startData.Split('&');
Debug.Log(dataSent.Length);
Dictionary <string, string> data = new Dictionary <string, string> {
};
foreach (string d in dataSent)
{
string[] cell = d.Split('=');
data[cell[0].Replace("%20", " ")] = cell[1].Replace("%20", " ");
Debug.Log(cell[0] + ":" + cell[1]);
}
if (!data.ContainsKey("request"))
{
ConstructResponse(context, "Request not included");
return;
}
else if (data.ContainsKey("token") && !playerDB.ContainsKey(data["token"]))
{
ConstructResponse(context, "Token does not exist");
return;
}
// handling the differant kinds of requests they want
// login/register/logout
if (data["request"].Equals("register") && data.ContainsKey("username") && data.ContainsKey("password"))
{
StartCoroutine(Register(context, data["username"], data["password"]));
}
else if (data["request"].Equals("login") && data.ContainsKey("username") && data.ContainsKey("password"))
{
StartCoroutine(LogIn(context, data["username"], data["password"]));
}
else if (data["request"].Equals("logout") && data.ContainsKey("token"))
{
StartCoroutine(Logout(context, data["token"]));
}
// debugging purposes
else if (data["request"].Equals("time compare"))
{
Debug.Log(Time.time - float.Parse(data["timer"]));
}
// purchasing stuff
else if (data["request"].Equals("purchase") && data.ContainsKey("item type") && data.ContainsKey("item name"))
{
game.Purchase(data["token"], data["item type"], data["item name"]);
}
// equipment changes
else if (data["request"].Equals("equip") && data.ContainsKey("equipment type") && data.ContainsKey("equipment name"))
{
Player player = playerDB[data["token"]];
if (data["equipment type"].Equals("Weapon"))
{
if (!(Array.Exists(player.GetWeapons(), element => element.Equals(data["equipment name"]))))
{ // check if they own the item
Debug.Log("They do not own a " + data["equipment name"]);
ConstructResponse(context, "You do not own this item");
return;
}
Debug.Log("Replacing weapon to " + data["equipment name"]);
Weapon item = new Weapon(null, "Not important", game.equipments["Weapons"][data["equipment name"]]);
if (item.weaponType == 0)
{
player.ChangeEquipped(4, data["equipment name"]);
}
else if (item.weaponType == 1)
{
player.ChangeEquipped(5, data["equipment name"]);
}
}
else
{
if (!(Array.Exists(player.GetClothing(), element => element.Equals(data["equipment name"]))))
{ // check if they own the item
Debug.Log("They do not own a " + data["equipment name"]);
ConstructResponse(context, "You do not own this item");
return;
}
int correspondingIndex = (new Dictionary <string, int> {
{ "Helmets", 0 },
{ "Armour", 1 }, { "Boots", 2 }, { "Pendants", 3 }
})[data["equipment type"]];
player.ChangeEquipped(correspondingIndex, data["equipment name"]);
}
ConstructResponse(context, "Item equipped");
}
// asking for stats because the game told them to
else if (data["request"].Equals("stats")) // overall max stats
{
Player player = playerDB[data["token"]];
DBPlayer fakeDB = new DBPlayer(player, "unimportant hash");
string xmlString = Encode_XML(fakeDB, typeof(DBPlayer));
if (game.deadPlayers.Contains(player))
{
game.deadPlayers.Remove(player);
ConstructResponse(context, "DEAD");
}
else
{
game.updatePlayer[player] = false;
ConstructResponse(context, xmlString);
}
}
else // they did not match any of the criteria
{
ConstructResponse(context, "Invalid arguements");
}
}
public void SetPlayer(DBPlayer player)
{
players[player.PlayerID] = player;
}
/// <summary>
/// Constructor to instantiate _dpPlayer
/// </summary>
public PlayerController()
{
_dbPlayer = new DBPlayer();
}
//make the userinfo persistent inside of the singleton
public void SetDbPlayer(DBPlayer user)
{
this.user = user;
SceneManager.LoadScene("Lobby");
}
public bool Execute(JHSNetworkMessage netMsg)
{
if (DbManager == null)
{
DbManager = AccountManager.Instance;
}
if (queueManager == null)
{
queueManager = GameServerManager.Instance;
}
if (dbService == null)
{
dbService = DbService.Instance;
}
ReqeuestUser packet = netMsg.ReadMessage <ReqeuestUser>();
if (packet != null)
{
uint connectionId = netMsg.conn.connectionId;
var server = queueManager.GetServerByConnectionId(connectionId);
if (server != null || Settings.DEBUG_GET_PLAYER)
{
AccountOBJ user = DbManager.GetOnlineByUserId(packet.userId);
if (Settings.DEBUG_GET_PLAYER && user == null)
{
user = dbService.GetAccountFromDB(packet.userId);
user.SelectedCharacer = user.FirstRole().PlayerId;
}
if (user != null)
{
if (user.SelectedCharacer != 0)
{
DBPlayer role = user.GetRole(user.SelectedCharacer);
if (role != null)
{
if (packet.Type == InfoType.NONE)
{
netMsg.conn.Send(GameServerOP.GETROLE, new LoginDataBasePlayer()
{
STATUS = SUCCESS,
player = role,
REQ = packet.Req
});
}
else
{
netMsg.conn.Send(GameServerOP.GET_ROLE2, new UpdateRole()
{
STATUS = SUCCESS,
player = role,
TYPE = packet.Type
});
}
LOG.Info(string.Format("GETRole :: REQ[{3}] id[{0}] userid[{1}] serverid[{2}]", role.Base.PlayerId, role.Base.UserId, connectionId, packet.Req));
return(true);
}
}
}
netMsg.conn.Send(GameServerOP.GETROLE, new LoginDataBasePlayer()
{
STATUS = PLAYER_NOT_FOUND
});
}
}
return(true);
}
// -------------- Class constructor --------------
public Player(DBPlayer player, string token) // gets the html from server, sets up player data
{
Username = player.username;
Token = token;
// -------- load all the info into the private fields, DBPlayer loses referance and dies afterwards --------
// Equipment
Debug.Log("Right hand: " + player.equipped[5]);
equipped = player.equipped;
foreach (string name in player.clothing) // Clothing
{
if (clothing.ContainsKey(name))
{
clothing[name].NewCount(clothing[name].HowMany() + 1);
}
else
{
clothing[name] = new Clothing(this, name, game.equipments["Clothing"][name]);
}
}
foreach (string name in player.weapons) // Weapons
{
if (weapons.ContainsKey(name))
{
weapons[name].NewCount(weapons[name].HowMany() + 1);
}
else
{
weapons[name] = new Weapon(this, name, game.equipments["Weapons"][name]);
}
}
foreach (string name in player.items) // Items
{
if (items.ContainsKey(name))
{
items[name].NewCount(items[name].HowMany() + 1);
}
else
{
items[name] = new Item(this, name, game.equipments["Items"][name]);
}
}
// stats
gold = player.gold;
score = player.score;
chosenTitle = player.chosenTitle;
titles = new List <string>(player.titles);
// quests
mainProgress = player.questProg;
for (int i = 0; i < player.optionalQuests.Length; i++)
{
optionalQuests[player.optionalQuests[i]] = player.optionalProg[i];
}
// skills
foreach (string name in player.magicSpells)
{
magicSpells[name] = new Magic(name);
}
foreach (string name in player.attackSkills)
{
attackSkills[name] = new Attack(name);
}
foreach (string name in player.playerAbilities)
{
playerAbilities[name] = new Skill(name);
}
ReCalculate(); // get new stats and all for player before slapping them into the game
hp[1] = hp[0];
mana[1] = mana[0];
stamina[1] = stamina[0];
}
