//-------------------------------------------------
#region Contructors Region
public DataBaseUpdateRequest(StrongString theMessage, StrongString theContext, StrongString theSha) :
base(theMessage.GetValue(),
QString.Parse(theContext).GetString(),
theSha.GetValue())
{
// do nothing here...
}
//-------------------------------------------------
#region static Method's Region
public static async Task <bool> GenerateFirstGeneration()
{
IServerProvider <QString, DataBaseClient> _s;
StrongString _target = ServerManager.Generation_Location_Name;
StrongString myString;
DataBaseCreation _req;
int first_index;
for (int i = MIN_SERVER_INDEX; i <= MAX_SERVER_INDEX; i++)
{
_s = ThereIsServer.ServersInfo.ServerManager.Get_UID_Generation_Server(i);
if (!await ThereIsServer.Actions.Exists(_s, _target))
{
first_index = i + BASE_UID_SERVER_INDEX_SHOW;
myString = first_index.ToString(INDEX_FORMAT) + FIRST_GENERATION;
_req = new DataBaseCreation(UID_MESSAGE, QString.Parse(myString));
await ThereIsServer.Actions.CreateData(_s, _target, _req);
}
else
{
continue;
}
}
return(true);
}
//--------------------------
private async void TokenObj_Timer_Tick(object sender, EventArgs e)
{
//-----------------
((Timer)sender).Enabled = false;
((Timer)sender).Dispose();
//-----------------
StrongString myString = string.Empty;
#pragma warning disable IDE0059
SecuredMe Hi = new SecuredMe(ref myString);
#pragma warning restore IDE0059
//MessageBox.Show(myString);
var ExistingFiles =
await ThereIsServer.Actions.GetAllContentsByRef(ThereIsServer.ServersInfo.MyServers[0],
Username + ThereIsServer.ServersInfo.EndCheckingFileName);
if (ExistingFiles.IsDeadCallBack || ThereIsServer.ServerSettings.HasConnectionClosed)
{
NoInternetConnectionSandBox.PrepareConnectionClosedSandBox();
return; // don't set ServerSettings.IsWaitingForServerChecking = false;
}
await ThereIsServer.Actions.UpdateFile(ThereIsServer.ServersInfo.MyServers[0],
Username + ThereIsServer.ServersInfo.EndCheckingFileName,
new DataBaseUpdateRequest("SAO", QString.Parse(myString), ExistingFiles.Sha));
ThereIsServer.ServerSettings.TokenObj = myString;
((CreateProfileSandBox)ThereIsConstants.Forming.TheMainForm.ShowingSandBox).IsSignInEnded4 = true;
//-----------------
GC.Collect();
}
//-------------------------------------------------
#region static mathods region
//These methods are server and online working
//so you should use await keyword for them.
public static async Task <DataBaseDataChangedInfo> CreateKingdomThrone(KingdomInfo kingdomInfo)
{
var _notSet = new StrongString[]
{
ThereIsConstants.Path.NotSet, // 0
ThereIsConstants.Path.NotSet, // 1
ThereIsConstants.Path.NotSet, // 2
ThereIsConstants.Path.NotSet, // 3
ThereIsConstants.Path.NotSet, // 4
ThereIsConstants.Path.NotSet, // 5
ThereIsConstants.Path.NotSet, // 6
};
KingdomThrone kingdomThrone = new KingdomThrone()
{
PlayerNames = _notSet,
PlayerUIDs = UID.GenerateNullUIDs(MAXIMUM_POSITION),
};
//---------------------------------------------
var _s = ThereIsServer.ServersInfo.ServerManager.Get_Kingdom_Server(kingdomInfo.Provider);
var _target = KingdomThrone_LOC;
var _req = new DataBaseCreation(MESSAGE, QString.Parse(kingdomThrone.GetForServer()));
return(await ThereIsServer.Actions.CreateData(_s, _target, _req));
//---------------------------------------------
}
//-------------------------------------------------
#region static Method's Region
public static async Task <DataBaseDataChangedInfo> CreateLevelRankings(KingdomInfo kingdom)
{
LevelRankings levelRankings = new LevelRankings()
{
Kingdom = kingdom,
PlayerNames = new StrongString[MAXIMUM_RANKS],
PlayerLevels = new uint[MAXIMUM_RANKS],
PlayerTotalExp = new Unit[MAXIMUM_RANKS],
PlayerUIDs = new UID[MAXIMUM_RANKS],
};
for (int i = 0; i < MAXIMUM_RANKS; i++)
{
levelRankings.PlayerNames[i] = ThereIsConstants.Path.NotSet;
levelRankings.PlayerLevels[i] = 0;
levelRankings.PlayerTotalExp[i] = Unit.GetBasicUnit();
levelRankings.PlayerUIDs[i] = UID.GenerateNullUID();
}
//---------------------------------------------
var _s = ThereIsServer.ServersInfo.ServerManager.Get_Kingdom_Server(levelRankings.Provider);
var _target = LevelRankings_LOC;
var _req = new DataBaseCreation(MESSAGE, QString.Parse(levelRankings.GetForServer()));
return(await ThereIsServer.Actions.CreateData(_s, _target, _req));
//---------------------------------------------
}
//-------------------------------------------------
#region Online and non-static Methods region
public async Task <DataBaseDataChangedInfo> UpdateKingdomThrone()
{
var _s = ThereIsServer.ServersInfo.ServerManager.Get_Kingdom_Server(Provider);
var _target = KingdomThrone_LOC;
var _req = new DataBaseCreation(MESSAGE, QString.Parse(GetForServer()));
return(await ThereIsServer.Actions.CreateData(_s, _target, _req));
}
//-------------------------------------------------
#region static Methods Region
/// <summary>
/// Create player's troops for the first time.
/// Notice: you shoul use this function when player has already selected his
/// Element, so he should has at least one hero to load after it.
/// </summary>
/// <param name="troops"></param>
public static async Task <DataBaseDataChangedInfo> CreatePlayerHero(Hero hero)
{
StrongString myString = hero.GetForServer();
var _p = ThereIsServer.GameObjects.MyProfile;
var _s = ThereIsServer.ServersInfo.ServerManager.Get_HeroInfo_Server(hero);
var _target = _p.UID.GetValue() + LOC_SEPARATOR + hero.HeroID + SERVER_LOC;
var _creation = new DataBaseCreation(HERO_MESSAGE, QString.Parse(myString));
return(await ThereIsServer.Actions.CreateData(_s, _target, _creation));
}
//-------------------------------------------------
#region Constructors Region
private DataBaseContent(RepositoryContent content, QString procedural)
{
Name = QString.Parse(WotoNameString.ToStrong(), false);
Sha = QString.Parse(content.Sha.ToStrong(), false);
Size = content.Size;
TheEncoding = QString.Parse(content.Encoding.ToStrong(), false);
EncodedContent = QString.Parse(content.EncodedContent.ToStrong());
Content = QString.Parse(content.Content.ToStrong(), true);
Target = null;
WotoGenerationProcedural = procedural;
IsDeadCallBack = false;
}
/// <summary>
/// Create player's troops for the first time.
/// </summary>
/// <param name="troops"></param>
public static async Task <DataBaseDataChangedInfo> CreatePlayerResources(PlayerResources playerResources)
{
StrongString myString = GetForServer(playerResources);
string targetFile = ThereIsServer.GameObjects.MyProfile.Username +
EndFileName;
return
(await ThereIsServer.Actions.CreateFile(ThereIsServer.ServersInfo.MyServers[0], targetFile,
new DataBaseCreation("CreatingThePlayerResources",
QString.Parse(myString, false))));
}
/// <summary>
/// Information for parameters at: <see cref="PlayerInfo"/>
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public async void CreatePlayerInfoTimer_Tick(object sender, EventArgs e)
{
((Timer)sender).Enabled = false;
((Timer)sender).Dispose();
//-----------------------------------------------
PlayerName = Username; // 1
PlayerLevel = 0; // 2
PlayerLVLRanking = 0; // 3
PlayerPowerRanking = 0; // 4
PlayerGuildName = NotSetString; // 5
GuildPosition = GuildPosition.NotJoined; // 6
LastSeen = ThereIsConstants.AppSettings.GlobalTiming; // 7
PlayerPower = new Unit(0); // 8
PlayerIntro = NotSetString; // 9
PlayerAvatar = Avatar.GetDefaultAvatar(); // 10
PlayerAvatarFrame = AvatarFrame.GetDefaultAvatarFrame(); // 11
PlayerVIPlvl = 0; // 12
PlayerCurrentExp = Unit.GetBasicUnit(); // 13
PlayerTotalExp = Unit.GetBasicUnit(); // 14
PlayerCurrentVIPExp = Unit.GetBasicUnit(); // 15
ThePlayerElement = PlayerElement.NotSet; // 16
PlayerKingdom = SAO_Kingdoms.NotSet; // 17
SocialPosition = SocialPosition.GetSocialPosition(); // 18
//-----------------------------------------------
var targetFile = Username + FileEndName;
await ThereIsServer.Actions.CreateFile(ThereIsServer.ServersInfo.MyServers[0],
targetFile,
new DataBaseCreation("Testing for Creating",
QString.Parse(PlayerInfoGetForServer())));
//------------------------------------------------------
StrongString myString = string.Empty;
#pragma warning disable IDE0059
SecuredMe Hi = new SecuredMe(ref myString);
#pragma warning restore IDE0059
await ThereIsServer.Actions.CreateFile(ThereIsServer.ServersInfo.MyServers[0],
Username + ThereIsServer.ServersInfo.EndCheckingFileName,
new DataBaseCreation("ReCreatedBySAO", QString.Parse(myString)));
//------------------------------------------------------
((CreateProfileSandBox)ThereIsConstants.Forming.TheMainForm.ShowingSandBox).IsCreatingEnded1 = true;
IsWaitingForSecuredWorking = true;
#pragma warning disable IDE0059
SecuredMe MeSecured = new SecuredMe(true, Username, Password, this);
#pragma warning restore IDE0059
GC.Collect();
}
/// <summary>
/// Create player's troops for the first time.
/// </summary>
/// <param name="troops"></param>
public static async Task <DataBaseDataChangedInfo> CreatePlayerMagicalTroops(MagicalTroop troops)
{
StrongString myString = GetForServer(troops);
//---------------------------------------------
var _me = ThereIsServer.GameObjects.MyProfile;
var _target = _me.UID.GetValue() + MT_Server_LOC;
var _s = ThereIsServer.ServersInfo.ServerManager.Get_MagicalTroops_Server(_me.Socket);
var _req = new DataBaseCreation(MTROOPS_MESSAGE, QString.Parse(myString));
return(await ThereIsServer.Actions.CreateData(_s, _target, _req));
//---------------------------------------------
}
/// <summary>
/// Create player's troops for the first time.
/// </summary>
/// <param name="troops"></param>
public static async Task <DataBaseDataChangedInfo> CreatePlayerResources(PlayerResources playerResources)
{
StrongString myString = playerResources.GetForServer();
//---------------------------------------------
var _me = ThereIsServer.GameObjects.MyProfile;
var _target = _me.UID.GetValue() + EndFileName;
var _s = ThereIsServer.ServersInfo.ServerManager.Get_Resources_Server(_me.Socket);
var _creation = new DataBaseCreation(RES_MESSAGE, QString.Parse(myString));
return(await ThereIsServer.Actions.CreateData(_s, _target, _creation));
//---------------------------------------------
}
/// <summary>
/// Create player's troops for the first time.
/// </summary>
/// <param name="troops"></param>
public async static Task <DataBaseDataChangedInfo> CreatePlayerTroops(Troop[] troops)
{
//---------------------------------------------
StrongString myString = GetForServer(troops);
var _p = ThereIsServer.GameObjects.MyProfile;
var _s = ThereIsServer.ServersInfo.ServerManager.Get_Troops_Server(_p.Socket);
var _target = _p.UID.GetValue() + EndFileName;
var _creation = new DataBaseCreation(TROOP_MESSAGE, QString.Parse(myString));
return(await ThereIsServer.Actions.CreateData(_s, _target, _creation));
//---------------------------------------------
}
/// <summary>
/// use this method just for generating a new UID.
/// </summary>
/// <param name="_username_"></param>
/// <param name="_socket_"></param>
/// <returns></returns>
public static async Task <UID> GenerateUID(StrongString _username_, IPlayerSocket _socket_)
{
int myIndex = Randomic.GetRandom(MIN_SERVER_INDEX, MAX_SERVER_INDEX);
var _s = ThereIsServer.ServersInfo.ServerManager.Get_UID_Generation_Server(myIndex);
StrongString _target = ServerManager.Generation_Location_Name;
UID uid;
ulong _value;
for (var i = 0; ; i++)
{
var existing = await ThereIsServer.Actions.GetAllContentsByRef(_s, _target);
if (existing.IsDeadCallBack || ThereIsServer.ServerSettings.HasConnectionClosed)
{
NoInternetConnectionSandBox.PrepareConnectionClosedSandBox();
return(null);
}
_value = existing.Decode().ToUInt64();
_value++;
var _req = new DataBaseUpdateRequest(UID_MESSAGE, _value.ToString(UID_FORMAT),
existing.Sha.GetStrong());
var _result = await ThereIsServer.Actions.UpdateDataOnce(_s, _target, _req);
if (_result.IsDeadCallBack)
{
continue;
}
if (ThereIsServer.ServerSettings.HasConnectionClosed || i >= MAX_TRY)
{
return(null);
}
break;
}
//----------------------
uid = new UID(myIndex, _value, _socket_, _username_);
_s = ThereIsServer.ServersInfo.ServerManager.Get_UID_Server(uid);
_target = uid.GetValue() + UID_Lcation_Name;
var _creation = new DataBaseCreation(UID_MESSAGE, QString.Parse(uid.GetForServer()));
await ThereIsServer.Actions.CreateData(_s, _target, _creation);
//----------------------
_s = ThereIsServer.ServersInfo.ServerManager.Get_UID_Server(_username_);
_target = _username_ + USERNAME_TO_UID;
_creation = new DataBaseCreation(UID_MESSAGE, QString.Parse(uid.GetValue()));
await ThereIsServer.Actions.CreateData(_s, _target, _creation);
//----------------------
return(uid);
}
public async Task <DataBaseDataChangedInfo> UpdateLevelRankings()
{
var Existing = await ThereIsServer.Actions.GetAllContentsByRef(
ThereIsServer.ServersInfo.MyServers[Kingdom.Index], LevelRankingsFileName);
if (Existing.IsDeadCallBack || ThereIsServer.ServerSettings.HasConnectionClosed)
{
NoInternetConnectionSandBox.PrepareConnectionClosedSandBox();
return(null); // don't set ServerSettings.IsWaitingForServerChecking = false;
}
return(await ThereIsServer.Actions.UpdateFile(
ThereIsServer.ServersInfo.MyServers[Kingdom.Index], LevelRankingsFileName,
new DataBaseUpdateRequest("BY SAO_Game", QString.Parse(GetForServer()), Existing[0].Sha)));
}
public async Task <DataBaseDataChangedInfo> UpdateChatConfiguration()
{
var Existing = await ThereIsServer.Actions.GetAllContentsByRef(
ThereIsServer.ServersInfo.MyServers[BasicDataBaseNum + (int)TheChannel],
DataBaseLocation);
if (Existing.IsDeadCallBack || ThereIsServer.ServerSettings.HasConnectionClosed)
{
NoInternetConnectionSandBox.PrepareConnectionClosedSandBox();
return(null); // don't set ServerSettings.IsWaitingForServerChecking = false;
}
return(await ThereIsServer.Actions.UpdateFile(
ThereIsServer.ServersInfo.MyServers[BasicDataBaseNum + (int)TheChannel],
DataBaseLocation,
new DataBaseUpdateRequest("BY SAO_Game",
QString.Parse(GetForServer(), false), Existing.Sha)));
}
/// <summary>
/// Information for parameters at: <see cref="Me"/>
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void CreateMeTimer_Tick(object sender, EventArgs e)
{
((Timer)sender).Enabled = false;
((Timer)sender).Dispose();
//-----------------------------------------------
AvatarFrameList = AvatarFrameList.GenerateEmptyList();
AvatarList = AvatarList.GenerateEmptyList();
MyBlockList = ChatBlockList.GenerateBlankChatBlockList();
//-----------------------------------------------
var targetFile = Username + FileEndName2;
await ThereIsServer.Actions.CreateFile(ThereIsServer.ServersInfo.MyServers[0],
targetFile,
new DataBaseCreation("Testing for Creating",
QString.Parse(MeGetForServer())));
((CreateProfileSandBox)ThereIsConstants.Forming.TheMainForm.ShowingSandBox).IsCreatingEnded2 = true;
GC.Collect();
}
//-------------------------------------------------
#region static Method's Region
public static async Task <DataBaseDataChangedInfo> CreateKingdomInfo(LTW_Kingdoms index)
{
KingdomInfo kingdomInfo = new KingdomInfo(index)
{
Index = (uint)index,
KingdomName = index.ToString(),
KingsPower = Unit.GetBasicUnit(),
KingdomLevel = 0,
};
//---------------------------------------------
var _s = ThereIsServer.ServersInfo.ServerManager.Get_Kingdom_Server(index);
var _target = KingdomInfo_LOC;
var _req = new DataBaseCreation(MESSAGE, QString.Parse(kingdomInfo.GetForServer()));
return(await ThereIsServer.Actions.CreateData(_s, _target, _req));
//---------------------------------------------
}
/// <summary>
/// Save Player's troops(Update them to the server.)
/// </summary>
/// <param name="troops"></param>
public static async Task <DataBaseDataChangedInfo> SavePlayerHeroes(Hero[] heroes)
{
StrongString myString = GetForServer(heroes);
string targetFile = ThereIsServer.GameObjects.MyProfile.Username +
EndFileName;
var ExistingFile =
await ThereIsServer.Actions.GetAllContentsByRef(ThereIsServer.ServersInfo.MyServers[0],
targetFile);
if (ExistingFile.IsDeadCallBack || ThereIsServer.ServerSettings.HasConnectionClosed)
{
NoInternetConnectionSandBox.PrepareConnectionClosedSandBox();
return(null); // don't set ServerSettings.IsWaitingForServerChecking = false;
}
return(await ThereIsServer.Actions.UpdateFile(ThereIsServer.ServersInfo.MyServers[0],
targetFile,
new DataBaseUpdateRequest("By SAO",
QString.Parse(myString, false), ExistingFile.Sha)));
}
public static async Task <DataBaseDataChangedInfo> CreateNewConfiguration(ChatChannels channel)
{
ChatConfiguration configuration = new ChatConfiguration(channel)
{
Status = ChatChannelStatus.FreeForAll,
ItemPrice = "notSet",
MinimumLvl = 0,
BanList = ChatBlockList.GenerateBlankChatBlockList(),
};
configuration.SetLimitationTime();
//---------------------------------------------
var _s = ThereIsServer.ServersInfo.ServerManager.Get_Channel_Server(channel);
var _req = new DataBaseCreation(MESSAGE, QString.Parse(configuration.GetForServer()));
return(await ThereIsServer.Actions.CreateData(_s, DataBaseLocation, _req));
//---------------------------------------------
}
private async Task <DataBaseDataChangedInfo> UpdateChatMessages()
{
//---------------------------------------------
var _s = ThereIsServer.ServersInfo.ServerManager.Get_Channel_Server(Channel);
var _existing = await ThereIsServer.Actions.GetAllContentsByRef(_s, ChatDataBaseLocation);
//---------------------------------------------
if (_existing.IsDeadCallBack || ThereIsServer.ServerSettings.HasConnectionClosed)
{
NoInternetConnectionSandBox.PrepareConnectionClosedSandBox();
return(null); // don't set ServerSettings.IsWaitingForServerChecking = false;
}
//---------------------------------------------
var _req = new DataBaseUpdateRequest(MESSAGE, QString.Parse(GetForServer()), _existing[0].Sha);
return(await ThereIsServer.Actions.UpdateData(_s, ChatDataBaseLocation, _req));
//---------------------------------------------
}
public async Task <DataBaseDataChangedInfo> UpdateMe()
{
//-----------------------------------------------
var targetFile = Username + FileEndName2;
var existingFile =
await ThereIsServer.Actions.GetAllContentsByRef(ThereIsServer.ServersInfo.MyServers[0],
targetFile);
if (existingFile.IsDeadCallBack || ThereIsServer.ServerSettings.HasConnectionClosed)
{
NoInternetConnectionSandBox.PrepareConnectionClosedSandBox();
return(null); // don't set ServerSettings.IsWaitingForServerChecking = false;
}
return(await ThereIsServer.Actions.UpdateFile(ThereIsServer.ServersInfo.MyServers[0],
targetFile,
new DataBaseUpdateRequest("Testing for Creating",
QString.Parse(MeGetForServer()),
existingFile.Sha)));
}
//-------------------------------------------------
#region online Method's Region
public async Task <DataBaseDataChangedInfo> UpdateLevelRankings()
{
//---------------------------------------------
var _s = ThereIsServer.ServersInfo.ServerManager.Get_Kingdom_Server(Provider);
var _target = LevelRankings_LOC;
var existing = await ThereIsServer.Actions.GetAllContentsByRef(_s, _target);
//---------------------------------------------
if (existing.IsDeadCallBack || ThereIsServer.ServerSettings.HasConnectionClosed)
{
NoInternetConnectionSandBox.PrepareConnectionClosedSandBox();
return(null); // don't set ServerSettings.IsWaitingForServerChecking = false;
}
//---------------------------------------------
var _req = new DataBaseUpdateRequest(MESSAGE, QString.Parse(GetForServer()), existing.Sha);
return(await ThereIsServer.Actions.UpdateData(_s, _target, _req));
//---------------------------------------------
}
public static async Task <DataBaseDataChangedInfo> SavePlayerTroops(Troop[] troops, Player _p)
{
StrongString myString = GetForServer(troops);
//---------------------------------------------
var _s = ThereIsServer.ServersInfo.ServerManager.Get_Troops_Server(_p.Socket);
var _target = _p.UID.GetValue() + EndFileName;
var existing = await ThereIsServer.Actions.GetAllContentsByRef(_s, _target);
//---------------------------------------------
if (existing.IsDeadCallBack || ThereIsServer.ServerSettings.HasConnectionClosed)
{
NoInternetConnectionSandBox.PrepareConnectionClosedSandBox();
return(null);
}
//---------------------------------------------
var _req = new DataBaseUpdateRequest(TROOP_MESSAGE, QString.Parse(myString), existing.Sha);
return(await ThereIsServer.Actions.UpdateData(_s, _target, _req));
//---------------------------------------------
}
public async Task <DataBaseDataChangedInfo> UpdatePlayerInfo(DataBaseContent existing)
{
try
{
//-----------------------------------------
var _target = UID.GetValue() + PI_Server_LOC;
var _s = ThereIsServer.ServersInfo.ServerManager.Get_PlayerInfo_Server(Socket);
//-----------------------------------------
if (existing.IsDeadCallBack || ThereIsServer.ServerSettings.HasConnectionClosed)
{
NoInternetConnectionSandBox.PrepareConnectionClosedSandBox();
return(null);
}
var _req = new DataBaseUpdateRequest(MESSAGE, QString.Parse(PlayerInfoGetForServer()), existing.Sha);
return(await ThereIsServer.Actions.UpdateData(_s, _target, _req));
}
catch
{
return(null);
}
}
/// <summary>
/// Save Player's Resources(Update them to the server.)
/// </summary>
/// <param name="troops"></param>
public static async Task <DataBaseDataChangedInfo> SavePlayerResources(PlayerResources _r, Player _p)
{
StrongString myString = _r.GetForServer();
//---------------------------------------------
var _s = ThereIsServer.ServersInfo.ServerManager.Get_Resources_Server(_p.Socket);
var _target = _p.UID.GetValue() + EndFileName;
var _existing = await ThereIsServer.Actions.GetAllContentsByRef(_s, _target);
//---------------------------------------------
if (_existing == null || ThereIsServer.ServerSettings.HasConnectionClosed)
{
NoInternetConnectionSandBox.PrepareConnectionClosedSandBox();
return(null); // don't set ServerSettings.IsWaitingForServerChecking = false;
}
//---------------------------------------------
var _req = new DataBaseUpdateRequest(RES_MESSAGE, QString.Parse(myString), _existing.Sha);
return(await ThereIsServer.Actions.UpdateData(_s, _target, _req));
//---------------------------------------------
}
/// <summary>
/// Save Player's troops(Update them to the server.)
/// </summary>
/// <param name="troops"></param>
public static async void SavePlayerTroops(MagicalTroop troops)
{
StrongString myString = GetForServer(troops);
//---------------------------------------------
var _p = ThereIsServer.GameObjects.MyProfile;
var _s = ThereIsServer.ServersInfo.ServerManager.Get_MagicalTroops_Server(_p.Socket);
var _target = _p.UID.GetValue() + MT_Server_LOC;
var existing = await ThereIsServer.Actions.GetAllContentsByRef(_s, _target);
//---------------------------------------------
if (existing.IsDeadCallBack || ThereIsServer.ServerSettings.HasConnectionClosed)
{
NoInternetConnectionSandBox.PrepareConnectionClosedSandBox();
return;
}
//---------------------------------------------
var _req = new DataBaseUpdateRequest(MTROOPS_MESSAGE, QString.Parse(myString), existing.Sha);
await ThereIsServer.Actions.UpdateData(_s, _target, _req);
//---------------------------------------------
}
//-------------------------------------------------
#region Online Method's Region
/// <summary>
/// Update the hero's info.
/// even if you did not change any information,
/// this method will do it's work.
/// so don't use it if you did not change any information.
/// </summary>
/// <returns></returns>
public async Task <DataBaseDataChangedInfo> UpdateHero()
{
StrongString myString = GetForServer();
//---------------------------------------------
var _p = ThereIsServer.GameObjects.MyProfile;
var _target = _p.UID.GetValue() + LOC_SEPARATOR + HeroID + SERVER_LOC;
var _s = ThereIsServer.ServersInfo.ServerManager.Get_HeroInfo_Server(this);
var _existing = await ThereIsServer.Actions.GetAllContentsByRef(_s, _target);
//---------------------------------------------
if (_existing.IsDeadCallBack || ThereIsServer.ServerSettings.HasConnectionClosed)
{
NoInternetConnectionSandBox.PrepareConnectionClosedSandBox();
return(null); // don't set ServerSettings.IsWaitingForServerChecking = false;
}
//---------------------------------------------
var _req = new DataBaseUpdateRequest(HERO_MESSAGE, QString.Parse(myString), _existing.Sha);
return(await ThereIsServer.Actions.UpdateData(_s, _target, _req));
//---------------------------------------------
}
//-------------------------------------------------
#region static Methods Region
public static async Task <DataBaseDataChangedInfo> CreatePowerRankings(KingdomInfo kingdom)
{
PowerRankings powerRankings = new PowerRankings()
{
Kingdom = kingdom,
PlayerNames = new StrongString[MAXIMUM_RANKS],
PlayerPowers = new Unit[MAXIMUM_RANKS]
};
for (int i = 0; i < MAXIMUM_RANKS; i++)
{
powerRankings.PlayerNames[i] = ThereIsConstants.Path.NotSet;
powerRankings.PlayerPowers[i] = Unit.GetBasicUnit();
}
return(await ThereIsServer.Actions.CreateFile(ThereIsServer.ServersInfo.MyServers[kingdom.Index],
PowerRankingsFileName, new DataBaseCreation("Created_BY_SAO",
QString.Parse(powerRankings.GetForServer()))));
}
public static async Task <DataBaseDataChangedInfo> CreateNewConfiguration(ChatChannels channel)
{
ChatConfiguration configuration = new ChatConfiguration(channel)
{
Status = ChatChannelStatus.FreeForAll,
ItemPrice = "notSet",
MinimumLvl = 0,
BanList = ChatBlockList.GenerateBlankChatBlockList(),
};
configuration.SetLimitationTime();
return(await ThereIsServer.Actions.CreateFile(ThereIsServer.ServersInfo.MyServers[BasicDataBaseNum + (int)channel],
DataBaseLocation, new DataBaseCreation("Created By SAO_Game",
QString.Parse(configuration.GetForServer(), false))));
}
