internal Realm(SharedRealmHandle sharedRealmHandle, RealmConfigurationBase config, RealmSchema schema)
{
Config = config;
RealmState state = null;
var statePtr = sharedRealmHandle.GetManagedStateHandle();
if (statePtr != IntPtr.Zero)
{
state = GCHandle.FromIntPtr(statePtr).Target as RealmState;
}
if (state == null)
{
state = new RealmState();
sharedRealmHandle.SetManagedStateHandle(GCHandle.ToIntPtr(state.GCHandle));
_states.Value[config.DatabasePath] = new WeakReference <RealmState>(state);
}
state.AddRealm(this);
_state = state;
SharedRealmHandle = sharedRealmHandle;
Metadata = schema.ToDictionary(t => t.Name, CreateRealmObjectMetadata);
Schema = schema;
}
public void UpdateWith(RealmState other)
{
foreach (KeyValuePair <String, PlayerState> element in other.players)
{
PlayerState currentPlayerState;
if (this.players.TryGetValue(element.Key, out currentPlayerState))
{
currentPlayerState.UpdateWith(element.Value);
}
else
{
this.players.Add(element.Key, element.Value);
}
}
if (this.map == null)
{
this.map = new MapState();
}
if (other.map != null)
{
map.UpdateWith(other.map);
}
}
/// <inheritdoc />
public void Dispose()
{
if (!IsClosed)
{
// only mutate the state on explicit disposal
// otherwise we do so on the finalizer thread
if (_state.RemoveRealm(this))
{
_states.Value.Remove(Config.DatabasePath);
}
_state = null;
SharedRealmHandle.Close(); // Note: this closes the *handle*, it does not trigger realm::Realm::close().
}
}
public static void SendRealmStateResponse(IPacketReceiver client, uint realmNo)
{
//uint realmSplitState = 0;
// realmNo = 0;
const RealmState realmState = RealmState.Normal;
var splitDate = "01/01/01";
using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_REALM_SPLIT, 8 + 1 + splitDate.Length))
{
packet.WriteUInt(realmNo);
packet.WriteUInt((uint)realmState);
packet.WriteCString(splitDate);
client.Send(packet, addEnd: false);
}
}
private void Dispose(bool disposing)
{
if (IsClosed)
{
return;
}
if (disposing)
{
// only mutate the state on explicit disposal
// otherwise we do so on the finalizer thread
_state.RemoveRealm(this);
}
_state = null;
SharedRealmHandle.Close(); // Note: this closes the *handle*, it does not trigger realm::Realm::close().
}
public bool HandleRealmUpdate(BinaryReader br)
{
var realm = PacketHelper.Parse <RealmState>(br);
if (realm.ID != RealmID)
{
return(true);
}
RealmState = realm;
if (RealmStatusChanged != null)
{
RealmStatusChanged(this, new EventArgs());
}
return(true);
}
public virtual void ReloadState(int frames)
{
var realmData = Context.Resolve <RealmData>();
_teams = new TeamState[realmData.TotalTeams];
for (var index = 0; index < _teams.Length; index++)
{
_teams[index] = new TeamState {
SpawnPoints = realmData.SpawnPoints[index % realmData.SpawnPoints.Length].ToArray()
};
}
_states = new RealmState[frames];
for (var index = 0; index < frames; index++)
{
_states[index] = new RealmState {
PlayerStates = new PlayerState[realmData.TotalPlayers]
};
}
}
// Start is called before the first frame update
async void Start()
{
RealmState initialState = await NetworkConnection.GetStateAsync();
RealmStateManager.UpdateState(initialState);
MapManager.InitMap(initialState.map);
await NetworkConnection.Connect();
while (NetworkConnection.IsOpen())
{
string message = await NetworkConnection.Receive();
if (!string.IsNullOrEmpty(message))
{
try {
NetworkMessage <RealmEventBase> networkMessage = NetworkMessageFactory.GetNetworkMessage(message);
if (networkMessage != null && networkMessage.realmEvent != null && !string.IsNullOrEmpty(networkMessage.realmEventType))
{
// Re-parse with the appropriate event type. This is ugly.
Type eventType = RealmEventRegistry.GetEventDataType(networkMessage.realmEventType);
Type networkMessageType = typeof(NetworkMessage <>).MakeGenericType(eventType);
object genericMessage = NetworkMessageFactory.GetNetworkMessage(message, networkMessageType);
object realmEvent = networkMessageType.GetField("realmEvent").GetValue(genericMessage);
RealmStateManager.UpdateState(networkMessage.realmStateFragment);
// TODO: Fire off this event and continue. Don't wait for a result.
EventManager.TriggerEvent(networkMessage.realmEventType, realmEvent as RealmEventBase);
//RealmStateManager.UpdateState(networkMessage.realmStateFragment);
}
} catch (Exception e) {
Debug.Log("Exception in NetworkHandler: " + e.Message);
Debug.Log(e.StackTrace);
}
}
}
}
public static void UpdateState(RealmState updatedState)
{
instance.realmState.UpdateWith(updatedState);
}
public void HandleAccount(string packet)
{
string[] data = packet.Split('#');
string username = data[0];
string password = data[1].Substring(1);//Sub one, because as a const char '1'
var account = Database.Tables.AccountTable.GetAccountFromSQL(username);
if (account != null)
{
if (Utilities.Hash.CryptPass(this.EncryptKey, account.Password) == password)
{
this.Account = account;
Database.Tables.AccountTable.UpdateLogged(this.Account.Username, 1);
this.Send("Ad" + this.Account.Pseudo);
this.Send("Ac0");
this.Characters = Managers.MultiServerManager.GetCharactersInformations(this.Account);
Managers.MultiServerManager.SendServerState(this);
this.Send("AlK" + (this.Account.AdminLevel > 0 ? 1 : 0));
this.State = RealmState.SERVER_LIST;
Utilities.Logger.Infos("Client was logged with the account @'" + username + "'@");
lock (Managers.MultiServerManager.ConnectedAccounts)
{
if (Managers.MultiServerManager.ConnectedAccounts.Contains(account.Username))
{
Managers.MultiServerManager.Send(new Interop.Crystal.Packets.KickPlayerMessage(account.Username));
}
}
}
else
{
this.Send("AlEx");
Utilities.Logger.Error("Wrong password for account @'" + username + "'@");
}
}
else
{
this.Send("AlEx");
Utilities.Logger.Error("Can't found account @'" + username + "'@");
}
}
public void HandleVersion(string version)
{
if (version == Definitions.DofusVersionRequired)
{
this.State = RealmState.ACCOUNT;
}
else
{
Utilities.Logger.Error("Client has incorrect version of dofus @'" + version + "'@");
this.Send("AlEv" + Definitions.DofusVersionRequired);
}
}
private void NotifyRealmState(String strRealmName, RealmState rstate)
{
string strStateText = "";
switch (rstate)
{
case RealmState.UP:
strStateText = "UP";
break;
case RealmState.DOWN:
strStateText = "DOWN";
break;
default:
strStateText = null;
break;
}
if (strStateText == null) { return; }
AddLogMessage(strRealmName + " is now " + strStateText + ".");
realmNotifyIcon.BalloonTipText = strRealmName + " is now " + strStateText + ".";
realmNotifyIcon.BalloonTipIcon = ToolTipIcon.Info;
realmNotifyIcon.ShowBalloonTip(100);
}
