Lire et spliter les lignes d'un tableau pour les lire une par une ?

[Winuty]

Bonjour à tous.

J'ai créé une node personnalisée en Visual Sripting pour sauvegarder mes variables en une seule fois au lieu de plusieurs.(C'est pour la partie Setting, je vais en faire d'autres plus longues pour mes GameObjects.)
Je vous donne tout en bas plus d'explications sur le projet.



Voci mon problème : J'aimerais faire l'inverse (un Get) pour récupérer les lignes du tableau séparément par index.
Pour le moment je n'arrive qu'à récupérer le tableau entier sans pouvoir sélectionner une ligne précise.

Code : Tout sélectionner

Variable = File.ReadAllText(Application.persistentDataPath + "/" + Folder + "/" + File + ".txt");

Ma node "Set" écrit dans un seul fichier texte, un tableau de toutes les variables.
La node va convertir les int, float et bool directement en string pour le fichier txt.
Voci ce que donne le résultat de la node Set :



Donc pour la "Get" je vais mettre des "Parse" pour reconvertir les types, mais surtout split les variables pour ne récupérer que la partie variable, sans sa désigantion.

Si quelqu'un peut m'aider pour identifier l'index de chaque ligne dans un tableau
La je galère à trouver.

Et voici le script de ma node:

Code : Tout sélectionner

using System;
using System.IO;
using UnityEngine;
using Unity.VisualScripting;

[UnitTitle("Set Settings")]
[UnitCategory("[Variables ]")]
[TypeIcon(typeof(GameObject))]
public class Set_Settings : Unit
	
{ 
	[DoNotSerialize]
	[PortLabelHidden]
	public ControlInput Entrance_Flux;
	[DoNotSerialize]
	[PortLabelHidden]
	public ControlOutput Exit_Flux;
	[DoNotSerialize]
	public ValueInput Entrance_Folder;
	[DoNotSerialize]
	public ValueInput Entrance_File;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_1;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_2;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_3;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_4;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_5;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_6;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_7;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_8;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_9;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_10;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_11;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_12;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_13;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_14;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_15;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_16;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_17;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_18;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_19;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_20;
	[DoNotSerialize]
	public ValueInput Entrance_Variable_21; 

	private string Variable_Folder;
	private string Variable_File;	
	private bool Variable_1_bool;
	private int Variable_2_int;
        private string Variable_3;
	private int Variable_4_int;	
	private int Variable_5_int;
	private int Variable_6_int;
	private int Variable_7_int;
	private int Variable_8_int;
	private int Variable_9_int;
	private int Variable_10_int;
	private int Variable_11_int;	
	private bool Variable_12_bool;
	private float Variable_13_float;
	private float Variable_14_float;
	private float Variable_15_float;
	private float Variable_16_float;
	private float Variable_17_float;
	private float Variable_18_float;
	private float Variable_19_float;
	private float Variable_20_float;
	private float Variable_21_float;	

	protected override void Definition()  
	{  
		Entrance_Flux = ControlInput("Entrance_Flux", (flow) =>
		{	
				Variable_Folder = flow.GetValue<string>(Entrance_Folder);
				Variable_File = flow.GetValue<string>(Entrance_File);				

				Variable_1_bool = flow.GetValue<bool>(Entrance_Variable_1);
				string Variable_1 = Variable_1_bool.ToString();
				
				Variable_2_int = flow.GetValue<int>(Entrance_Variable_2);
				string Variable_2 = Variable_2_int.ToString();
				
				Variable_3 = flow.GetValue<string>(Entrance_Variable_3);
				
				Variable_4_int = flow.GetValue<int>(Entrance_Variable_4);
				string Variable_4 = Variable_4_int.ToString();
				
				Variable_5_int = flow.GetValue<int>(Entrance_Variable_5);
				string Variable_5 = Variable_5_int.ToString();
				
				Variable_6_int = flow.GetValue<int>(Entrance_Variable_6);
				string Variable_6 = Variable_6_int.ToString();
				
				Variable_7_int = flow.GetValue<int>(Entrance_Variable_7);
				string Variable_7 = Variable_7_int.ToString();
				
				Variable_8_int = flow.GetValue<int>(Entrance_Variable_8);
				string Variable_8 = Variable_8_int.ToString();
				
				Variable_9_int = flow.GetValue<int>(Entrance_Variable_9);
				string Variable_9 = Variable_9_int.ToString();
				
				Variable_10_int = flow.GetValue<int>(Entrance_Variable_10);
				string Variable_10 = Variable_10_int.ToString();
				
				Variable_11_int = flow.GetValue<int>(Entrance_Variable_11);
				string Variable_11 = Variable_11_int.ToString();
				
				Variable_12_bool = flow.GetValue<bool>(Entrance_Variable_12);
				string Variable_12 = Variable_12_bool.ToString();
				
				Variable_13_float = flow.GetValue<float>(Entrance_Variable_13);
				string Variable_13 = Variable_13_float.ToString();
				
				Variable_14_float = flow.GetValue<float>(Entrance_Variable_14);
				string Variable_14 = Variable_14_float.ToString();
				
				Variable_15_float = flow.GetValue<float>(Entrance_Variable_15);
				string Variable_15 = Variable_15_float.ToString();
				
				Variable_16_float = flow.GetValue<float>(Entrance_Variable_16);
				string Variable_16 = Variable_16_float.ToString();
				
				Variable_17_float = flow.GetValue<float>(Entrance_Variable_17);
				string Variable_17 = Variable_17_float.ToString();
				
				Variable_18_float = flow.GetValue<float>(Entrance_Variable_18);
				string Variable_18 = Variable_18_float.ToString();
				
				Variable_19_float = flow.GetValue<float>(Entrance_Variable_19);
				string Variable_19 = Variable_19_float.ToString();
				
				Variable_20_float = flow.GetValue<float>(Entrance_Variable_20);
				string Variable_20 = Variable_20_float.ToString();
				
				Variable_21_float = flow.GetValue<float>(Entrance_Variable_21);
                		string Variable_21 = Variable_21_float.ToString();				

				Directory.CreateDirectory(Application.persistentDataPath + "/" + Variable_Folder);
				string[] List = {
				null,
				"-Initialization-",
				"Setup: " + Variable_1,
				"GameObject: " + Variable_2,
				"Select: " + Variable_3,
				"Music: " + Variable_4,
				null,
				"-Time-",
				"Hour: " + Variable_5,
				"Minute: " + Variable_6,
				"Second :" + Variable_7,
				"Day: " + Variable_8,
				"Month: " + Variable_9,
				"Year: " + Variable_10,
				"Leap Year: " + Variable_11,
				null,
				"-Camera-",
				"Camera: " + Variable_12,
				"Position X: " + Variable_13,
				"Position Y: " + Variable_14,
				"Position Z: " + Variable_15,
				"Rotation X: " + Variable_16,
				"Rotation Y: " + Variable_17,
				"Rotation Z: " + Variable_18,
				"Scale X: " + Variable_19,
				"Scale Y: " + Variable_20,
				"Scale Z: " + Variable_21,				
				};
				
				File.WriteAllLines(Application.persistentDataPath + "/" + Variable_Folder + "/" + Variable_File + ".txt", List);
				return Exit_Flux;
		});   
		Exit_Flux = ControlOutput("Exit_Flux");
		
		Entrance_Folder = ValueInput<string>("Folder", string.Empty);
		Entrance_File = ValueInput<string>("File", string.Empty);	
		Entrance_Variable_1 = ValueInput<bool>("Setup");
		Entrance_Variable_2 = ValueInput<int>("GameObject");
		Entrance_Variable_3 = ValueInput<string>("Select", string.Empty);
		Entrance_Variable_4 = ValueInput<int>("Music");
		Entrance_Variable_5 = ValueInput<int>("Hour");
		Entrance_Variable_6 = ValueInput<int>("Minute");
		Entrance_Variable_7 = ValueInput<int>("Second");
		Entrance_Variable_8 = ValueInput<int>("Day");
		Entrance_Variable_9 = ValueInput<int>("Month");
		Entrance_Variable_10 = ValueInput<int>("Year");
		Entrance_Variable_11 = ValueInput<int>("Leap Year");	
		Entrance_Variable_12 = ValueInput<bool>("Camera");
		Entrance_Variable_13 = ValueInput<float>("Position X");	
		Entrance_Variable_14 = ValueInput<float>("Position Y");	
		Entrance_Variable_15 = ValueInput<float>("Position Z");
		Entrance_Variable_16 = ValueInput<float>("Rotation X");
		Entrance_Variable_17 = ValueInput<float>("Rotation Y");	
		Entrance_Variable_18 = ValueInput<float>("Rotation Z");	
		Entrance_Variable_19 = ValueInput<float>("Scale X");
		Entrance_Variable_20 = ValueInput<float>("Scale Y");
		Entrance_Variable_21 = ValueInput<float>("Scale Z");	
		
		Succession(Entrance_Flux, Exit_Flux);	
	}
}

Pour mes GameObjects, j'aurais déjà un début de liste comme ceci:


L'idée dans mes codes VS est de placer en début la node Get pour que je puisse tirer une ligne d'une variable de cette node que j'ai besoin vers les nodes de mon code.

La node Set seras placer en bout de code pour récupérer directement toutes les variables mises à jour.
Pour les variables non utilisée je vais dans un premier temps relier toutes les variables de la Get à la Set avant de déplacer la node set sur la droite de mon code.
Comme ça au lieu qu'elle m'enregistre une ligne vide j'aurais réécrit la variable avec son actuel contenu.
(Oui je ne pense pas que ça soit possible d'écrire une ligne ignorée).

[boubouk50]

J'en reviens à notre première discussion : utiliser un format .json (ou .xml).
L'avantage du .json c'est qu'il est formaté avec le nom de la variable et sa valeur. Pour avoir une valeur, il te suffit d'aller chercher le nom de la variable, donc pas besoin de trouver la ligne, pas besoin de regex pour séparer le nom de variable et sa valeur, possibilité de tout fourrer dans un seul .json, etc.
Là, tu essaies de recréer le comportement de ce format. Réellement.
Maintenant, comme tu utilises le visual scripting, je ne sais pas dans quelle mesure cela peut être adapté, mais ça semble possible.
Aussi, peut-être utiliser des struct ou des classes pour les données :
Class heure -> Hour, minute, second, etc (utiliser DateTime déjà existante ??)
Class camTransform -> Position, Rotation, Scale, etc. (Utiliser Vector3 ??)

Tu parais réinventer plein de trucs déjà en place et ça a l'air galère.
Si tu pouvais créer une classe de données qui peut se linker directement sur un node, ce serait plus simple, ça t'éviterait de linker chaque variable à la main.

[Winuty]

Bonjour, et merci pour tes conseils boubouk50.

Je découvre au fur et à mesure.
Ce n'est malheureusement pas mon métier et je n'ai qu'une formation de base du C# pour le moment.
J'ai appris à me servir tout seul du VisualScrip via la documentation officielle.

Je vais étudier de plus près le format .json.
Je n'ai pas encore pris le temps de voir comment il fonctionnait, mais il semblerait que ça soit la solution idéale.

Il n'y a quasi aucun tuto sur le net pour les nodes personnalisées en VS, uniquement la documentation officielle.
J'ai dû faire plusieurs tests avant de comprendre comment la personnalisation de node fonctionne.

Pour le DateTime c'est l'horloge locale ou Utc non ?
Mes variables de temps ne sont pas synchronisées à l'heure réelle.
C'est un écoulement du temps pour le jeu.
Par défaut qui s'écoule à la même vitesse que le nôtre (ss, mm, hh, jj, mm, aaaa, année bissextile ou pas, décalage horaire).

J'ai reprogrammé une horloge pour pouvoir provoquer comme des voyages dans le temps dans mon jeu. (ralentir, accélérer, faire des sauts à une date précise).
Chaque GameObjects ou Préfabs de mon jeu est synchroniser sur des variables de temps.
Quand il est instancié, s'il a été modifié, déplacer etc ces variables de temps son mise à jour.
Par exemple si dans mon jeu je provoque un saut vers le passé, il va me recharger la scène en chargeant uniquement les prefabs qui étaient déjà sur place à cette époque. Idem pour le futur pas avant que l'événement se soit produit.

Le joueur peut modifier l'avenir de sa ligne temporelle, rattraper ses erreurs ou voir le résultat d'événements sur le long terme.

Bon pour le moment il me charge les objets de la scène uniquement lors du saut.
Je me demande si j'aurais des ralentissements en actualisait en continue chaque objet (pour par exemple observer l'historique de leur déplacement, revoir un évènement).

Pour le transform de la camera, c'est pour sauvegarder l'emplacement du joueur en quittant ou en continu.
Pour le moment oui j'ai 6 variables (PX, PY, PZ, RX, RY et RZ).
Je peux sauvegarder le tout en une seule variable avec le Vector3 ?

_____________________________________

Edit: Je viens de faire un test, j'ai mis 500 nodes à la suite qui chacune écrivent un tableau de 20 variables de 20 caractères.
Un tableau par un fichier texte générer.
J'ai placé un Get Time au début et un à la fin pour afficher dans la console le temps chrono que prend le VS à lire/écrire tout ça.

Sur PC j'ai mis 0sec.
Sur Android j'ai mis 0sec.

Pourtant le Get Time affiche bien le temps en float, se qui veut dire qu'il n'a même pas mis 0,000001 sec à faire tout ça.

Quand vous dites que le C# c'est plus rapide que le VS ? C'est dans quel sens ?

[boubouk50]

Ton calcul de temps d'exécution est faux. Probablement que tout se fait à la suite de façon synchrone, donc il considère que c'est la même instruction qui se joue, donc le temps de départ = temps d'arrivée.
Il faudrait faire un thread séparé qui calcule le temps indépendamment de l'exécution.

Datetime est un format, tu n'es pas obligé d'utiliser le temps UTC. Tu peux toi-même définir ton horaire. Il est déjà formaté YYYY:MM:DD:hh:mm:ss:msmsms, comme tu l'as fait. Je te proposais de l'utiliser pour t'éviter de recréer quelque chose qui existe déjà.

Un Vector3 contient 3 floats, donc tu auras un Vector3 pour la rotation et un pour la translation.

Quand vous dites que le C# c'est plus rapide que le VS ? C'est dans quel sens ?

Si j'ai dit ça, c'est pour la programmation, pas pour l'exécution. Coder est plus efficace et plus libre que le VS, mais derrière, c'est bien du code C# qui est exécuté donc le temps est le même.