Liste chainée avec des éléments différents

[Guimauve]

Bonjour à tous,

Voiçi une exemple que j'ai posté sur le forum anglais mais que j'ai oublié de montrer ici.

L'exemple en question montre comment on peut avoir une liste chainée qui possède des éléments qui sont différents. Bien sur c'est adaptable avec les tableaux dynamiques et statiques imbriqués dans des structures. Vraiment désolé mais les messages que l'on voit dans le déboggeur sont en anglais.

C'est un peu fous comme manière de faire mais ça a des avantages dans certains cas particuliers.

A+
Guimauve

Code : Tout sélectionner

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; Project name : PB LinkedList holding different elements
; File : Adapter.pb
; File Version : 0.0.0
; Programmation : EXPERIMENTAL CODE
; Programmed by : Guimauve
; Date : 19-11-2006
; Last Update : 19-11-2006
; Coded for PureBasic V4.00
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; AUTOMATICALLY GENERATED CODE, DO NOT MODIFY
; UNLESS YOU REALLY, REALLY, REALLY MEAN IT !!
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Enumeration 1
   
   #DataType_LocalTime
   #DataType_POINT
   #DataType_POINTFX
   
EndEnumeration

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Structure declaration <<<<<

Structure Adapter
   
   DataType.b
   ElementPtr.l
   
EndStructure

; <<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The accessors <<<<<

Macro AdapterDataType(AdapterA)
   
   AdapterA\DataType
   
EndMacro

Macro AdapterElementPtr(AdapterA)
   
   AdapterA\ElementPtr
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The Complete Reset operator <<<<<

Macro ResetAdapter(AdapterA)
   
   RtlZeroMemory_(AdapterA, SizeOf(Adapter))
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Code generated in : 00.001 seconds <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Structure declaration <<<<<

Structure LocalTime
   
   wYear.w
   wMonth.w
   wDayOfWeek.w
   wDay.w
   wHour.w
   wMinute.w
   wSecond.w
   wMilliseconds.w
   
EndStructure

; <<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The mutators <<<<<

Macro SetLocalTime(LocalTimeA)
   
   GetLocalTime_(LocalTimeA)
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The accessors <<<<<

Macro LocalTimewYear(LocalTimeA)
   
   LocalTimeA\wYear
   
EndMacro

Macro LocalTimewMonth(LocalTimeA)
   
   LocalTimeA\wMonth
   
EndMacro

Macro LocalTimewDayOfWeek(LocalTimeA)
   
   LocalTimeA\wDayOfWeek
   
EndMacro

Macro LocalTimewDay(LocalTimeA)
   
   LocalTimeA\wDay
   
EndMacro

Macro LocalTimewHour(LocalTimeA)
   
   LocalTimeA\wHour
   
EndMacro

Macro LocalTimewMinute(LocalTimeA)
   
   LocalTimeA\wMinute
   
EndMacro

Macro LocalTimewSecond(LocalTimeA)
   
   LocalTimeA\wSecond
   
EndMacro

Macro LocalTimewMilliseconds(LocalTimeA)
   
   LocalTimeA\wMilliseconds
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The Complete Reset operator <<<<<

Macro ResetLocalTime(LocalTimeA)
   
   LocalTimewYear(LocalTimeA) = 0
   LocalTimewMonth(LocalTimeA) = 0
   LocalTimewDayOfWeek(LocalTimeA) = 0
   LocalTimewDay(LocalTimeA) = 0
   LocalTimewHour(LocalTimeA) = 0
   LocalTimewMinute(LocalTimeA) = 0
   LocalTimewSecond(LocalTimeA) = 0
   LocalTimewMilliseconds(LocalTimeA) = 0
   
   ; RtlZeroMemory_(LocalTimeA, SizeOf(LocalTime))
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Debugging macro <<<<<

Procedure DebugLocalTime(*LocalTimeA.LocalTime)
   
   Debug "-----------------------------------------------------"
   Debug "Structure : LocalTime"
   Debug LocalTimewYear(*LocalTimeA)
   Debug LocalTimewMonth(*LocalTimeA)
   Debug LocalTimewDayOfWeek(*LocalTimeA)
   Debug LocalTimewDay(*LocalTimeA)
   Debug LocalTimewHour(*LocalTimeA)
   Debug LocalTimewMinute(*LocalTimeA)
   Debug LocalTimewSecond(*LocalTimeA)
   Debug LocalTimewMilliseconds(*LocalTimeA)
   Debug "-----------------------------------------------------"
   
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Code generated in : 00.016 seconds <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

; <<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The Constructor <<<<<

Procedure CreateNewLocalTime()
   
   *NewLocalTime.LocalTime = AllocateMemory(SizeOf(LocalTime))
   
   If *NewLocalTime = #Null
      MessageRequester("Fatal Error", "CreateNewLocalTime() - Impossible to Allocate Memory !")
   EndIf
   
   ProcedureReturn *NewLocalTime
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The Destructor <<<<<

Procedure.b DestroyLocalTime(*LocalTime.LocalTime)
   
   If *LocalTime <> #Null
      
      ResetLocalTime(*LocalTime)
      FreeMemory(*LocalTime)
      DestroySuccess.b = #True
      
   EndIf
   
   ProcedureReturn DestroySuccess
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Code generated in : 00.032 seconds <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Procedure AttachLocalTime(*AdapterA.Adapter, *Element.LocalTime)
   
   *New.LocalTime = CreateNewLocalTime()
   If *New <> 0
      AdapterDataType(*AdapterA) = #DataType_LocalTime
      CopyMemory(*Element, *New, SizeOf(LocalTime))
      AdapterElementPtr(*AdapterA) = *New
   EndIf
   
EndProcedure

Procedure ExtractLocaltime(*AdapterA.Adapter)
   
   ProcedureReturn AdapterElementPtr(*AdapterA)
   
EndProcedure

Procedure DirectAttachLocalTime(*AdapterA.Adapter)
   
   *New.LocalTime = CreateNewLocalTime()
   If *New <> 0
      AdapterDataType(*AdapterA) = #DataType_LocalTime
      SetLocalTime(*New)
      AdapterElementPtr(*AdapterA) = *New
   EndIf
   
EndProcedure

Procedure DetachLocalTime(*AdapterA.Adapter)
   
   DestroyLocalTime(AdapterElementPtr(*AdapterA))
   ResetAdapter(*AdapterA)
   
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< End of Adapter-LocalTime Interface <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

; <<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The mutators <<<<<

Macro SetPOINTx(PointA, P_x)
   
   PointA\x = P_x
   
EndMacro

Macro SetPOINTy(PointA, P_y)
   
   PointA\y = P_y
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The observators <<<<<

Macro GetPOINTx(PointA)
   
   PointA\x
   
EndMacro

Macro GetPOINTy(PointA)
   
   PointA\y
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The Complete Reset operator <<<<<

Macro ResetPOINT(PointA)
   
   SetPOINTx(PointA, 0)
   SetPOINTy(PointA, 0)
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Debugging macro <<<<<

Procedure DebugPOINT(*PointA.POINT)
   
   Debug "-----------------------------------------------------"
   Debug "Structure : POINT"
   Debug "(x,y) (" + Str(GetPOINTx(*PointA)) + ", " + Str(GetPOINTy(*PointA)) + ")"
   Debug "-----------------------------------------------------"
   
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The Constructor <<<<<

Procedure CreateNewPoint()
   
   *New.POINT = AllocateMemory(SizeOf(POINT))
   
   If *New = #Null
      MessageRequester("Fatal Error", "CreateNewPoint() - Impossible to Allocate Memory !")
   EndIf
   
   ProcedureReturn *New
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The Destructor <<<<<

Procedure.b DestroyPoint(*PointA.POINT)
   
   If *LocalTime <> #Null
      
      ResetPOINT(*PointA)
      FreeMemory(*PointA)
      DestroySuccess.b = #True
      
   EndIf
   
   ProcedureReturn DestroySuccess
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Code generated in : 00.016 seconds <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Procedure AttachPoint(*AdapterA.Adapter, *Element.POINT)
   
   *New.POINT = CreateNewPoint()
   If *New <> 0
      AdapterDataType(*AdapterA) = #DataType_POINT
      CopyMemory(*Element, *New, SizeOf(POINT))
      AdapterElementPtr(*AdapterA) = *New
   EndIf
   
EndProcedure

Procedure ExtractPoint(*AdapterA.Adapter)
   
   ProcedureReturn AdapterElementPtr(*AdapterA)
   
EndProcedure

Procedure DirectAttachPoint(*AdapterA.Adapter, P_x.l, P_y.l)
   
   *New.POINT = CreateNewPoint()
   If *New <> 0
      AdapterDataType(*AdapterA) = #DataType_POINT
      SetPOINTx(*New, P_x)
      SetPOINTy(*New, P_y)
      AdapterElementPtr(*AdapterA) = *New
   EndIf
   
EndProcedure

Procedure DetachPoint(*AdapterA.Adapter)
   
   DestroyPoint(AdapterElementPtr(*AdapterA))
   ResetAdapter(*AdapterA)
   
EndProcedure


; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< End of Adapter-POINT Interface <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

; <<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The mutators <<<<<

Macro SetPOINTFXx(PointA, P_x)
   
   PointA\x = P_x
   
EndMacro

Macro SetPOINTFXy(PointA, P_y)
   
   PointA\y = P_y
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The observators <<<<<

Macro GetPOINTFXx(PointA)
   
   PointA\x
   
EndMacro

Macro GetPOINTFXy(PointA)
   
   PointA\y
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The Complete Reset operator <<<<<

Macro ResetPOINTFX(PointA)
   
   SetPOINTFXx(PointA, 0)
   SetPOINTFXy(PointA, 0)
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Debugging macro <<<<<

Procedure DebugPOINTFX(*PointA.POINTFX)
   
   Debug "-----------------------------------------------------"
   Debug "Structure : POINTFX"
   Debug "(x,y) (" + Str(GetPOINTFXx(*PointA)) + ", " + Str(GetPOINTFXy(*PointA)) + ")"
   Debug "-----------------------------------------------------"
   
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The Constructor <<<<<

Procedure CreateNewPointFX()
   
   *New.POINT = AllocateMemory(SizeOf(POINTFX))
   
   If *New = #Null
      MessageRequester("Fatal Error", "CreateNewPoint() - Impossible to Allocate Memory !")
   EndIf
   
   ProcedureReturn *New
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The Destructor <<<<<

Procedure.b DestroyPointFX(*PointA.POINTFX)
   
   If *LocalTime <> #Null
      
      ResetPOINTFX(*PointA)
      FreeMemory(*PointA)
      DestroySuccess.b = #True
      
   EndIf
   
   ProcedureReturn DestroySuccess
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Code generated in : 00.016 seconds <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Procedure AttachpointFX(*AdapterA.Adapter, *Element.POINTFX)
   
   *New.POINTFX = CreateNewPointFX()
   If *New <> 0
      AdapterDataType(*AdapterA) = #DataType_POINTFX
      CopyMemory(*Element, *New, SizeOf(POINTFX))
      AdapterElementPtr(*AdapterA) = *New
   EndIf
   
EndProcedure

Procedure ExtractpointFX(*AdapterA.Adapter)
   
   ProcedureReturn AdapterElementPtr(*AdapterA)
   
EndProcedure

Procedure DirectAttachpointFX(*AdapterA.Adapter, P_x.l, P_y.l)
   
   *New.POINTFX = CreateNewPointFX()
   If *New <> 0
      AdapterDataType(*AdapterA) = #DataType_POINTFX
      SetPOINTFXx(*New, P_x)
      SetPOINTFXy(*New, P_y)
      AdapterElementPtr(*AdapterA) = *New
   EndIf
   
EndProcedure

Procedure DetachpointFX(*AdapterA.Adapter)
   
   DestroyPointFX(AdapterElementPtr(*AdapterA))
   ResetAdapter(*AdapterA)
   
EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< End of Adapter-POINTFX Interface <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

;/ <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
;/ <<<<< !!! WARNING - YOU ARE NOW IN A TESTING ZONE - WARNING !!! <<<<<
;/ <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Macro RandomMinMax(min, max)
   
   (max - Random(max - min))
   
EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< The new linked list of Adapter <<<<<

NewList MyList.Adapter()

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< OK it's time to add element to the list <<<<<

Debug "To attach elements to the list need 6-7 seconds, be patient ..."
Debug "It's for Localtime, we want to see some differences."
Debug "-----------------------------------------------------"

While CountList(MyList()) < 12
   
   Delay(500)
   
   AddElement(MyList())
   
   DataType = RandomMinMax(#DataType_LocalTime, #DataType_POINTFX)
   
   Select DataType
      
      Case #DataType_LocalTime
         
         If AttachDirectLocalTime = 0
            AttachDirectLocalTime = 1
            SetLocalTime(LooseLocalTime.LocalTime)
            AttachLocalTime(MyList(), LooseLocalTime)
         Else
            
            DirectAttachLocalTime(MyList())
         EndIf
         
      Case #DataType_POINT
         
         If AttachDirectPOINT = 0
            AttachDirectPOINT = 1
            SetPOINTx(LoosePOINT.POINT, 50)
            SetPOINTy(LoosePOINT.POINT, 75)
            AttachPoint(MyList(), LoosePOINT)
         Else
            DirectAttachPoint(MyList(), Coord_X, Coord_Y)
            Coord_X + 25
            Coord_Y + 33
         EndIf
         
      Case #DataType_POINTFX
         
         If AttachDirectPOINTfx = 0
            AttachDirectPOINTfx = 1
            SetPOINTFXx(LoosePOINTfx.POINTFX, 50)
            SetPOINTFXy(LoosePOINTfx.POINTFX, 75)
            AttachpointFX(MyList(), LoosePOINTfx)
         Else
            DirectAttachpointFX(MyList(), Coord_X_FX, Coord_Y_FX)
            Coord_X_FX + 44
            Coord_Y_FX + 55
         EndIf
         
   EndSelect
   
Wend

Debug "Ok we have some element to the list."
Debug " It's time to see the information."
Debug "-----------------------------------------------------"

ForEach MyList()
   
   Select AdapterDataType(MyList())
      
      Case #DataType_LocalTime
         DebugLocalTime(AdapterElementPtr(MyList()))
         
      Case #DataType_POINT
         DebugPOINT(AdapterElementPtr(MyList()))
         
      Case #DataType_POINTFX
         DebugPOINTFX(AdapterElementPtr(MyList()))
         
   EndSelect
   
Next

Debug "Ok we Detach everyting ..."
Debug "-----------------------------------------------------"

ForEach MyList()
   
   Select AdapterDataType(MyList())
      
      Case #DataType_LocalTime
         DetachLocalTime(MyList())
         
      Case #DataType_POINT
         DetachPoint(MyList())
         
      Case #DataType_POINTFX
         DetachpointFX(MyList())
         
   EndSelect
   
Next

Debug "Re debug the list for information"
Debug "-----------------------------------------------------"

ForEach MyList()
   
   Select AdapterDataType(MyList())
      
      Case #DataType_LocalTime
         DebugLocalTime(AdapterElementPtr(MyList()))
         
      Case #DataType_POINT
         DebugPOINT(AdapterElementPtr(MyList()))
         
      Case #DataType_POINTFX
         DebugPOINTFX(AdapterElementPtr(MyList()))
         
      Default
         Debug "MyList() Index " + Str(ListIndex(MyList())) + " is empty !"
         
   EndSelect
   
Next

Debug "This is the END"
Debug "-----------------------------------------------------"

; <<<<<<<<<<<<<<<<<<<<<<<
; <<<<< END OF FILE <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<

[nico]

L'exemple en question montre comment on peut avoir une liste chainée qui possède des éléments qui sont différents

Qu'est-ce que ton code permet de faire qu'on ne peut pas faire autrement, le code est complique pour moi ?

[Guimauve]

L'exemple en question montre comment on peut avoir une liste chainée qui possède des éléments qui sont différents

Qu'est-ce que ton code permet de faire qu'on ne peut pas faire autrement, le code est complique pour moi ?

Cas typique, on veut faire une map pour un jeu 2D. La map est faite comment ? Avec des tiles. Le problème c'est que les tiles ne sont pas toutes pareilles. Certaines sont là que pour l'aspect visuel, alors que certaines ont une animation qui doit tourner en boucle infinie, certaines sont des murs, certaines ont une animation qui est déclanché par un évènement, certaines autres vont lancer un script, etc.

Ce que ça permet de faire, une centralisation de données organisées. On parcours 1 seul et unique tableau et on choisit le traitement approprié en fonction de la Tile qui est attaché.

2e cas typique, une liste de gadget. Donc on a les TextGadget ButtonGadget, StringGadget, ...

Le concept informatique en question : LE POLYMORPHISME

Dans le cas d'une map de tile ça me semble bien plus simple à faire avec 1 tableau polymorphe que de faire autant de tableau qu'il y a de type de tile possible. Parce que la ça devient infernal à gérer et pire encore quand on veut modifier le code.

Mais je suis d'accord avec toi pour dire que c'est tordu comme concept. Et il faut être un peu fous pour solutionner les problèmes de cette façon mais le système me semble bien plus facile à gérer quand on y réfléchit bien.

A+
Guimauve

[Thyphoon]

Je comprends bien l'idée théorique. mais j'ai beau lire le code dans tout les sens je ne comprends pas tres bien le fonctionnement

[Backup]

en clair tu réinvente la pile !!

une pile c'est un emplacement memoire, dans lequel tu empile des données (de type different)..

tout comme la liste chainée !!

ps : c'est la dessus qu'est basé mon PureGolo

[Thyphoon]

Je suis vraiment curieux de voir comment le code de guimauve pourrait remplacer mon tableau pour ma map ... C'est peut être l'exemple avec les localtime que je comprends pas

[Backup]

je vais prendre un exemple archi-connu que nous utilisions pour les Demos sur Atari, pour t'expliquer ce qu'il en est

il va mettre des donné dans la liste chainée, certaines de ces données
vont servir a faire un truc, et d'autres a faire d'autres trucs, pour ça il les "marques" en ajoutant un signe distinctif ...


pour les Demos on faisaient pareil pour les ScrollTexts !!

tu avait le text dans des Datas
genre :

data 1,l,e, ,p,u,r,e, ,b,a,s,i,c, ,2,c,',e,s,t, ,d,e, ,l,a, ,b,a,l,l,e,*

et puis en lisant le data les chiffres (cela aurai pu etre un autre signe distinctif) , indiques, l'effet voulu

par exemple le "1" nous dira de sauter dans la routine de Scroll Vertical
et l'on prendra la phrase qui suit :"le pure basic "

le "2" nous indiquera qu'il faut sauter dans la routine de scroll horizontal
et l'on prendra la phrase qui suit :"c'est de la balle"

le "*" nous indiquera qu'il n'y a plus de data , pour un Restore eventuel

voila en gros son principe, mais utilisé avec une liste chainée au lieu du Data !

Bref il fait une Pile , qu'il lira ensuite en "dépilant" (en fait en relisant le contenu de la liste chainée), et en utilisant ces "Marquages" (1,2,*,pour moi), il fera executer des actions differentes

j'ai une question !

pourquoi dans tes codes on retrouve toujours ce genre de trucs ?

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Code generated in : 00.016 seconds <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

[Thyphoon]

Merci Dobro je commence a comprendre .... enfin je crois...
Donc dans le cas d'une Map ou chaque case peut avoir un nombre d'information indefinie on aurait juste un tableau du style Map(X,Y) qui donne un pointeur vers une liste de donnée dans le quel on aura les infos dont on a besoin!

Mais le problème est que des que tu as besoin d'une information a certaine coordonée il faut alors lire tout les autres infos pour en ressortir l'info dont tu as besoin.... Donc on fait des economies de places émoire, mais c'est quand même plus lent (plus de ressource) pour ressortir une information ?
Et oui Guimauve je me pose la même question que Dobro pour ces lignes là

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Code generated in : 00.016 seconds <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

[Backup]

Mais le problème est que des que tu as besoin d'une information a certaine coordonée il faut alors lire tout les autres infos pour en ressortir l'info dont tu as besoin....

exactement !

c'est d'ailleurs pour ça que dans mon PureGolo, plus il y a de variables, plus le code est long a l'exécution

car a chaque variable, je relit la "pile des variables" pour savoir si elle existe
et connaître son contenue (... suite de notre discutions privé )
ce qui est effectivement long si on a plein de valeur a relire pour vérifications ....

a moins de faire du "précalculé" , il n'y a pas 36 methodes en fait

[Guimauve]

Pourquoi il y a le commentaire :

Code : Tout sélectionner

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Code generated in : 00.016 seconds <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

C'est très simple, je suis classé parmis les gens paresseux voir même très paresseux. Le code est générer par un programme.

Exemple on a une structure quelconque et l'on désir écrire et lire la structure en question dans un fichier binaire. Il faut à chaque fois écrire le code manuellement à chaque fois. C'est long, fastidieu et pénible sans oublier que l'écriture du code est très mécanique, ça réponds à un automatisme.

Pour un jeu 3D, j'ai besoin d'un système de Vecteur pour les calculs de déplacement. Dans le programme en question je donne :

- Le nom de la Structure : Vector3
- Les champs :
- i.f
- j.f
- k.f

Ensuite je change d'onglet sur lequel il y a des CheckBox et je dis au programme les commandes de base que j'ai besoin et le résultat est le suivant :

Code : Tout sélectionner

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; CODE GÉNÉRÉ AUTOMATIQUEMENT, NE PAS MODIFIER À
; MOINS D'AVOIR UNE RAISON TRÈS TRÈS VALABLE !!!
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; Code généré par : Dev-Type
; Nom du projet : Le nom du projet ici
; Fichier : Nom du fichier
; Version : 0.0.0
; Programmation : À vérifier
; Programmé par : Guimauve
; Date : 19-03-2007
; Mise à jour : 19-03-2007
; Codé pour PureBasic V4.02
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Déclaration de la Structure <<<<<

Structure Vector3

   i.f
   j.f
   k.f

EndStructure

; <<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Les mutateurs <<<<<

Macro SetVector3i(VecteurA, P_i)

   VecteurA\i = P_i

EndMacro

Macro SetVector3j(VecteurA, P_j)

   VecteurA\j = P_j

EndMacro

Macro SetVector3k(VecteurA, P_k)

   VecteurA\k = P_k

EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Les observateurs <<<<<

Macro GetVector3i(VecteurA)

   VecteurA\i

EndMacro

Macro GetVector3j(VecteurA)

   VecteurA\j

EndMacro

Macro GetVector3k(VecteurA)

   VecteurA\k

EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Update <<<<<

Macro UpdateVector3(VecteurA, P_i, P_j, P_k)

   SetVector3i(VecteurA, P_i)
   SetVector3j(VecteurA, P_j)
   SetVector3k(VecteurA, P_k)

EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Equal : A = B <<<<<

Macro EqualVector3(VecteurA, VecteurB)

   SetVector3i(VecteurA, GetVector3i(VecteurB))
   SetVector3j(VecteurA, GetVector3j(VecteurB))
   SetVector3k(VecteurA, GetVector3k(VecteurB))

   ; CopyMemory(VecteurB, VecteurA, SizeOf(Vector3))

EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Plus : R = A + B <<<<<

Macro PlusVector3(VecteurR, VecteurA, VecteurB)

   SetVector3i(VecteurR, GetVector3i(VecteurA) + GetVector3i(VecteurB))
   SetVector3j(VecteurR, GetVector3j(VecteurA) + GetVector3j(VecteurB))
   SetVector3k(VecteurR, GetVector3k(VecteurA) + GetVector3k(VecteurB))

EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Minus : R = A - B <<<<<

Macro MinusVector3(VecteurR, VecteurA, VecteurB)

   SetVector3i(VecteurR, GetVector3i(VecteurA) - GetVector3i(VecteurB))
   SetVector3j(VecteurR, GetVector3j(VecteurA) - GetVector3j(VecteurB))
   SetVector3k(VecteurR, GetVector3k(VecteurA) - GetVector3k(VecteurB))

EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur Zero <<<<<

Macro ZeroVector3(VecteurA)

   SetVector3i(VecteurA, 0)
   SetVector3j(VecteurA, 0)
   SetVector3k(VecteurA, 0)

   ; RtlZeroMemory_(VecteurA, SizeOf(Vector3))

EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur ProductByScalar : R = A * Scalar <<<<<

Macro ProductByScalarVector3(VecteurR, VecteurA, Scalar)

   SetVector3i(VecteurR, GetVector3i(VecteurA) * Scalar)
   SetVector3j(VecteurR, GetVector3j(VecteurA) * Scalar)
   SetVector3k(VecteurR, GetVector3k(VecteurA) * Scalar)

EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< L'opérateur DivideByScalar : R = A / Scalar <<<<<

Macro DivideByScalarVector3(VecteurR, VecteurA, Scalar)

   SetVector3i(VecteurR, GetVector3i(VecteurA) / Scalar)
   SetVector3j(VecteurR, GetVector3j(VecteurA) / Scalar)
   SetVector3k(VecteurR, GetVector3k(VecteurA) / Scalar)

EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Lecture d'un groupe Préférences <<<<<

Procedure ReadPreferenceVector3(GroupName.s, *VecteurA.Vector3)

   PreferenceGroup(GroupName)

   SetVector3i(*VecteurA, ReadPreferenceFloat("i", GetVector3i(*VecteurA)))
   SetVector3j(*VecteurA, ReadPreferenceFloat("j", GetVector3j(*VecteurA)))
   SetVector3k(*VecteurA, ReadPreferenceFloat("k", GetVector3k(*VecteurA)))

EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Écriture d'un groupe de Préférences <<<<<

Procedure WritePreferenceVector3(GroupName.s, *VecteurA.Vector3)

   PreferenceGroup(GroupName)

   WritePreferenceFloat("i", GetVector3i(*VecteurA))
   WritePreferenceFloat("j", GetVector3j(*VecteurA))
   WritePreferenceFloat("k", GetVector3k(*VecteurA))

EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Lecture fichier Binaire <<<<<

Procedure ReadVector3(FileID.l, *VecteurA.Vector3)

   SetVector3i(*VecteurA, ReadFloat(FileID))
   SetVector3j(*VecteurA, ReadFloat(FileID))
   SetVector3k(*VecteurA, ReadFloat(FileID))

EndProcedure

; Macro ReadVector3(FileID, VecteurA)
   ; ReadData(FileID, VecteurA, SizeOf(Vector3))
; EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Écriture fichier Binaire <<<<<

Procedure WriteVector3(FileID.l, *VecteurA.Vector3)

   WriteFloat(FileID, GetVector3i(*VecteurA))
   WriteFloat(FileID, GetVector3j(*VecteurA))
   WriteFloat(FileID, GetVector3k(*VecteurA))

EndProcedure

; Macro WriteVector3(FileID, VecteurA)
   ; WriteData(FileID, VecteurA, SizeOf(Vector3))
; EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Lecture d'un tableau dynamique dans le fichier en cours <<<<<

Procedure ReadDynamicArrayOfVector3(FileID.l, Array.Vector3(1))

   Array_Max.l = ReadLong(FileID)
   Redim Array.Vector3(Array_Max)

   For Index = 0 to Array_Max
      ReadVector3(FileID, Array(Index))
   Next

EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Écriture d'un tableau dynamique dans le fichier en cours <<<<<

Procedure WriteDynamicArrayOfVector3(FileID.l, Array.Vector3(1))

   Array_Max.l = (PeekL(@Array() - 8) - 1)
   WriteLong(FileID, Array_Max)

   For Index = 0 to Array_Max
      WriteVector3(FileID, Array(Index))
   Next

EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Lecture d'une liste chaînée dans le fichier en cours <<<<<

Procedure ReadLinkedListOfVector3(FileID.l, LList.Vector3())

   LList_Max.l = ReadLong(FileID)

   For Index = 0 to LList_Max - 1
      AddElement(LList())
      ReadVector3(FileID, LList())
   Next

EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Écriture d'une liste chaînée dans le fichier en cours <<<<<

Procedure WriteLinkedListOfVector3(FileID.l, LList.Vector3())

   WriteLong(FileID, CountList(LList()))

   ForEach LList()
      WriteVector3(FileID, LList())
   Next

EndProcedure

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Macro de déboguage <<<<<

Macro DebugVector3(VecteurA)

   Debug GetVector3i(VecteurA)
   Debug GetVector3j(VecteurA)
   Debug GetVector3k(VecteurA)

EndMacro

; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; <<<<< Code généré en : 00.078 secondes <<<<<
; <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Je sauvegarde sur un fichier, IncludeFile dans mon projet. Ensuite c'est du Copier/Coller des instructions que j'ai besoins dans le code principal de mon programme.

Sauf que le programme génère un code qui n'est pas toujours parfait ou le meilleur. Bien souvent, je dois faire des petites modifications, écrire les instructions manquantes, etc. Le plus gros du travail à été fait.

Pour ce qui est d'une Map de Tile, la seule raison pour laquelle je reprend un tableau standard c'est je n'ai pas envie de refaire le système d'indexation d'un tableau. (Qui ferait exatement la même chose)

C'est comme si tu avais une boîte avec 512 par 512 compartiments. Tu as 5 sortes de bouteilles et tu as 232144 boutielles à placer dans cette boîte.

Du point de vue de la boîte, il n'y a aucune différence à ce que les bouteilles soit placées pêle-mêle ou ordonnées dans celle-ci.

Si la boite est traité par un machine par la suite, que va t-elle faire ? Elle va prendre la bouteille en (0,0), l'analyser et en fonction du résultat choisir et faire l'action appropriée pour la bouteille en question. La machine prend la bouteille en (0,1), l'analyse et en fonction du résultat choisir et faire l'action appropriée pour la boutielle en question. La machine prend la bouteille en (0,2), l'analyse et en fonction du résultat choisir et faire l'action appropriée pour la boutielle en question. La ...

Donc à la place d'avoir une boîte, on a une Map (Un tableau 512X512) et à la place des Boutielles on a des tiles. Mais c'est pareil.

A+
Guimauve

[lionel_om]

Ton preogramme gère aussi si dans ta structure tu as des références d'objets ou même simplement des objets ?