/***
* Gère la conversion et la sauvegarde dans un fichier json
* @param InfoEvent [evennements reçu]
* @return void
*/
void Sauvegarder(InfoEvent evennement)
{
_sauvegarde.positionJoueur = _teddy.transform.position;
_sauvegarde.pointVieJoueur = _teddyScript.pointDeVie;
_sauvegarde.pointVieMaxJoueur = _teddyScript.pointDeVieMax;
_sauvegarde.armeEquipe = _teddyScript.armeActuelle.nom;
_sauvegarde.inventaireArme = _teddyScript.inventaireArme;
_sauvegarde.experienceJoueur = _gestionnaireCombat.experience;
_sauvegarde.experienceMaxJoueur = _gestionnaireCombat.experienceMax;
_sauvegarde.experienceJoueurTotal = _gestionnaireCombat.experienceTotal;
_sauvegarde.experienceJoueurNextLevel = _gestionnaireCombat.experienceNextLevel;
_sauvegarde.niveau = _gestionnaireCombat.niveau;
_sauvegarde.rage = _teddyScript.GetComponent <Rage>().pointsDeRage;
_sauvegarde.stats = _statScript.RecupererStat();
_sauvegarde.ventilationEstBriser = _ventilation.estDetruit;
string stringJson = JsonUtility.ToJson(_sauvegarde);
if (System.IO.Directory.Exists("Assets/Resources/Saves"))
{
System.IO.File.WriteAllText("Assets/Resources/Saves/save.json", stringJson);
}
else
{
System.IO.Directory.CreateDirectory("Assets/Resources/Saves");
System.IO.File.WriteAllText("Assets/Resources/Saves/save.json", stringJson);
}
}
/// <summary>
/// Processes the message
/// </summary>
/// <param name="connectionBase">The connection base</param>
/// <param name="message">The playerio message</param>
/// <param name="handled">Whether the message was already handled</param>
public void Process(ConnectionBase connectionBase, Message message, bool handled)
{
string title = message.GetString(0);
string text = message.GetString(1);
ChatMessage systemMessage = new ChatMessage(null, string.Format("{0} {1}", title, text));
if (connectionBase is LobbyConnection)
{
LobbyConnection lobbyCon = (LobbyConnection)connectionBase;
if (!handled)
{
lobbyCon.MessageOfTheDay = message.GetString(1);
}
}
else if (connectionBase is WorldConnection)
{
if (!handled)
{
WorldConnection worldCon = (WorldConnection)connectionBase;
worldCon.Chat.Add(systemMessage);
}
}
InfoEvent infoEvent = new InfoEvent()
{
Raw = message,
SystemMessage = systemMessage
};
connectionBase.RaiseServerEvent <InfoEvent>(infoEvent);
}
/// <summary>
/// Information received when plugin is connected to Touch Portal.
/// </summary>
/// <param name="message"></param>
public void OnInfoEvent(InfoEvent message)
{
_logger?.LogInformation($"[Info] VersionCode: '{message.TpVersionCode}', VersionString: '{message.TpVersionString}', SDK: '{message.SdkVersion}', PluginVersion: '{message.PluginVersion}', Status: '{message.Status}'");
_settings = message.Settings;
_logger?.LogInformation($"[Info] Settings: {JsonSerializer.Serialize(_settings)}");
}
public void Save()
{
File.WriteAllText(FileName, scintillaZ80Monitor1.Text);
InfoEvent?.Invoke(this, new InfoEventArgs("Saved " + FileName));
originalText = scintillaZ80Monitor1.Text;
Text = Path.GetFileName(FileName);
}
/**
* Fonction d'initialisation de départ des statistiques
* Récupère aussi les stats depuis le fichier de sauvegarde, puis actualise l'UI
* @param void
* @return void
*/
void Start()
{
if (System.IO.File.Exists("Assets/Resources/Saves/save.json"))
{
InfoEvent info = new InfoEvent();
Sauvegarde _sauvegarde;
_sauvegarde = ScriptableObject.CreateInstance <Sauvegarde>();
string stringJson = System.IO.File.ReadAllText("Assets/Resources/Saves/save.json");
JsonUtility.FromJsonOverwrite(stringJson, _sauvegarde);
constitution = _sauvegarde.stats[0];
force = _sauvegarde.stats[1];
attaque = _sauvegarde.stats[2];
chance = _sauvegarde.stats[3];
info.stats.Constitution = constitution;
info.stats.Force = force;
info.stats.Attaque = attaque;
info.stats.Chance = chance;
SystemeEvents.Instance.LancerEvent(NomEvent.levelUpEvent, info);
}
Constitution.ValeurBase = constitution;
Force.ValeurBase = force;
Attaque.ValeurBase = attaque;
Chance.ValeurBase = chance;
}
/**
* Fonction de débugage de la mort d'un ennemi
* @param void
* @return void
*/
void MortEnnemiDebug(InfoEvent info)
{
if (mortEnnemi)
{
Debug.Log("ENNEMIE MORT: " + info.Experience);
}
}
public void FinishFrameSet(string identifier, InfoEvent frameSetStart)
{
queue.Add(new FrameData(identifier)
{
RawFrame = frameSetStart
});
}
public LogInfoData(string _Session, InfoEvent _Event, string _Parameters)
{
this.Session = _Session;
this.Event = _Event;
this.Parameters = _Parameters;
this.Timestamp = GenericUtilities.GetTimestampForNow();
}
/**
* Fonction qui est éxécutée lors de la réception d'un événement de mort d'un ennemi
* @param class InfoEvent infoEvent
* @return void
*/
void MortEnnemiEvent(InfoEvent infoEvent)
{
//Gain en EXP
AjouterExp(infoEvent);
//Update de la rage
UpdateRage();
}
/***
* instancie un ennemi grâce au paramètre infoEvent
* @param InfoEvent [contient l'ensemble des paramètres nécéssaire à l'instantiation des ennemis]
* @return void
*/
private void InstantierEnnemi(InfoEvent infoEvent)
{
var clone = Instantiate(ennemieASpawn[infoEvent.Ennemi]);
clone.transform.position = infoEvent.Position;
clone.GetComponent <Ennemi>().spawner = infoEvent.Cible;
}
public void Equality_Default()
{
var a = new InfoEvent();
var b = new InfoEvent();
Assert.AreEqual(a, b);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
}
public LogInfoData(int appSession, InfoEvent _event, AppScene _scene, string additionalData)
{
AppSession = appSession;
Event = _event;
Scene = _scene;
AdditionalData = additionalData;
Timestamp = GenericHelper.GetTimestampForNow();
}
public void SetValues()
{
var sut = new InfoEvent {
Info = "A"
};
Assert.AreEqual("A", sut.Info);
}
private void MMessageBus_LoadingStatusHandler(object sender, InfoEvent e)
{
//UserInfo.Text = e.Message;
sStatus = e.Message;
UpdateData();
Thread.Sleep(10);
timer1.Start();
}
public void AnalizData()
{
if (ONData.DataNew != null && ONData.DataOld != null)
{
int added = ReaderNew.RowsId.Except(ReaderOld.RowsId).Count();
int deleted = ReaderOld.RowsId.Except(ReaderNew.RowsId).Count();
InfoEvent?.Invoke($"Добавлено строк: {added} Удалено строк: {deleted} Всего строк: {ReaderNew.RowsId.Count}");
}
}
public void Equality_DifferentInfo()
{
var a = new InfoEvent {
Info = "a"
};
var b = new InfoEvent();
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void Equality_BaseIsCalled()
{
var a = new InfoEvent {
IDESessionUUID = "a"
};
var b = new InfoEvent();
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
/*
* Fonction de lancement d'un évènement
* @param NomEvent nomEvent
* @param InfoEvent infoEvent
* @return void
*/
public void LancerEvent(NomEvent nomEvent, InfoEvent infoEvent)
{
Action <InfoEvent> cetEvent = null; //Nouvelle instance vide de la classe d'information
//Si l'évènement existe dans le dictionaire...
if (Instance.dictionaireEvents.TryGetValue(nomEvent, out cetEvent))
{
//Éxécute toutes les fonctions abonnées à l'évènement
cetEvent.Invoke(infoEvent);
}
}
public void LogInfo(string session, InfoEvent infoEvent, string parametersString = "")
{
if (AppManager.I.DB == null)
{
Debug.Log("No DB to log to. Player profile is probably not set");
return;
}
var data = new LogInfoData(session, infoEvent, parametersString);
db.Insert(data);
}
public void ShouldSerializeToString()
{
var infoEvent = new InfoEvent
{
Info = "SomeInformation",
};
const string expected =
"{\"$type\":\"KaVE.Commons.Model.Events.InfoEvent, KaVE.Commons\",\"Info\":\"SomeInformation\",\"TriggeredBy\":0}";
JsonAssert.SerializesTo(infoEvent, expected);
}
public void Info(string info, params object[] args)
{
// Do not use Create<InfoEvent>() here, because retrieving the
// active window/document might create a deadlock
var e = new InfoEvent
{
TriggeredAt = _dateUtils.Now,
Info = ReplaceNewLineByBr(string.Format(info, args))
};
FireNow(e);
}
public void LogInfoDoesNotContainNewLines()
{
_uut.Info("A\r\nB");
var actual = GetSinglePublished <InfoEvent>();
var expected = new InfoEvent
{
Info = "A<br />B"
};
AssertSimilarity(expected, actual);
}
public void LogInfo(int appSession, InfoEvent infoEvent, string parametersString = "")
{
if (!AppManager.I.DB.HasLoadedPlayerProfile())
{
Debug.Log("No player profile DB to log to. Player profile is probably not set");
return;
}
var data = new LogInfoData(appSession, infoEvent, AppManager.I.NavigationManager.GetCurrentScene(), parametersString);
db.Insert(data);
}
public void LogInfo()
{
_uut.Info("test");
var actual = GetSinglePublished <InfoEvent>();
var expected = new InfoEvent
{
Info = "test"
};
AssertSimilarity(expected, actual);
}
public void Equality_ReallyTheSame()
{
var a = new InfoEvent {
Info = "A"
};
var b = new InfoEvent {
Info = "A"
};
Assert.AreEqual(a, b);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
}
private static async void WaitForInfoEvent(BotBitsClient botBits, TaskCompletionSource <bool> result,
CancellationToken token)
{
try
{
var e = await InfoEvent.Of(botBits).WaitOneAsync(token);
result.SetException(new MapLoadException(e.Title, e.Text));
}
catch (TaskCanceledException)
{
}
}
/**
* Fonction qui est éxécutée lors de la réception d'un événement de pause du jeu
* @param class InfoEvent info
* @return void
*/
void PauseEvent(InfoEvent info)
{
//Si le jeu doit être en pause...
if (info.EnPause)
{
//Activer la pause
Pause(info.Cible);
}
else
{
//Sinon, remettre le jeu en marche
Resume(info.Cible);
}
}
public void Update()
{
ticks--;
if (ticks == 0)
{
var ev = new InfoEvent(attacker.Name + new ColoredString(" strikes ", Color.White, Color.Black) + target.Name + new ColoredString(" with ", Color.White, Color.Black) + weapon.Name);
attacker.Witness(ev);
target.Witness(ev);
//To do: Damage calculation
if (target is Damageable d)
{
d.OnDamaged(this);
}
}
}
/// <inheritdoc cref="IMessageHandler" />
void IMessageHandler.OnMessage(string message)
{
var eventMessage = MessageResolver.ResolveMessage(message);
switch (eventMessage)
{
case InfoEvent infoEvent:
_lastInfoEvent = infoEvent;
_infoWaitHandle.Set();
_eventHandler.OnInfoEvent(infoEvent);
return;
case CloseEvent _:
Close("TouchPortal sent a Plugin close event.");
return;
case ListChangeEvent listChangeEvent:
_eventHandler.OnListChangedEvent(listChangeEvent);
return;
case BroadcastEvent broadcastEvent:
_eventHandler.OnBroadcastEvent(broadcastEvent);
return;
case SettingsEvent settingsEvent:
_eventHandler.OnSettingsEvent(settingsEvent);
return;
case NotificationOptionClickedEvent notificationEvent:
_eventHandler.OnNotificationOptionClickedEvent(notificationEvent);
return;
case ConnectorChangeEvent connectorChangeEvent:
_eventHandler.OnConnecterChangeEvent(connectorChangeEvent);
return;
//All of Action, Up, Down:
case ActionEvent actionEvent:
_eventHandler.OnActionEvent(actionEvent);
return;
default:
_eventHandler.OnUnhandledEvent(message);
return;
}
}
/// <summary>
/// Loads all classes according to the given namespace
/// </summary>
/// <param name="namespaceName">The name of the namespace</param>
/// <param name="browseTab">true to load all classes, false to load only dynamic and static classes</param>
/// <param name="cancellationToken">The token to cancel the execution</param>
/// <returns>The list with the classes</returns>
/// <exception cref="ArgumentNullException">Will be thrown when the namespace name is null or empty</exception>
/// <exception cref="ManagementException">Will be thrown when an error occured in the management object searcher</exception>
public static List <ClassItem> LoadClasses(string namespaceName, bool browseTab, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(namespaceName))
{
throw new ArgumentNullException(nameof(namespaceName));
}
var searcher = new ManagementObjectSearcher(new ManagementScope(namespaceName),
new WqlObjectQuery("SELECT * FROM meta_class"), null);
var result = new List <ClassItem>();
foreach (var wmiClass in searcher.Get())
{
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
var name = wmiClass["__CLASS"].ToString();
InfoEvent?.Invoke($"{result.Count,4} - current class: {name}");
if (browseTab)
{
var classItem = new ClassItem(name);
classItem.Description = LoadClassDescription(namespaceName, classItem.Name);
result.Add(classItem);
}
else
{
foreach (var qualifier in wmiClass.Qualifiers)
{
if (qualifier.Name.EqualsIgnoreCase("dynamic") || qualifier.Name.EqualsIgnoreCase("static"))
{
var classItem = new ClassItem(name);
result.Add(classItem);
}
}
}
}
return(result.OrderBy(o => o.Name).ToList());
}
