425 lines
14 KiB
C++
425 lines
14 KiB
C++
#include "contrib/sqlite/sqlite3pp.h"
|
|
#include "contrib/bcrypt/BCrypt.hpp"
|
|
#include "CNProtocol.hpp"
|
|
#include "Database.hpp"
|
|
#include "CNStructs.hpp"
|
|
#include "settings.hpp"
|
|
#include "Player.hpp"
|
|
#include <regex>
|
|
#include <fstream>
|
|
#include "contrib/JSON.hpp"
|
|
|
|
|
|
//TODO: replace this sqlite wrapper with something better, clean up queries, get rid of json
|
|
|
|
sqlite3pp::database db;
|
|
|
|
void Database::open() {
|
|
//checking if database file exists
|
|
std::ifstream file;
|
|
file.open("data.db");
|
|
|
|
if (file) {
|
|
file.close();
|
|
// if exists, assign it
|
|
db = sqlite3pp::database("data.db");
|
|
DEBUGLOG(std::cout << "[DB] Database in operation" << std::endl; )
|
|
}
|
|
else {
|
|
// if doesn't, create all the tables
|
|
DEBUGLOG(std::cout << "[DB] Creating new database" << std::endl;)
|
|
db = sqlite3pp::database("data.db");
|
|
|
|
// creates accounts
|
|
db.execute("CREATE TABLE Accounts(AccountID INTEGER PRIMARY KEY AUTOINCREMENT, Login TEXT NOT NULL, Password TEXT NOT NULL);");
|
|
// creates characters
|
|
db.execute("CREATE TABLE Players(PlayerID INTEGER PRIMARY KEY AUTOINCREMENT, AccountID INTEGER NOT NULL, Slot INTEGER NOT NULL, FirstName TEXT NOT NULL, LastName TEXT NOT NULL, CharData TEXT NOT NULL);");
|
|
|
|
DEBUGLOG(std::cout << "Done" << std::endl;)
|
|
}
|
|
}
|
|
|
|
// verifies that the username & passwords are valid
|
|
bool Database::isLoginDataGood(std::string login, std::string password) {
|
|
std::regex loginRegex("^([A-Za-z\\d_\\-]){5,20}$");
|
|
std::regex passwordRegex("^([A-Za-z\\d_\\-@$!%*#?&,.+:;<=>]){2,20}$");
|
|
return (std::regex_match(login, loginRegex) && std::regex_match(password, passwordRegex));
|
|
}
|
|
|
|
void Database::addAccount(std::string login, std::string password) {
|
|
// generates prepared statment
|
|
sqlite3pp::command cmd(db, "INSERT INTO Accounts (Login, Password) VALUES (:login, :password)");
|
|
|
|
// generates a hashed password!
|
|
password = BCrypt::generateHash(password);
|
|
|
|
// binds args to the command
|
|
cmd.bind(":login", login, sqlite3pp::nocopy);
|
|
cmd.bind(":password", password, sqlite3pp::nocopy);
|
|
cmd.execute();
|
|
}
|
|
|
|
bool Database::doesUserExist(std::string login) {
|
|
// generates prepared statement
|
|
sqlite3pp::query qry(db, "SELECT COUNT(AccountID) FROM Accounts WHERE Login = :login");
|
|
// binds to the query
|
|
qry.bind(":login", login, sqlite3pp::nocopy);
|
|
|
|
// executes
|
|
sqlite3pp::query::iterator i = qry.begin();
|
|
|
|
// grabs the first result (the count)
|
|
int result;
|
|
std::tie(result) = (*i).get_columns<int>(0);
|
|
|
|
// if there is more than 0 results, the user exists :eyes:
|
|
return (result > 0);
|
|
}
|
|
|
|
bool Database::isPasswordCorrect(std::string login, std::string password) {
|
|
// generates prepared statement
|
|
sqlite3pp::query qry(db, "SELECT Password FROM Accounts WHERE Login = :login");
|
|
// binds username to the query
|
|
qry.bind(":login", login, sqlite3pp::nocopy);
|
|
|
|
// executes
|
|
sqlite3pp::query::iterator i = qry.begin();
|
|
|
|
// grabs the first result
|
|
const char* actual;
|
|
std::tie(actual) = (*i).get_columns<const char*>(0);
|
|
|
|
// validate password hash with provded password
|
|
return BCrypt::validatePassword(password, actual);
|
|
}
|
|
|
|
int Database::getUserID(std::string login) {
|
|
// generates prep statement
|
|
sqlite3pp::query qry(db, "SELECT AccountID FROM Accounts WHERE Login = :login");
|
|
// binds the username to the login param
|
|
qry.bind(":login", login, sqlite3pp::nocopy);
|
|
|
|
// executes the query
|
|
sqlite3pp::query::iterator i = qry.begin();
|
|
|
|
// grabs the first result of the query
|
|
int result;
|
|
std::tie(result) = (*i).get_columns<int>(0);
|
|
|
|
// returns the result
|
|
return result;
|
|
}
|
|
|
|
int Database::getUserSlotsNum(int AccountId) {
|
|
// generates the prepared statement
|
|
sqlite3pp::query qry(db, "SELECT COUNT(PlayerID) FROM Players WHERE AccountID = :ID");
|
|
|
|
// binds the ID to the param
|
|
qry.bind(":ID", AccountId);
|
|
|
|
// executes
|
|
sqlite3pp::query::iterator i = qry.begin();
|
|
|
|
// grabs the first result
|
|
int result;
|
|
std::tie(result) = (*i).get_columns<int>(0);
|
|
|
|
// returns the result
|
|
return result;
|
|
}
|
|
|
|
bool Database::isNameFree(std::string First, std::string Second) {
|
|
// generates the prepared statement
|
|
sqlite3pp::query qry(db, "SELECT COUNT(PlayerID) FROM Players WHERE FirstName = :First COLLATE nocase AND LastName = :Second COLLATE nocase");
|
|
|
|
// binds the params
|
|
qry.bind(":First", First, sqlite3pp::nocopy);
|
|
qry.bind(":Second", Second, sqlite3pp::nocopy);
|
|
|
|
// executes the query
|
|
sqlite3pp::query::iterator i = qry.begin();
|
|
|
|
// grabs the result
|
|
int result;
|
|
std::tie(result) = (*i).get_columns<int>(0);
|
|
|
|
// if no results return, the the username is unused
|
|
return (result == 0);
|
|
}
|
|
|
|
void Database::createCharacter(sP_CL2LS_REQ_SAVE_CHAR_NAME* save, int AccountID) {
|
|
// generate the command
|
|
sqlite3pp::command cmd(db, "INSERT INTO Players (AccountID, Slot, FirstName, LastName, CharData) VALUES (:AccountID, :Slot, :FirstName, :LastName, :CharData)");
|
|
|
|
// generate character data
|
|
std::string charData = CharacterToJson(save);
|
|
std::string first = U16toU8(save->szFirstName);
|
|
std::string last = U16toU8(save->szLastName);
|
|
|
|
// bind to command
|
|
cmd.bind(":AccountID", AccountID);
|
|
cmd.bind(":Slot", save->iSlotNum);
|
|
cmd.bind(":CharData", charData, sqlite3pp::nocopy);
|
|
cmd.bind(":FirstName", first, sqlite3pp::nocopy);
|
|
cmd.bind(":LastName", last, sqlite3pp::nocopy);
|
|
|
|
// run
|
|
cmd.execute();
|
|
}
|
|
|
|
void Database::finishCharacter(sP_CL2LS_REQ_CHAR_CREATE* character) {
|
|
sqlite3pp::command cmd(db, "UPDATE Players SET CharData = :data WHERE PlayerID = :id");
|
|
|
|
// grab the data to add to the command
|
|
int id = character->PCStyle.iPC_UID;
|
|
std::string charData = CharacterToJson(character);
|
|
|
|
// bind to the command & execute
|
|
cmd.bind(":data", charData, sqlite3pp::nocopy);
|
|
cmd.bind(":id", id);
|
|
cmd.execute();
|
|
}
|
|
|
|
void Database::finishTutorial(int PlayerID) {
|
|
sqlite3pp::query qry(db, "SELECT CharData FROM Players WHERE PlayerID = :ID");
|
|
|
|
// bind to the query and execute
|
|
qry.bind(":ID", PlayerID);
|
|
sqlite3pp::query::iterator i = qry.begin();
|
|
|
|
// grab the player json from the database
|
|
std::string json;
|
|
std::tie(json) = (*i).get_columns<std::string>(0);
|
|
|
|
// parse the json into a Player
|
|
Player player = JsonToPlayer(json, PlayerID);
|
|
|
|
// set the tutorial flag & equip lightning gun
|
|
player.PCStyle2.iTutorialFlag = 1;
|
|
player.Equip[0].iID = 328;
|
|
json = PlayerToJson(player);
|
|
|
|
// update the database
|
|
sqlite3pp::command cmd(db, "UPDATE Players SET CharData = :data WHERE PlayerID = :id");
|
|
cmd.bind(":data", json, sqlite3pp::nocopy);
|
|
cmd.bind(":id", PlayerID);
|
|
cmd.execute();
|
|
}
|
|
|
|
int Database::getCharacterID(int AccountID, int slot) {
|
|
// make the query
|
|
sqlite3pp::query qry(db, "SELECT PlayerID FROM Players WHERE AccountID = :ID AND Slot = :Slot");
|
|
|
|
// bind the params & execute
|
|
qry.bind(":ID", AccountID);
|
|
qry.bind(":Slot", slot);
|
|
sqlite3pp::query::iterator i = qry.begin();
|
|
|
|
// grab the result
|
|
int result;
|
|
std::tie(result) = (*i).get_columns<int>(0);
|
|
|
|
return result;
|
|
}
|
|
|
|
int Database::deleteCharacter(int characterID, int accountID) {
|
|
// checking if requested player exist and is bound to the account
|
|
|
|
sqlite3pp::query qry(db, "SELECT COUNT(AccountID) FROM Players WHERE AccountID = :AccID AND PlayerID = :PID");
|
|
|
|
qry.bind(":AccID", accountID);
|
|
qry.bind(":PID", characterID);
|
|
sqlite3pp::query::iterator i = qry.begin();
|
|
|
|
int result;
|
|
std::tie(result) = (*i).get_columns<int>(0);
|
|
|
|
if (result > 0) {
|
|
// get player character slot
|
|
sqlite3pp::query qry(db, "SELECT Slot FROM Players WHERE PlayerID = :PID");
|
|
|
|
// bind & execute
|
|
qry.bind(":PID", characterID);
|
|
sqlite3pp::query::iterator i = qry.begin();
|
|
|
|
// grab the slot to return
|
|
int slot;
|
|
std::tie(slot) = (*i).get_columns<int>(0);
|
|
|
|
// actually delete the record
|
|
sqlite3pp::command cmd(db, "DELETE FROM Players WHERE PlayerID = :ID");
|
|
cmd.bind(":ID", characterID);
|
|
cmd.execute();
|
|
|
|
// finally, return the grabbed slot
|
|
return slot;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
// TODO: this should really be std::vector, but for the sake of compatibility with PRs, I'll change this after merging
|
|
std::list<Player> Database::getCharacters(int userID) {
|
|
std::list<Player> result = std::list<Player>();
|
|
|
|
sqlite3pp::query qry(db, "SELECT * FROM Players WHERE AccountID = :ID");
|
|
|
|
qry.bind(":ID", userID);
|
|
|
|
// for each character owned by the account,
|
|
for (sqlite3pp::query::iterator i = qry.begin(); i != qry.end(); ++i) {
|
|
// grab the data
|
|
int ID, AccountID, slot;
|
|
char const* charData, * first, * second;
|
|
std::tie(ID, AccountID, slot, first, second, charData) =
|
|
(*i).get_columns<int, int, int, char const*, char const*, char const*>(0, 1, 2, 3, 4, 5);
|
|
|
|
// convert to player
|
|
Player toadd = JsonToPlayer(charData, ID);
|
|
toadd.slot = slot;
|
|
|
|
// add it to the results
|
|
result.push_back(toadd);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::string Database::CharacterToJson(sP_CL2LS_REQ_SAVE_CHAR_NAME* save) {
|
|
nlohmann::json json = {
|
|
{"Level",36},
|
|
//to check
|
|
{"HP",1000},
|
|
{"NameCheck", 1},
|
|
{"FirstName",U16toU8(save->szFirstName)},
|
|
{"LastName",U16toU8(save->szLastName)},
|
|
{"Gender",rand() % 2 + 1 },
|
|
{"FaceStyle",1},
|
|
{"HairStyle",1},
|
|
{"HairColor",(rand() % 19) + 1},
|
|
{"SkinColor",(rand() % 13) + 1},
|
|
{"EyeColor",(rand() % 6) + 1},
|
|
{"Height",(rand() % 6)},
|
|
{"Body",(rand() % 4)},
|
|
{"Class",0},
|
|
{"AppearanceFlag",0},
|
|
{"PayzoneFlag",1},
|
|
{"TutorialFlag",0},
|
|
{"EquipUB", 217},
|
|
{"EquipLB", 203},
|
|
{"EquipFoot", 314},
|
|
{"EquipWeapon", 0},
|
|
{"x",settings::SPAWN_X},
|
|
{"y",settings::SPAWN_Y},
|
|
{"z",settings::SPAWN_Z},
|
|
{"isGM",false},
|
|
};
|
|
return json.dump();
|
|
}
|
|
|
|
std::string Database::PlayerToJson(Player player) {
|
|
nlohmann::json json = {
|
|
{"Level",player.level},
|
|
//to check
|
|
{"HP",player.HP},
|
|
{"NameCheck", 1},
|
|
{"FirstName",U16toU8(player.PCStyle.szFirstName)},
|
|
{"LastName",U16toU8(player.PCStyle.szLastName)},
|
|
{"Gender",player.PCStyle.iGender},
|
|
{"FaceStyle",player.PCStyle.iFaceStyle},
|
|
{"HairStyle",player.PCStyle.iHairStyle},
|
|
{"HairColor",player.PCStyle.iHairColor},
|
|
{"SkinColor",player.PCStyle.iSkinColor},
|
|
{"EyeColor",player.PCStyle.iEyeColor},
|
|
{"Height",player.PCStyle.iHeight},
|
|
{"Body",player.PCStyle.iBody},
|
|
{"Class",player.PCStyle.iClass},
|
|
{"AppearanceFlag",player.PCStyle2.iAppearanceFlag},
|
|
{"PayzoneFlag",player.PCStyle2.iPayzoneFlag},
|
|
{"TutorialFlag",player.PCStyle2.iTutorialFlag},
|
|
{"EquipUB", player.Equip[1].iID},
|
|
{"EquipLB", player.Equip[2].iID},
|
|
{"EquipFoot", player.Equip[3].iID},
|
|
{"EquipWeapon", player.Equip[0].iID},
|
|
{"x",player.x},
|
|
{"y",player.y},
|
|
{"z",player.z},
|
|
{"isGM",false},
|
|
};
|
|
return json.dump();
|
|
}
|
|
|
|
Player Database::JsonToPlayer(std::string input, int PC_UID) {
|
|
std::string err;
|
|
const auto json = nlohmann::json::parse(input);
|
|
Player player;
|
|
player.PCStyle.iPC_UID = (int64_t)PC_UID;
|
|
player.level = std::stoi(json["Level"].dump());
|
|
player.HP = std::stoi(json["HP"].dump());
|
|
player.PCStyle.iNameCheck = std::stoi(json["NameCheck"].dump());
|
|
U8toU16(json["FirstName"].get<std::string>(), player.PCStyle.szFirstName);
|
|
U8toU16(json["LastName"].get<std::string>(), player.PCStyle.szLastName);
|
|
player.PCStyle.iGender = std::stoi(json["Gender"].dump());
|
|
player.PCStyle.iFaceStyle = std::stoi(json["FaceStyle"].dump());
|
|
player.PCStyle.iHairStyle = std::stoi(json["HairStyle"].dump());
|
|
player.PCStyle.iHairColor = std::stoi(json["HairColor"].dump());
|
|
player.PCStyle.iSkinColor = std::stoi(json["SkinColor"].dump());
|
|
player.PCStyle.iEyeColor = std::stoi(json["EyeColor"].dump());
|
|
player.PCStyle.iHeight = std::stoi(json["Height"].dump());
|
|
player.PCStyle.iBody = std::stoi(json["Body"].dump());
|
|
player.PCStyle.iClass = std::stoi(json["Class"].dump());
|
|
player.PCStyle2.iAppearanceFlag = std::stoi(json["AppearanceFlag"].dump());
|
|
player.PCStyle2.iPayzoneFlag = std::stoi(json["PayzoneFlag"].dump());
|
|
player.PCStyle2.iTutorialFlag = std::stoi(json["TutorialFlag"].dump());
|
|
player.Equip[0].iID = std::stoi(json["EquipWeapon"].dump());
|
|
if (player.Equip[0].iID != 0)
|
|
player.Equip[0].iOpt = 1;
|
|
else
|
|
player.Equip[0].iOpt = 0;
|
|
player.Equip[0].iType = 0;
|
|
player.Equip[1].iID = std::stoi(json["EquipUB"].dump());
|
|
player.Equip[1].iOpt = 1;
|
|
player.Equip[1].iType = 1;
|
|
player.Equip[2].iID = std::stoi(json["EquipLB"].dump());
|
|
player.Equip[2].iOpt = 1;
|
|
player.Equip[2].iType = 2;
|
|
player.Equip[3].iID = std::stoi(json["EquipFoot"].dump());
|
|
player.Equip[3].iOpt = 1;
|
|
player.Equip[3].iType = 3;
|
|
player.x = std::stoi(json["x"].dump());
|
|
player.y = std::stoi(json["y"].dump());
|
|
player.z = std::stoi(json["z"].dump());
|
|
return player;
|
|
}
|
|
|
|
std::string Database::CharacterToJson(sP_CL2LS_REQ_CHAR_CREATE* character) {
|
|
nlohmann::json json = {
|
|
{"Level",36},
|
|
//to check
|
|
{"HP",1000},
|
|
{"NameCheck", 1},
|
|
{"FirstName",U16toU8(character->PCStyle.szFirstName)},
|
|
{"LastName",U16toU8(character->PCStyle.szLastName)},
|
|
{"Gender",character->PCStyle.iGender},
|
|
{"FaceStyle",character->PCStyle.iFaceStyle},
|
|
{"HairStyle",character->PCStyle.iHairStyle},
|
|
{"HairColor",character->PCStyle.iHairColor},
|
|
{"SkinColor",character->PCStyle.iSkinColor},
|
|
{"EyeColor",character->PCStyle.iEyeColor},
|
|
{"Height",character->PCStyle.iHeight},
|
|
{"Body",character->PCStyle.iBody},
|
|
{"Class",character->PCStyle.iClass},
|
|
{"AppearanceFlag",1},
|
|
{"PayzoneFlag",1},
|
|
{"TutorialFlag",0},
|
|
{"EquipUB", character->sOn_Item.iEquipUBID},
|
|
{"EquipLB", character->sOn_Item.iEquipLBID},
|
|
{"EquipFoot", character->sOn_Item.iEquipFootID},
|
|
{"EquipWeapon", 0},
|
|
{"x",settings::SPAWN_X},
|
|
{"y",settings::SPAWN_Y},
|
|
{"z",settings::SPAWN_Z},
|
|
{"isGM",false},
|
|
};
|
|
return json.dump();
|
|
}
|