public BoxedData ExecuteQuery(string query)
{
BoxedData data = new BoxedData();
bool success = false;
string msg = "";
try
{
lock (_connectionLock)
{
using (MySqlCommand command = new MySqlCommand(query, _connection))
{
command.ExecuteNonQuery();
success = true;
}
}
}
catch (Exception exception)
{
msg = $"Cannot execute query: {exception.Message}";
}
data.Data = success;
data.Msg = msg;
return(data);
}
public BoxedData CloseConnection()
{
BoxedData data = new BoxedData();
bool success = false;
string msg = "";
try
{
lock (_connectionLock)
{
if (_connection != null && _connection.State == System.Data.ConnectionState.Open)
{
_connection.Close();
}
success = true;
}
}
catch (Exception exception)
{
msg = $"An error occured during mySQL connection closing: {exception.Message}";
}
data.Data = success;
data.Msg = msg;
return(data);
}
public BoxedData StartConnection()
{
BoxedData data = new BoxedData();
bool success = false;
string msg = "";
try
{
lock (_connectionLock)
{
if (_connection != null && _connection.State == System.Data.ConnectionState.Open)
{
throw new Exception("connection is open. It should be closed before starting new connection!");
}
_connection = new MySqlConnection(_connectionSettings.ConnectionString);
_connection.Open();
success = true;
}
}
catch (Exception exception)
{
msg = $"An error occured during mySQL connection starting: {exception.Message}";
}
data.Data = success;
data.Msg = msg;
return(data);
}
public BoxedData GetLocalGeoDataOfExitElements(int wmId, int parentObjectId)
{
BoxedData data = new BoxedData();
List <GeoDataElement> resultList = null;
string msg = "";
try
{
WorldPlaceData worldPlace = GetWorldPlaceByWmId(wmId);
if (worldPlace == null)
{
throw new Exception("world place not found!");
}
PlaceInstance placeInstance = worldPlace.GetPredefinedInstanceByParentObjectId(parentObjectId);
if (placeInstance == null)
{
throw new Exception("place instance not found!");
}
resultList = placeInstance.GetGeoDataOfExitElements();
}
catch (Exception exception)
{
msg = $"An error occured while getting geo data (exit elements), wm_id [{wmId}] parent obj, ID [{parentObjectId}]: {exception.Message}";
}
data.Data = (resultList ?? new List <GeoDataElement>());
data.Msg = msg;
return(data);
}
public BoxedData CheckConnection()
{
BoxedData data = new BoxedData();
bool connOpen = false;
string msg = "";
try
{
lock (_connectionLock)
{
if (_connection == null)
{
throw new Exception("connector is NULL!");
}
if (_connection.State == System.Data.ConnectionState.Open)
{
connOpen = true;
}
}
}
catch (Exception exception)
{
msg = $"An error occured during mySQL connection checking: {exception.Message}";
}
data.Data = connOpen;
data.Msg = msg;
return(data);
}
public async void Test()
{
try
{
_logger.UpdateLog("getting geo data...");
BoxedData bxData = await _gameWorldData.GetLocalGeoDataTaskStart(1, -1, new Point3 <int>(2, 2, 3), new Point3 <int>(10, 10, 10));
List <GeoDataElement> geoDataList = (List <GeoDataElement>)bxData.Data;
if (!String.IsNullOrEmpty(bxData.Msg))
{
_logger.UpdateLog(bxData.Msg);
}
foreach (GeoDataElement geoElement in geoDataList)
{
_logger.UpdateLog
(
$"loc [{geoElement.Location.X}, {geoElement.Location.Y}, {geoElement.Location.Z}] " +
$"collision [{geoElement.ColliderSize.X}, {geoElement.ColliderSize.Y}, {geoElement.ColliderSize.Z}] " +
$"type [{geoElement.ElementType.ToString()}]"
);
}
_accountData.ShowAccountsInLog();
}
catch (Exception exception)
{
_logger.UpdateLog($"(TEST) Error: {exception.Message} | {exception.StackTrace}");
}
}
private BoxedData InitializeCharacterData(List <DbCharactersData> dbCharDataList)
{
BoxedData data = new BoxedData();
bool success = false;
string msg = "";
try
{
ClearData();
int charCounter = 0;
lock (_charListLock)
{
foreach (DbCharactersData dbCharData in dbCharDataList)
{
CharacterData charData = new CharacterData(dbCharData);
_characterList.Add(charData);
charCounter++;
}
}
msg = $"Character data container - added [{charCounter}] chars.";
success = true;
}
catch (Exception exception)
{
msg = $"Character data init. failed: {exception.Message} | {exception.StackTrace}";
}
data.Data = success;
data.Msg = msg;
return(data);
}
/// <summary>
/// Gets data from table 'world_map_settings'
/// </summary>
public BoxedData GetWorldMapSettingsData(string sqlFilter = "")
{
BoxedData data = new BoxedData();
List <DbWorldMapSettingsData> resultList = new List <DbWorldMapSettingsData>();
string msg = "";
try
{
int id = -1;
int type = -1;
string description = "";
string value = "";
string query = @"
SELECT
`wms_id`,
`wms_type`,
`wms_description`,
`wms_value`
FROM
`world_map_settings`
";
if (!String.IsNullOrWhiteSpace(sqlFilter))
{
query += $" {(!sqlFilter.ToUpper().Contains("WHERE") ? "WHERE" : "")} {sqlFilter}";
}
lock (_connectionLock)
{
using (MySqlCommand command = new MySqlCommand(query, _connection))
{
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
id = reader.GetInt32("wms_id");
type = reader.GetInt32("wms_type");
description = reader["wms_description"].ToString();
value = reader["wms_value"].ToString();
DbWorldMapSettingsData result = new DbWorldMapSettingsData(id, type, description, value);
resultList.Add(result);
}
}
}
}
}
catch (Exception exception)
{
msg = $"Cannot get data from 'world_map_settings' table, SQL filter [{sqlFilter}]: {exception.Message}";
}
data.Data = resultList;
data.Msg = msg;
return(data);
}
/// <summary>
/// Adds new record in table 'accounts'
/// </summary>
public BoxedData AddAccountsData(DbAccountsData accountData)
{
BoxedData data = new BoxedData();
int accId = -1;
string msg = "";
try
{
string query = @"
INSERT INTO `accounts`
(
`acc_login`,
`acc_pass`,
`acc_access_level`
)
VALUES
(
@login,
@pass,
@accessLevel
);
SELECT LAST_INSERT_ID() AS `acc_id`;
";
lock (_connectionLock)
{
using (MySqlCommand command = new MySqlCommand(query, _connection))
{
command.Parameters.AddWithValue("@login", accountData.Login);
command.Parameters.AddWithValue("@pass", accountData.PassEncrypted);
command.Parameters.AddWithValue("@accessLevel", accountData.AccessLevel);
using (MySqlDataReader reader = command.ExecuteReader())
{
if (reader.Read())
{
if (!Int32.TryParse(reader["acc_id"].ToString(), out accId))
{
msg = $"Cannot convert acc_id!";
}
}
}
}
}
}
catch (Exception exception)
{
msg = $"Cannot insert new record in table 'accounts': {exception.Message}";
}
data.Data = accId;
data.Msg = msg;
return(data);
}
public BoxedData GetLocalGeoData(int wmId, int parentObjectId, Point3 <int> from, Point3 <int> to)
{
BoxedData data = new BoxedData();
List <GeoDataElement> resultList = null;
string msg = "";
try
{
#region Bounds
int pointFromX = from.X - DbTerrainObjectDefinitions.MaxCollisionXOfAllObjects;
int pointFromY = from.Y - DbTerrainObjectDefinitions.MaxCollisionYOfAllObjects;
int pointFromZ = from.Z - DbTerrainObjectDefinitions.MaxCollisionZOfAllObjects;
//Console.WriteLine($"mod. point from [{pointFromX}, {pointFromY}, {pointFromZ}]");
Point3 <int> pointFromTemp = new Point3 <int>
(
(pointFromX <= to.X ? pointFromX - 1 : to.X - 1), //NOTE: -1 to prevent rounding error
(pointFromY <= to.Y ? pointFromY - 1 : to.Y - 1), //NOTE: -1 to prevent rounding error
(pointFromZ <= to.Z ? pointFromZ - 1 : to.Z - 1) //NOTE: -1 to prevent rounding error
);
Point3 <int> pointToTemp = new Point3 <int>
(
(from.X >= to.X ? from.X + 1 : to.X + 1), //NOTE: +1 to prevent rounding error
(from.Y >= to.Y ? from.Y + 1 : to.Y + 1), //NOTE: +1 to prevent rounding error
(from.Z >= to.Z ? from.Z + 1 : to.Z + 1) //NOTE: +1 to prevent rounding error
);
#endregion
WorldPlaceData worldPlace = GetWorldPlaceByWmId(wmId);
if (worldPlace == null)
{
throw new Exception("world place not found!");
}
PlaceInstance placeInstance = worldPlace.GetPredefinedInstanceByParentObjectId(parentObjectId);
if (placeInstance == null)
{
throw new Exception("place instance not found!");
}
resultList = placeInstance.GetGeoData(pointFromTemp, pointToTemp);
}
catch (Exception exception)
{
msg = $"An error occured while getting geo data, wm_id [{wmId}] parent obj, ID [{parentObjectId}]: {exception.Message}";
}
data.Data = (resultList ?? new List <GeoDataElement>());
data.Msg = msg;
return(data);
}
public async void AddPredefinedInstanceAsync(List <DbTerrainObjectsData> terrainDataList, int parentTerrainObjectId)
{
WorldPlaceData.InstanceCreationInProgress = true;
try
{
DeletePredefinedInstanceIfExists(parentTerrainObjectId);
PlaceInstance instance = new PlaceInstance
(
_terrainObjectDefinitionList,
_parent.LocalBoundX,
_parent.LocalBoundY,
_parent.LocalBoundZ,
this.WorldPosX,
this.WorldPosY,
parentTerrainObjectId
);
bool terrainFillingSuccess = false;
using (BoxedData terrainFillingPacket = await instance.FillTerrainDetailsTaskStart(terrainDataList))
{
terrainFillingSuccess = (bool)terrainFillingPacket.Data;
if (!String.IsNullOrEmpty(terrainFillingPacket.Msg))
{
_logger.UpdateLog(terrainFillingPacket.Msg);
}
}
if (terrainFillingSuccess)
{
lock (_instanceLock)
{
_predefinedPlacesList.Add(instance);
}
_logger.UpdateLog($"Added predefined instance, ID [{instance.PlaceInstanceId}] world pos. [{this.WorldPosX}, {this.WorldPosY}] parent object ID [{parentTerrainObjectId}]");
}
else
{
_logger.UpdateLog("Predefined instance creation failed!");
}
}
catch (Exception exception)
{
_logger.UpdateLog($"An error occured during predefined instance creation: {exception.Message}");
}
WorldPlaceData.InstanceCreationInProgress = false;
}
public async void LoadAccountsAsync(MySqlDbManager dbManager)
{
this.IsLoaded = false;
this.LoadingError = false;
_accountList.Clear();
_logger.UpdateLog("Loading accounts data...");
try
{
if (dbManager.GetConnectionState() != System.Data.ConnectionState.Open)
{
throw new Exception("connection not open!");
}
using (BoxedData accBoxedData = await dbManager.GetAccountsDataTaskStart())
{
_accountList = (List <DbAccountsData>)accBoxedData.Data;
if (!String.IsNullOrEmpty(accBoxedData.Msg))
{
_logger.UpdateLog(accBoxedData.Msg);
}
}
this.IsLoaded = true;
}
catch (Exception exception)
{
this.LoadingError = true;
_logger.UpdateLog($"An error occured during account data loading: {exception.Message}");
}
if (this.IsLoaded)
{
_logger.UpdateLog($"Loaded [{_accountList.Count}] accounts");
}
_logger.UpdateLog($"Loading account data ended with {(this.IsLoaded ? "success" : "failure")}.");
}
/// <summary>
/// Gets all parent IDs from terrain objects in specific location (by world map loc. ID)
/// </summary>
public BoxedData GetParentObjectIds(int wmId)
{
BoxedData data = new BoxedData();
List <int> parentIdsList = new List <int>();
string msg = "";
try
{
string query = @"
SELECT DISTINCT `to_parent_id`
FROM `terrain_objects`
WHERE `to_wm_id` = @wmId
";
lock (_connectionLock)
{
using (MySqlCommand command = new MySqlCommand(query, _connection))
{
command.Parameters.AddWithValue("@wmId", wmId);
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
parentIdsList.Add(reader.GetInt32("to_parent_id"));
}
}
}
}
}
catch (Exception exception)
{
msg = $"Cannot get parent IDs from 'terrain_objects' table, wm_id [{wmId}]: {exception.Message}";
}
data.Data = parentIdsList;
data.Msg = msg;
return(data);
}
private async void CheckMySqlConnectionAsync()
{
_uiHandler.ShowTab("overviewTabPage");
_uiHandler.UpdateLog("Checking mySQL connection...");
MySqlConnectionSettings myConnSettings = _uiHandler.GetMySqlSettings();
using (MySqlDbManager dbManager = new MySqlDbManager(myConnSettings))
{
_uiHandler.UpdateLog("Estabilishing mySQL connection...");
BoxedData startConnData = await dbManager.StartConnectionTaskStart();
bool startConnSuccess = (bool)startConnData.Data;
_uiHandler.UpdateLog(startConnSuccess ? "Connection started!" : "Connection starting failed!");
if (!String.IsNullOrEmpty(startConnData.Msg))
{
_uiHandler.UpdateLog(startConnData.Msg);
}
BoxedData checkConnData = await dbManager.CheckConnectionTaskStart();
bool checkConnSuccess = (bool)checkConnData.Data;
_uiHandler.UpdateLog(checkConnSuccess ? "Connection successfully estabilished!" : "Connection not estabilished!");
if (!String.IsNullOrEmpty(checkConnData.Msg))
{
_uiHandler.UpdateLog(checkConnData.Msg);
}
BoxedData closeConnData = await dbManager.CloseConnectionTaskStart();
bool closeConnSuccess = (bool)closeConnData.Data;
_uiHandler.UpdateLog(closeConnSuccess ? "Connection closed!" : "Cannot close current connection!");
if (!String.IsNullOrEmpty(closeConnData.Msg))
{
_uiHandler.UpdateLog(closeConnData.Msg);
}
}
}
public static BoxedData ValidateMovement(List <GeoDataElement> geoDataList, CharacterMovementDetails movementDetails)
{
BoxedData data = new BoxedData();
GeoDataValidationDetails details = new GeoDataValidationDetails();
string msg = "";
try
{
#region Sub arrays
//SUB ARRAYS
GeoDataElement[] terrainSubArray = new GeoDataElement[geoDataList.Count];
GeoDataElement[] obstacleSubArray = new GeoDataElement[geoDataList.Count];
int terrainFilledSize = 0;
int obstacleFilledSize = 0;
for (int i = 0; i < geoDataList.Count; i++)
{
switch (geoDataList[i].ElementType)
{
case GeoDataElement.Type.Terrain:
terrainSubArray[terrainFilledSize] = geoDataList[i];
terrainFilledSize++;
break;
case GeoDataElement.Type.Obstacle:
obstacleSubArray[obstacleFilledSize] = geoDataList[i];
obstacleFilledSize++;
break;
case GeoDataElement.Type.Platform:
terrainSubArray[terrainFilledSize] = geoDataList[i];
obstacleSubArray[obstacleFilledSize] = geoDataList[i];
terrainFilledSize++;
obstacleFilledSize++;
break;
}
}
#endregion
//PARAMETERS
bool valid = true;
Point3 <double> lastValidMovementPoint = movementDetails.OldLocationLocal.Copy();
double tStep = Measure.GetTParamStep(movementDetails.OldLocationLocal, movementDetails.NewLocationLocal)
/ 2;
double tParam = 0;
double tParamClamped = 0;
bool tParamReached = false;
//VALIDATION
if (tStep > 0 && tStep < 1)
{
double currentXDbl, currentYDbl, currentZDbl;
int currentX, currentY, currentZ;
int collisionMinX, collisionMaxX, collisionMinY, collisionMaxY, collisionMinZ, collisionMaxZ;
GeoDataElement geoDataElement;
bool obstacleDetected = false;
bool hasGroundUnderFeet;
while (!tParamReached)
{
tParamClamped = Measure.Clamp(0.0000, 1.0000, tParam);
currentXDbl = Measure.Lerp(movementDetails.OldLocationLocal.X, movementDetails.NewLocationLocal.X, tParamClamped);
currentYDbl = Measure.Lerp(movementDetails.OldLocationLocal.Y, movementDetails.NewLocationLocal.Y, tParamClamped);
currentZDbl = Measure.Lerp(movementDetails.OldLocationLocal.Z, movementDetails.NewLocationLocal.Z, tParamClamped)
+ _marginZ;
currentX = Convert.ToInt32(Math.Floor(currentXDbl));
currentY = Convert.ToInt32(Math.Floor(currentYDbl));
currentZ = Convert.ToInt32(Math.Floor(currentZDbl));
#region Obstacle check
//OBSTACLE CHECK
for (int i = 0; i < obstacleFilledSize; i++)
{
geoDataElement = obstacleSubArray[i];
GetColliderPosition(geoDataElement, out collisionMinX, out collisionMaxX, out collisionMinY, out collisionMaxY, out collisionMinZ, out collisionMaxZ);
if
(
currentX >= collisionMinX && currentX <= collisionMaxX &&
currentY >= collisionMinY && currentY <= collisionMaxY &&
currentZ >= collisionMinZ && currentZ <= collisionMaxZ
)
{
obstacleDetected = true;
break;
}
}
#endregion
#region Ground check
//GROUND CHECK
hasGroundUnderFeet = false;
if (!obstacleDetected) //NOTE: ground check is not necessary if player collides with obstacle (performance)
{
for (int i = 0; i < terrainFilledSize; i++)
{
geoDataElement = terrainSubArray[i];
GetColliderPosition(geoDataElement, out collisionMinX, out collisionMaxX, out collisionMinY, out collisionMaxY, out collisionMinZ, out collisionMaxZ);
if
(
currentX >= collisionMinX && currentX <= collisionMaxX &&
currentY >= collisionMinY && currentY <= collisionMaxY &&
currentZ >= collisionMinZ - 1 && currentZ <= collisionMaxZ + 2
)
{
hasGroundUnderFeet = true;
break;
}
}
}
#endregion
if (obstacleDetected || !hasGroundUnderFeet)
{
valid = false;
break;
}
else
{
lastValidMovementPoint.X = currentXDbl;
lastValidMovementPoint.Y = currentYDbl;
lastValidMovementPoint.Z = currentZDbl - _marginZ;
}
//Console.WriteLine($"tClamped [{tParamClamped}] pos [{currentX}; {currentY}; {currentZ}] obstacle [{obstacleDetected}]");
if (tParam >= 1)
{
tParamReached = true;
}
tParam += tStep;
}
}
details.Valid = valid;
details.LastValidMovementPoint = lastValidMovementPoint;
details.LastTParamValue = tParamClamped;
}
catch (Exception exception)
{
msg = $"Error occured while geo data movement validation for character's ID [{movementDetails.CharId}]: {exception.Message}";
}
data.Data = details;
data.Msg = msg;
return(data);
}
/// <summary>
/// Starts the game and its management/handlers etc.
/// </summary>
public async void StartAsync(MySqlConnectionSettings mySqlConnSettings)
{
if (_loadingInProgress)
{
_logger.UpdateLog("Game loading in progress!");
return;
}
_loadingInProgress = true;
try
{
if (this.State == GameState.Active)
{
_logger.UpdateLog("The game is already active!");
return;
}
_mySqlConnSettings = mySqlConnSettings;
int counter;
try
{
//GAME DATA
using (MySqlDbManager gwdDbManager = new MySqlDbManager(_mySqlConnSettings))
{
#region Connection starting
//CONNECTION STARTING
_logger.UpdateLog("Starting connection for data loading...");
bool connectionSuccess = false;
using (BoxedData connStartData = await gwdDbManager.StartConnectionTaskStart())
{
if (!String.IsNullOrEmpty(connStartData.Msg))
{
_logger.UpdateLog(connStartData.Msg);
}
connectionSuccess = (bool)connStartData.Data;
}
if (!connectionSuccess)
{
throw new Exception("connection not estabilished!");
}
#endregion
#region Account data
//ACCOUNT DATA
_accountData = new AccountData(_logger);
_accountData.LoadAccountsAsync(gwdDbManager);
while (!_accountData.IsLoaded)
{
await Task.Factory.StartNew(() => Thread.Sleep(1000));
if (_accountData.LoadingError)
{
throw new Exception("account data loading failure!");
}
}
//_accountData.ShowAccountsInLog(); //NOTE: only for testing (shows secret account details)!
#endregion
#region Game world data
//GAME DATA LOADING
_gameWorldData = new GameWorldData(_logger);
_gameWorldData.LoadWorldDataAsync(gwdDbManager);
counter = 0;
while (!_gameWorldData.IsLoaded)
{
await Task.Factory.StartNew(() => Thread.Sleep(1000));
counter++;
if (_gameWorldData.LoadingError)
{
throw new Exception("game world data loading failure!");
}
}
_logger.UpdateLog($"Game data loading ended in {counter} seconds.");
#endregion
}
//PLAYER HANDLER
_playerHandler = new PlayerHandler(_logger);
//GAME STATE HANDLER
_gameStateHandler = new GameStateHandler(_logger, _gameWorldData, _gameWorldData, _playerHandler);
//CHAT HANDLER
_chatHandler = new ChatHandler(_logger, _gameWorldData, _playerHandler);
//COMMAND HANDLER
_commandHandler = new CommandHandler(_logger);
_commandHandler.RegisterCommandHandlingStrategy(new CmdPingStrategy());
_commandHandler.RegisterCommandHandlingStrategy(new MoveCharRequestStrategy(_logger, _gameStateHandler, _gameWorldData, _playerHandler));
_commandHandler.RegisterCommandHandlingStrategy(new CmdChatStrategy(_logger, _chatHandler));
_commandHandler.RegisterCommandHandlingStrategy(new SwitchPlaceRequestStrategy(_logger, _gameStateHandler, _gameWorldData, _gameWorldData, _playerHandler));
_commandHandler.RegisterCommandHandlingStrategy(new CmdGetLocationCharsStrategy(_logger, _gameWorldData));
_commandHandler.RegisterCommandHandlingStrategy(new CmdGetWorldDetailsStrategy(_logger, _gameWorldData));
_commandHandler.RegisterCommandHandlingStrategy(new CmdLoginStrategy(_logger, _accountData, _playerHandler));
_commandHandler.RegisterCommandHandlingStrategy(new CmdLogoutStrategy(_playerHandler));
_commandHandler.RegisterCommandHandlingStrategy(new CmdGetAccountCharsStrategy(_logger, _accountData, _gameWorldData));
_commandHandler.RegisterCommandHandlingStrategy(new CmdChooseCharacterStrategy(_logger, _accountData, _gameWorldData, _playerHandler));
//CONNECTION HANDLER
_tcpConnectionHandler = TcpConnectionHandler.GetInstance(_tcpLogger, _commandHandler, _playerHandler);
_tcpConnectionHandler.StartConnection(_uiHandler.GetTcpConnectionSettings());
//REGULAR OPERATION HANDLER
_regularOperationHandler = new RegularOperationHandler(_logger);
//ETC
this.State = GameState.Active;
}
catch (Exception exception)
{
this.State = GameState.Error;
_logger.UpdateLog($"An error occured during game starting: {exception.Message}");
}
}
finally
{
_logger.UpdateLog($"*** ENDED WITH GAME STATE [{this.State.ToString()}]");
_loadingInProgress = false;
}
}
private async void ExecuteAsync(PlayerDetails playerDetails)
{
try
{
int charId = playerDetails.CharId;
if (charId < 0)
{
throw new Exception("char. ID not set!");
}
CharacterData charData = await _charInfo.GetCharacterByIdTaskStart(charId);
if (charData.IsOnWorldMap)
{
_charActionManager.SwitchCharacterMovementType(charId);
}
else
{
int wmId = charData.WmId;
int parentObjectId = charData.ParentObjectId;
Point3 <int> pointFrom = new Point3 <int>
(
Convert.ToInt32(charData.CurrentLoc.X),
Convert.ToInt32(charData.CurrentLoc.Y),
Convert.ToInt32(charData.CurrentLoc.Z) - 1
);
Point3 <int> pointTo = new Point3 <int>
(
Convert.ToInt32(charData.CurrentLoc.X),
Convert.ToInt32(charData.CurrentLoc.Y),
Convert.ToInt32(charData.CurrentLoc.Z) + 1
);
using (BoxedData boxedGeoData = await _geoDataInfo.GetLocalGeoDataTaskStart(wmId, parentObjectId, pointFrom, pointTo))
{
List <GeoDataElement> geoDataElementList = (List <GeoDataElement>)boxedGeoData.Data;
if (!String.IsNullOrEmpty(boxedGeoData.Msg))
{
_logger.UpdateLog(boxedGeoData.Msg);
}
bool exitFound = false;
int collisionMinX, collisionMaxX, collisionMinY, collisionMaxY, collisionMinZ, collisionMaxZ;
foreach (GeoDataElement geoElement in geoDataElementList)
{
if (!geoElement.IsExit)
{
continue;
}
GeoDataValidator.GetColliderPosition(geoElement, out collisionMinX, out collisionMaxX, out collisionMinY, out collisionMaxY, out collisionMinZ, out collisionMaxZ);
//_logger.UpdateLog($"exit col. x [{collisionMinX}-{collisionMaxX}] y [{collisionMinY}-{collisionMaxY}] z [{collisionMinZ}-{collisionMaxZ}]");
//_logger.UpdateLog($"current [{charData.CurrentLoc.X}; {charData.CurrentLoc.Y}; {charData.CurrentLoc.Z}]");
if
(
charData.CurrentLoc.X >= collisionMinX && charData.CurrentLoc.X <= collisionMaxX + 1 &&
charData.CurrentLoc.Y >= collisionMinY && charData.CurrentLoc.Y <= collisionMaxY + 1 &&
charData.CurrentLoc.Z >= collisionMinZ && charData.CurrentLoc.Z <= collisionMaxZ + 2
)
{
exitFound = true;
break;
}
}
if (exitFound)
{
_charActionManager.SwitchCharacterMovementType(charId);
}
else
{
CommandHandler.Send(new InfoCmdBuilder("You're not at exit point!"), playerDetails);
}
}
}
}
catch (Exception exception)
{
_logger.UpdateLog($"Switch place command execution error: {exception.Message}");
}
}
public async void CreateNewAccountAsync(DbAccountsData dbAccData, MySqlConnectionSettings connSettings)
{
try
{
if (String.IsNullOrWhiteSpace(dbAccData.Login))
{
_logger.UpdateLog("Login cannot be empty!");
return;
}
bool success = false;
using (MySqlDbManager dbManager = new MySqlDbManager(connSettings))
{
BoxedData connStartData = await dbManager.StartConnectionTaskStart();
bool connStartSuccess = (bool)connStartData.Data;
if (!String.IsNullOrEmpty(connStartData.Msg))
{
_logger.UpdateLog(connStartData.Msg);
}
if (connStartSuccess)
{
BoxedData accCreationData = await dbManager.AddAccountsDataTaskStart(dbAccData);
int accId = (int)accCreationData.Data;
if (!String.IsNullOrEmpty(accCreationData.Msg))
{
_logger.UpdateLog(accCreationData.Msg);
}
if (accId > -1)
{
_logger.UpdateLog($"Created new account, acc_id [{accId}]!");
if (_accountData != null)
{
_accountData.AddAccountData
(
new DbAccountsData
(
accId,
dbAccData.Login,
dbAccData.PassEncrypted,
DbAccountsData.PasswordType.Encrypted,
dbAccData.AccessLevel
)
);
}
success = true;
}
}
else
{
_logger.UpdateLog("Cannot connect to database!");
}
}
if (success)
{
_logger.UpdateLog("Account created successfully!");
}
}
catch (Exception exception)
{
_logger.UpdateLog($"Account creation failure: {exception.Message}");
}
}
public async void CreateMySqlDataAsync(bool createTables, bool createData)
{
_logger.UpdateLog("Running mySQL data creation tool...");
int successCounter = 0;
int faultCounter = 0;
try
{
_logger.UpdateLog("Starting connection...");
using (MySqlDbManager dbManager = new MySqlDbManager(_connectionSettings))
{
BoxedData startConnData = await dbManager.StartConnectionTaskStart();
bool startConnSuccess = (bool)startConnData.Data;
if (!String.IsNullOrEmpty(startConnData.Msg))
{
_logger.UpdateLog(startConnData.Msg);
}
if (!startConnSuccess)
{
throw new Exception("cannot connect to database!");
}
_logger.UpdateLog("Getting data creation queries...");
SqlCreationQueriesData queriesData = new SqlCreationQueriesData();
List <string> queryList = queriesData.GetMySqlDataCreationQueries(createTables, createData);
bool queryExecSuccess = false;
for (int i = 0; i < queryList.Count; i++)
{
_logger.UpdateLog($"Executing query {(i + 1)} of {queryList.Count}...");
using (BoxedData queryExecData = await dbManager.ExecuteQueryTaskStart(queryList[i]))
{
queryExecSuccess = (bool)queryExecData.Data;
if (!String.IsNullOrEmpty(queryExecData.Msg))
{
_logger.UpdateLog(queryExecData.Msg);
}
}
_logger.UpdateLog(queryExecSuccess ? "Query executed successfully!" : "An error occured!");
if (queryExecSuccess)
{
successCounter++;
}
else
{
faultCounter++;
}
}
}
_logger.UpdateLog($"MySql data creation ended! Successes [{successCounter}] faults [{faultCounter}].");
}
catch (Exception exception)
{
_logger.UpdateLog($"MySQL data creation failed: {exception.Message}");
}
}
public async void LoadWorldDataAsync(MySqlDbManager dbManager)
{
this.IsLoaded = false;
this.LoadingError = false;
_logger.UpdateLog("Loading game world data...");
try
{
if (dbManager.GetConnectionState() != System.Data.ConnectionState.Open)
{
throw new Exception("connection not open!");
}
#region World map settings
//WORLD MAP SETTINGS
_logger.UpdateLog("Getting world map settings...");
using (BoxedData wmsBoxedData = await dbManager.GetWorldMapSettingsDataTaskStart())
{
List <DbWorldMapSettingsData> wmsDataList = (List <DbWorldMapSettingsData>)wmsBoxedData.Data;
if (!String.IsNullOrEmpty(wmsBoxedData.Msg))
{
_logger.UpdateLog(wmsBoxedData.Msg);
}
ExtractWorldMapSettingsData(wmsDataList);
}
#endregion
#region Terrain object definitions
//TERRAIN OBJECT DEFINITIONS
lock (_terrainDefLock)
{
_terrainObjectDefinitionList.Clear();
}
_logger.UpdateLog("Getting terrain object definitions...");
using (BoxedData todBoxedData = await dbManager.GetTerrainObjectDefinitionsDataTaskStart())
{
lock (_terrainDefLock)
{
_terrainObjectDefinitionList = (List <DbTerrainObjectDefinitions>)todBoxedData.Data;
}
if (!String.IsNullOrEmpty(todBoxedData.Msg))
{
_logger.UpdateLog(todBoxedData.Msg);
}
}
#endregion
#region World place data
//WORLD PLACE DATA INITIALIZATION
if (this.MapWidth <= 0 || this.MapHeight <= 0)
{
throw new Exception($"wrong map dimensions [{this.MapWidth}, {this.MapHeight}]!");
}
_logger.UpdateLog("World place data initialization...");
_worldPlaces = new WorldPlaceData[this.MapWidth, this.MapHeight];
await Task.Factory.StartNew
(
() =>
{
for (int y = 0; y < this.MapHeight; y++)
{
for (int x = 0; x < this.MapWidth; x++)
{
_worldPlaces[x, y] = new WorldPlaceData(_logger, this, _terrainObjectDefinitionList, x, y);
}
}
}
);
//WORLD PLACE DATA FILLING
_logger.UpdateLog("Filling world place data...");
using (BoxedData wmBoxedData = await dbManager.GetWorldMapDataTaskStart())
{
List <DbWorldMapData> wmDataList = (List <DbWorldMapData>)wmBoxedData.Data;
if (!String.IsNullOrEmpty(wmBoxedData.Msg))
{
_logger.UpdateLog(wmBoxedData.Msg);
}
await Task.Factory.StartNew(() => FillWorldPlaceData(wmDataList));
}
#endregion
#region Place instance creation
//PLACE INSTANCE CREATION
{
int wmId = -1;
List <DbTerrainObjectsData> terrainObjectsList = new List <DbTerrainObjectsData>();
List <int> parentIdList = new List <int>();
for (int y = 0; y < this.MapHeight; y++)
{
for (int x = 0; x < this.MapWidth; x++)
{
parentIdList.Clear();
terrainObjectsList.Clear();
wmId = _worldPlaces[x, y].WmId;
using (BoxedData parentIdsData = await dbManager.GetParentObjectIdsTaskStart(wmId))
{
parentIdList = (List <int>)parentIdsData.Data;
if (!String.IsNullOrEmpty(parentIdsData.Msg))
{
_logger.UpdateLog(parentIdsData.Msg);
}
LogParentIds(x, y, parentIdList);
}
foreach (int parentId in parentIdList)
{
using (BoxedData terrainObjectsData = await dbManager.GetTerrainObjectsDataTaskStart($"`to_wm_id` = {wmId} AND `to_parent_id` = {parentId}"))
{
terrainObjectsList = (List <DbTerrainObjectsData>)terrainObjectsData.Data;
if (!String.IsNullOrEmpty(terrainObjectsData.Msg))
{
_logger.UpdateLog(terrainObjectsData.Msg);
}
_worldPlaces[x, y].AddPredefinedInstanceAsync(terrainObjectsList, parentId);
while (WorldPlaceData.InstanceCreationInProgress)
{
await Task.Factory.StartNew(() => Thread.Sleep(50));
}
}
}
}
}
}
#endregion
#region Characters
//CHARACTER DATA INITIALIZATION
_logger.UpdateLog("Getting characters data...");
_characterContainer = new CharacterDataContainer();
bool charInitSuccess = false;
using (BoxedData dbCharsData = await dbManager.GetCharactersDataTaskStart())
{
List <DbCharactersData> charDataList = (List <DbCharactersData>)dbCharsData.Data;
if (!String.IsNullOrEmpty(dbCharsData.Msg))
{
_logger.UpdateLog(dbCharsData.Msg);
}
using (BoxedData charContainerInitData = await _characterContainer.InitializeCharacterDataTaskStart(charDataList))
{
charInitSuccess = (bool)charContainerInitData.Data;
_logger.UpdateLog(charContainerInitData.Msg);
}
}
if (!charInitSuccess)
{
throw new Exception("character initialization failed!");
}
#endregion
this.IsLoaded = true;
}
catch (Exception exception)
{
this.LoadingError = true;
_logger.UpdateLog($"An error occured during world data loading: {exception.Message}");
}
_logger.UpdateLog($"Loading world data ended with {(this.IsLoaded ? "success" : "failure")}.");
}
private async void HandleCharactersMovementAsync()
{
if (_movementHandlingInProgress)
{
_logger.UpdateLog("Character movement handling already started!");
return;
}
_movementHandlingInProgress = true;
_logger.UpdateLog("Game state handler - character movement handling started!");
try
{
List <CharacterMovementDetails> movementDetailsListTemp = new List <CharacterMovementDetails>();
CharacterData characterData;
List <GeoDataElement> geoDataList = new List <GeoDataElement>();
CharacterPositionUpdateDetails positionDetailsToSend = null;
int count = 0;
int wmId;
int parentObjectId;
bool isOnWorldMap;
GeoDataValidationDetails geoDataValidationDetails = null;
bool geoMovementValid = false;
Point3 <double> lastValidMovementPoint = new Point3 <double>(0, 0, 0);
bool exitPointFound = false;
Point3 <double> exitPosition = null;
double lastTParamValue = 0;
int timeArrivalMsIncomplete = 0;
bool worldMovingValid = false;
do
{
#region Main list item removal
//MAIN LIST ITEM REMOVAL
lock (_movementDetailsLock)
{
count = _movementDetailsList.Count;
if (count > 0)
{
movementDetailsListTemp = _movementDetailsList.Clone();
foreach (CharacterMovementDetails item in _movementDetailsList)
{
item.Dispose();
}
_movementDetailsList.Clear();
}
}
#endregion
#region Interval handling
//INTERVAL HANDLING
if (count == 0)
{
await Task.Factory.StartNew(() => Thread.Sleep(GameStateHandler._movementHandlingTickMs));
continue;
}
#endregion
#region Movement details handling
//MOV. DETAILS HANDLING
foreach (CharacterMovementDetails movementDetails in movementDetailsListTemp)
{
if (geoDataList.Count > 0)
{
geoDataList.Clear();
}
if (movementDetails.CharId < 0)
{
_logger.UpdateLog("Movement details handling warning - character's ID less than 0!");
continue;
}
//characterData = await _characterInfo.GetCharacterByNameTaskStart(movementDetails.CharName);
characterData = await _characterInfo.GetCharacterByIdTaskStart(movementDetails.CharId);
if (characterData == null)
{
_logger.UpdateLog($"Movement details handling warning - character's ID [{movementDetails.CharId}] not found!");
continue;
}
wmId = characterData.WmId;
parentObjectId = characterData.ParentObjectId;
isOnWorldMap = characterData.IsOnWorldMap;
switch (movementDetails.Type)
{
case CharacterMovementDetails.MovementType.SwitchMovementType:
{
#region Local enter/exit point veryfication
//LOCAL ENTER/EXIT POINT VERYFICATION
exitPointFound = false;
if (characterData.IsOnWorldMap)
{
using (BoxedData geoBoxedData = await _geoDataInfo.GetLocalGeoDataOfExitElementsTaskStart(wmId, parentObjectId))
{
geoDataList = (List <GeoDataElement>)geoBoxedData.Data;
if (!String.IsNullOrEmpty(geoBoxedData.Msg))
{
_logger.UpdateLog(geoBoxedData.Msg);
}
}
exitPosition = GeoDataValidator.GetRandomExitPosition(geoDataList);
if (exitPosition != null)
{
exitPointFound = true;
//PLACING CHARACTER ON ENTRY POINT
characterData.MoveCharacterLocal
(
exitPosition.Copy(),
exitPosition.Copy(),
0
);
}
}
#endregion
#region State change section
//STATE CHANGE SECTION
if (!exitPointFound && characterData.IsOnWorldMap)
{
_logger.UpdateLog($"Cannot find location exit point for character's ID [{movementDetails.CharId}] wm_id [{wmId}] parent object ID [{parentObjectId}]");
SendMessageToPlayer(movementDetails.CharId, "Error: cannot find entry point!");
}
else
{
characterData.IsOnWorldMap = !isOnWorldMap;
_logger.UpdateLog($"Movement type switched for character's ID [{movementDetails.CharId}] to {(characterData.IsOnWorldMap ? "world" : "local")} state");
positionDetailsToSend = new CharacterPositionUpdateDetails()
{
MovementType = (characterData.IsOnWorldMap ? "switchmap" : "switchlocal"),
CharId = movementDetails.CharId,
OldLocationLocal = characterData.CurrentLoc.Copy(),
NewLocationLocal = characterData.CurrentLoc.Copy(),
TimeArrivalMsLocal = 0,
OldLocationWorld = characterData.CurrentWorldLoc.Copy(),
NewLocationWorld = characterData.CurrentWorldLoc.Copy()
};
if (characterData.IsOnWorldMap)
{
SendMovementDetailsToCurrentPlayerAsync(positionDetailsToSend, movementDetails.CharId);
}
SendMovementDetailsToPlayersInLocationAsync(positionDetailsToSend, wmId, false, parentObjectId);
}
#endregion
}
break;
case CharacterMovementDetails.MovementType.Local:
{
#region Local movement handling
//LOCAL MOVEMENT HANDLING
if (isOnWorldMap)
{
_logger.UpdateLog($"Movement details handling warning - local movement cancelled for character's ID [{movementDetails.CharId}], reason: world map state");
}
else
{
#region Geo data validation
//GEO DATA VALIDATION
using
(
BoxedData geoBoxedData = await _geoDataInfo.GetLocalGeoDataTaskStart
(
wmId,
parentObjectId,
PointConverter.Point3DoubleToInt(movementDetails.OldLocationLocal),
PointConverter.Point3DoubleToInt(movementDetails.NewLocationLocal)
)
)
{
geoDataList = (List <GeoDataElement>)geoBoxedData.Data;
if (!String.IsNullOrEmpty(geoBoxedData.Msg))
{
_logger.UpdateLog(geoBoxedData.Msg);
}
}
using (BoxedData geoValidationBoxedData = await GeoDataValidator.ValidateMovementTaskStart(geoDataList, movementDetails))
{
geoDataValidationDetails = (GeoDataValidationDetails)geoValidationBoxedData.Data;
if (!String.IsNullOrEmpty(geoValidationBoxedData.Msg))
{
_logger.UpdateLog(geoValidationBoxedData.Msg);
}
geoMovementValid = geoDataValidationDetails.Valid;
lastValidMovementPoint = geoDataValidationDetails.LastValidMovementPoint;
lastTParamValue = geoDataValidationDetails.LastTParamValue;
geoDataValidationDetails.Dispose();
geoDataValidationDetails = null;
}
#endregion
//_logger.UpdateLog($"GEO VALID [{geoMovementValid}]");
//geoMovementValid = true; //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//CHARACTER MOVING
if (geoMovementValid)
{
characterData.MoveCharacterLocal
(
movementDetails.OldLocationLocal.Copy(),
movementDetails.NewLocationLocal.Copy(),
movementDetails.TimeArrivalMsLocal
);
positionDetailsToSend = new CharacterPositionUpdateDetails()
{
MovementType = "movelocal",
CharId = movementDetails.CharId,
OldLocationLocal = movementDetails.OldLocationLocal.Copy(),
NewLocationLocal = movementDetails.NewLocationLocal.Copy(),
TimeArrivalMsLocal = movementDetails.TimeArrivalMsLocal,
OldLocationWorld = new Point2 <int>(0, 0),
NewLocationWorld = new Point2 <int>(0, 0)
};
SendMovementDetailsToPlayersInLocationAsync(positionDetailsToSend, wmId, isOnWorldMap, parentObjectId);
}
else
{
timeArrivalMsIncomplete = Convert.ToInt32(Convert.ToDouble(movementDetails.TimeArrivalMsLocal) * lastTParamValue);
characterData.MoveCharacterLocal
(
movementDetails.OldLocationLocal.Copy(),
lastValidMovementPoint.Copy(),
timeArrivalMsIncomplete
);
positionDetailsToSend = new CharacterPositionUpdateDetails()
{
MovementType = "movelocal",
CharId = movementDetails.CharId,
OldLocationLocal = movementDetails.OldLocationLocal.Copy(),
NewLocationLocal = lastValidMovementPoint.Copy(),
TimeArrivalMsLocal = timeArrivalMsIncomplete,
OldLocationWorld = new Point2 <int>(0, 0),
NewLocationWorld = new Point2 <int>(0, 0)
};
SendMovementDetailsToPlayersInLocationAsync(positionDetailsToSend, wmId, isOnWorldMap, parentObjectId);
}
}
#endregion
}
break;
case CharacterMovementDetails.MovementType.World:
{
#region World map movement handling
//WORLD MAP MOVEMENT HANDLING
if (!isOnWorldMap)
{
_logger.UpdateLog($"Movement details handling warning - world map movement cancelled for character's ID [{movementDetails.CharId}], reason: local movement state");
}
else
{
Point2 <int> oldLocWorld = movementDetails.OldLocationWorld.Copy();
Point2 <int> newLocWorld = movementDetails.NewLocationWorld.Copy();
//WORLD MOVEMENT VALIDATION
worldMovingValid = true;
int distanceX = Math.Abs(oldLocWorld.X - newLocWorld.X);
int distanceY = Math.Abs(oldLocWorld.Y - newLocWorld.Y);
if
(
oldLocWorld.X != characterData.CurrentWorldLoc.X || oldLocWorld.Y != characterData.CurrentWorldLoc.Y ||
distanceX > 2 || distanceY > 2
)
{
worldMovingValid = false;
//_logger.UpdateLog($"Movement details handling warning - world map movement cancelled for character's ID [{movementDetails.CharId}]");
}
//CHARACTER MOVING
if (worldMovingValid)
{
WorldPlaceDataDetails worldPlaceDetails = _geoDataInfo.GetWorldPlaceDataDetails(newLocWorld.X, newLocWorld.Y);
int newWmId = (worldPlaceDetails != null ? worldPlaceDetails.WmId : -1);
characterData.MoveCharacterWorld(newLocWorld);
positionDetailsToSend = new CharacterPositionUpdateDetails()
{
MovementType = "moveworld",
CharId = movementDetails.CharId,
OldLocationLocal = new Point3 <double>(0, 0, 0),
NewLocationLocal = new Point3 <double>(0, 0, 0),
TimeArrivalMsLocal = 0,
OldLocationWorld = oldLocWorld,
NewLocationWorld = newLocWorld
};
SendMovementDetailsToPlayersInLocationAsync(positionDetailsToSend, wmId, isOnWorldMap, parentObjectId);
ChangeWmIdAsync(characterData, newWmId);
}
else
{
SendMessageToPlayer(movementDetails.CharId, "You're moving too far");
}
}
#endregion
}
break;
default:
throw new Exception($"unknown movement type [{movementDetails.Type.ToString()}]!");
}
}
#endregion
#region Temp. list disposal
//TEMP. LIST DISPOSAL
foreach (CharacterMovementDetails item in movementDetailsListTemp)
{
item.Dispose();
}
movementDetailsListTemp.Clear();
#endregion
}while (_movementHandlingInProgress);
}
catch (Exception exception)
{
_logger.UpdateLog($"Character movement handling error: {exception.Message}");
}
finally
{
_movementHandlingInProgress = false;
_logger.UpdateLog("Game state handler - character movement handling stopped!");
}
}
/// <summary>
/// Gets data from table 'characters'
/// </summary>
public BoxedData GetCharactersData(string sqlFilter = "")
{
BoxedData data = new BoxedData();
List <DbCharactersData> resultList = new List <DbCharactersData>();
string msg = "";
try
{
int charId = -1;
string name = "";
int accId = -1;
bool isNpc = false;
string npcAltName = "";
bool isOnWorldMap = false;
int wmId = -1;
int terrainParentId = -1;
decimal localPosX = 0.0000M;
decimal localPosY = 0.0000M;
decimal localPosZ = 0.0000M;
decimal localAngle = 0.0000M;
string modelCode = "";
int hairstyleId = 0;
string query = @"
SELECT
`char_id`,
`char_name`,
`char_acc_id`,
`char_is_npc`,
`char_npc_alt_name`,
`char_is_on_world_map`,
`char_wm_id`,
`char_terrain_parent_id`,
`char_local_pos_x`,
`char_local_pos_y`,
`char_local_pos_z`,
`char_local_angle`,
`char_model_code`,
`char_hairstyle_id`
FROM
`characters`
";
if (!String.IsNullOrWhiteSpace(sqlFilter))
{
query += $" {(!sqlFilter.ToUpper().Contains("WHERE") ? "WHERE" : "")} {sqlFilter}";
}
lock (_connectionLock)
{
using (MySqlCommand command = new MySqlCommand(query, _connection))
{
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
charId = reader.GetInt32("char_id");
name = reader["char_name"].ToString();
accId = reader.GetInt32("char_acc_id");
isNpc = (reader.GetInt32("char_is_npc") == 1);
npcAltName = reader["char_npc_alt_name"].ToString();
isOnWorldMap = (reader.GetInt32("char_is_on_world_map") == 1);
wmId = reader.GetInt32("char_wm_id");
terrainParentId = reader.GetInt32("char_terrain_parent_id");
localPosX = reader.GetDecimal("char_local_pos_x");
localPosY = reader.GetDecimal("char_local_pos_y");
localPosZ = reader.GetDecimal("char_local_pos_z");
localAngle = reader.GetDecimal("char_local_angle");
modelCode = reader["char_model_code"].ToString();
hairstyleId = reader.GetInt32("char_hairstyle_id");
DbCharactersData result = new DbCharactersData
(
charId,
name,
accId,
isNpc,
npcAltName,
isOnWorldMap,
wmId,
terrainParentId,
localPosX,
localPosY,
localPosZ,
localAngle,
modelCode,
hairstyleId
);
resultList.Add(result);
}
}
}
}
}
catch (Exception exception)
{
msg = $"Cannot get data from 'characters' table, SQL filter [{sqlFilter}]: {exception.Message}";
}
data.Data = resultList;
data.Msg = msg;
return(data);
}
/// <summary>
/// Gets data from table 'terrain_objects'
/// </summary>
public BoxedData GetTerrainObjectsData(string sqlFilter = "")
{
BoxedData data = new BoxedData();
List <DbTerrainObjectsData> resultList = new List <DbTerrainObjectsData>();
string msg = "";
try
{
int toId = -1;
int wmId = -1;
int localPosX = -1;
int localPosY = -1;
int localPosZ = -1;
int todId = -1;
int parentId = -1;
bool isParentalTeleport = false;
bool isExit = false;
string query = @"
SELECT
`to_id`,
`to_wm_id`,
`to_local_pos_x`,
`to_local_pos_y`,
`to_local_pos_z`,
`to_tod_id`,
`to_parent_id`,
`to_is_parental_teleport`,
`to_is_exit`
FROM
`terrain_objects`
";
if (!String.IsNullOrWhiteSpace(sqlFilter))
{
query += $" {(!sqlFilter.ToUpper().Contains("WHERE") ? "WHERE" : "")} {sqlFilter}";
}
lock (_connectionLock)
{
using (MySqlCommand command = new MySqlCommand(query, _connection))
{
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
toId = reader.GetInt32("to_id");
wmId = reader.GetInt32("to_wm_id");
localPosX = reader.GetInt32("to_local_pos_x");
localPosY = reader.GetInt32("to_local_pos_y");
localPosZ = reader.GetInt32("to_local_pos_z");
todId = reader.GetInt32("to_tod_id");
parentId = reader.GetInt32("to_parent_id");
isParentalTeleport = (reader.GetInt32("to_is_parental_teleport") == 1);
isExit = (reader.GetInt32("to_is_exit") == 1);
DbTerrainObjectsData result = new DbTerrainObjectsData
(
toId,
wmId,
localPosX,
localPosY,
localPosZ,
todId,
parentId,
isParentalTeleport,
isExit
);
resultList.Add(result);
}
}
}
}
}
catch (Exception exception)
{
msg = $"Cannot get data from 'terrain_objects' table, SQL filter [{sqlFilter}]: {exception.Message}";
}
data.Data = resultList;
data.Msg = msg;
return(data);
}
/// <summary>
/// Gets data from table 'accounts'
/// </summary>
public BoxedData GetAccountsData(string sqlFilter = "")
{
BoxedData data = new BoxedData();
List <DbAccountsData> resultList = new List <DbAccountsData>();
string msg = "";
try
{
int id = -1;
string login = "";
string passEncrypted = "";
int accessLevel = 0;
string query = @"
SELECT
`acc_id`,
`acc_login`,
`acc_pass`,
`acc_access_level`
FROM
`accounts`
";
if (!String.IsNullOrWhiteSpace(sqlFilter))
{
query += $" {(!sqlFilter.ToUpper().Contains("WHERE") ? "WHERE" : "")} {sqlFilter}";
}
lock (_connectionLock)
{
using (MySqlCommand command = new MySqlCommand(query, _connection))
{
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
id = reader.GetInt32("acc_id");
login = reader["acc_login"].ToString();
passEncrypted = reader["acc_pass"].ToString();
accessLevel = reader.GetInt32("acc_access_level");
DbAccountsData result = new DbAccountsData
(
id,
login,
passEncrypted,
DbAccountsData.PasswordType.Encrypted,
accessLevel
);
resultList.Add(result);
}
}
}
}
}
catch (Exception exception)
{
msg = $"Cannot get data from 'accounts' table, SQL filter [{sqlFilter}]: {exception.Message}";
}
data.Data = resultList;
data.Msg = msg;
return(data);
}
private BoxedData FillTerrainDetails(List <DbTerrainObjectsData> terrainDataList)
{
BoxedData data = new BoxedData();
bool success = false;
string msg = "";
try
{
int toId;
int wmId;
int localPosX;
int localPosY;
int localPosZ;
int todId;
int parentId;
bool isParentalTeleport;
bool isExit;
DbTerrainObjectDefinitions terrainDefinition;
lock (_terrainDetailsLock)
{
foreach (DbTerrainObjectsData terrainData in terrainDataList)
{
toId = terrainData.ToId;
wmId = terrainData.WmId;
localPosX = terrainData.LocalPosX;
localPosY = terrainData.LocalPosY;
localPosZ = terrainData.LocalPosZ;
todId = terrainData.TodId;
parentId = terrainData.ParentId;
isParentalTeleport = terrainData.IsParentalTeleport;
isExit = terrainData.IsExit;
terrainDefinition = (todId > -1 ? GetTerrainDefinition(todId) : null);
if
(
localPosX < 0 || localPosX >= _terrainDetails.GetLength(0) ||
localPosY < 0 || localPosY >= _terrainDetails.GetLength(1) ||
localPosZ < 0 || localPosZ >= _terrainDetails.GetLength(2)
)
{
continue;
}
//Console.WriteLine($"Terrain details - wm_id [{wmId}] local pos [{localPosX}, {localPosY}, {localPosZ}] parent [{parentId}] is TP [{isParentalTeleport}] exit [{isExit}]");
_terrainDetails[localPosX, localPosY, localPosZ] = new PlaceInstanceTerrainDetails
(
toId,
wmId,
localPosX,
localPosY,
localPosZ,
parentId,
isParentalTeleport,
isExit,
terrainDefinition
);
if (isExit)
{
_exitElementsIndexList.Add(Tuple.Create(localPosX, localPosY, localPosZ));
}
}
}
success = true;
}
catch (Exception exception)
{
msg = $"Error - terrain details filling - place instance ID [{this.PlaceInstanceId}]: {exception.Message}";
}
data.Data = success;
data.Msg = msg;
return(data);
}
/// <summary>
/// Gets data from table 'world_map'
/// </summary>
public BoxedData GetWorldMapData(string sqlFilter = "")
{
BoxedData data = new BoxedData();
List <DbWorldMapData> resultList = new List <DbWorldMapData>();
string msg = "";
try
{
int wmId = -1;
int worldPosX = -1;
int worldPosY = -1;
int placeType = -1;
int isRandomPlace = 0;
string placeName = "";
string query = @"
SELECT
`wm_id`,
`wm_world_pos_x`,
`wm_world_pos_y`,
`wm_place_type`,
`wm_is_random_place`,
`wm_place_name`
FROM
`world_map`
";
if (!String.IsNullOrWhiteSpace(sqlFilter))
{
query += $" {(!sqlFilter.ToUpper().Contains("WHERE") ? "WHERE" : "")} {sqlFilter}";
}
lock (_connectionLock)
{
using (MySqlCommand command = new MySqlCommand(query, _connection))
{
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
wmId = reader.GetInt32("wm_id");
worldPosX = reader.GetInt32("wm_world_pos_x");
worldPosY = reader.GetInt32("wm_world_pos_y");
placeType = reader.GetInt32("wm_place_type");
isRandomPlace = reader.GetInt32("wm_is_random_place");
placeName = reader["wm_place_name"].ToString();
DbWorldMapData result = new DbWorldMapData
(
wmId,
worldPosX,
worldPosY,
placeType,
(isRandomPlace == 1),
placeName
);
resultList.Add(result);
}
}
}
}
}
catch (Exception exception)
{
msg = $"Cannot get data from 'world_map' table, SQL filter [{sqlFilter}]: {exception.Message}";
}
data.Data = resultList;
data.Msg = msg;
return(data);
}
/// <summary>
/// Gets data from table 'terrain_object_definitions'
/// </summary>
public BoxedData GetTerrainObjectDefinitionsData(string sqlFilter = "")
{
BoxedData data = new BoxedData();
List <DbTerrainObjectDefinitions> resultList = new List <DbTerrainObjectDefinitions>();
string msg = "";
try
{
int todId = -1;
string code = "";
int collisionX = 0;
int collisionY = 0;
int collisionZ = 0;
bool isTerrain = false;
bool isPlatform = false;
bool isObstacle = false;
string query = @"
SELECT
`tod_id`,
`tod_code`,
`tod_collision_x`,
`tod_collision_y`,
`tod_collision_z`,
`tod_is_terrain`,
`tod_is_platform`,
`tod_is_obstacle`
FROM
`terrain_object_definitions`
";
if (!String.IsNullOrWhiteSpace(sqlFilter))
{
query += $" {(!sqlFilter.ToUpper().Contains("WHERE") ? "WHERE" : "")} {sqlFilter}";
}
lock (_connectionLock)
{
using (MySqlCommand command = new MySqlCommand(query, _connection))
{
using (MySqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
todId = reader.GetInt32("tod_id");
code = reader["tod_code"].ToString();
collisionX = reader.GetInt32("tod_collision_x");
collisionY = reader.GetInt32("tod_collision_y");
collisionZ = reader.GetInt32("tod_collision_z");
isTerrain = (reader.GetInt32("tod_is_terrain") == 1);
isPlatform = (reader.GetInt32("tod_is_platform") == 1);
isObstacle = (reader.GetInt32("tod_is_obstacle") == 1);
DbTerrainObjectDefinitions result = new DbTerrainObjectDefinitions
(
todId,
code,
collisionX,
collisionY,
collisionZ,
isTerrain,
isPlatform,
isObstacle
);
resultList.Add(result);
}
}
}
}
}
catch (Exception exception)
{
msg = $"Cannot get data from 'terrain_object_definitions' table, SQL filter [{sqlFilter}]: {exception.Message}";
}
data.Data = resultList;
data.Msg = msg;
return(data);
}
