Définir une variable avec une constante clavier est simple avec PureBasic !
Code : Tout sélectionner
leftKey = #PB_Key_A ou leftKey = 30
Code : Tout sélectionner
this.leftKey = this.game.input.keyboard.addKey( Kiwi.Input.Keycodes.A );
Code : Tout sélectionner
leftKey = #PB_Key_A ou leftKey = 30
Code : Tout sélectionner
this.leftKey = this.game.input.keyboard.addKey( Kiwi.Input.Keycodes.A );
Code : Tout sélectionner
;{ MODULE Classe
CompilerIf Defined(Classe, #PB_Module) = #False
DeclareModule Classe
Structure InfoClasse
*tableVirtuelle
NomClasse.s
*ClasseParent.InfoClasse
Compteur_Fonction.i
Instance_Objet.i
EndStructure
Global InfoClasse.InfoClasse
; Fonction
Interface Fonction
Liberer()
ObtenirInfoClasse.i()
EndInterface
; Structure gestion données
Structure Struct_Donnees
*tableVirtuelle
*Classe.InfoClasse
EndStructure
; Déclaration créateur ((une macro pour convenance)
Macro Init(_obj_)
_obj_ = AllocateMemory(SizeOf(Struct_Donnees))
InitializeStructure(_obj_, Struct_Donnees)
_obj_\tableVirtuelle = InfoClasse\tableVirtuelle
_obj_\Classe = @InfoClasse
InfoClasse\Instance_Objet + 1
EndMacro
Macro Detruire(_obj_)
FreeMemory(_obj_)
InfoClasse\Instance_Objet - 1
EndMacro
; Macro pour manipulation tableVirtuelle
Macro Fonction_Heritee_de_la_Classe(_Classe_)
InfoClasse\tableVirtuelle = AllocateMemory(SizeOf(Fonction))
InfoClasse\NomClasse = #PB_Compiler_Module
InfoClasse\ClasseParent = _Classe_#@InfoClasse
; héritage
CopyMemory(_Classe_#InfoClasse\tableVirtuelle, InfoClasse\tableVirtuelle, SizeOf(_Classe_#Fonction))
InfoClasse\Compteur_Fonction = SizeOf(_Classe_#Fonction) / SizeOf(Integer)
EndMacro
Macro Fonction_Surcharge(_Fonction_)
PokeI(InfoClasse\tableVirtuelle + OffsetOf(Fonction\_Fonction_), @_Fonction_)
EndMacro
Macro Ajouter_Fonction(_Fonction_)
PokeI(InfoClasse\tableVirtuelle + InfoClasse\Compteur_Fonction * SizeOf(Integer), @_Fonction_)
InfoClasse\Compteur_Fonction + 1
EndMacro
EndDeclareModule
Module Classe
InfoClasse\tableVirtuelle = AllocateMemory(SizeOf(Fonction))
InfoClasse\NomClasse = #PB_Compiler_Module
; Commodité
Procedure.i Obtenir_Classe_Info(*obj.Struct_Donnees)
ProcedureReturn *obj\Classe
EndProcedure
; Destructeur
Procedure Liberer(*obj.Struct_Donnees)
ClearStructure(*obj, Struct_Donnees)
Detruire(*obj)
EndProcedure
; Fonction Ajouter dans la tableVirtuelle
Ajouter_Fonction(Liberer())
Ajouter_Fonction(Obtenir_Classe_Info())
EndModule
CompilerEndIf
;}
;{ MODULE Nom_Classe_Ici : parent = Nom_Classe_Parent_Ici (Modele)
CompilerIf 0 ; à supprimer
DeclareModule Nom_Classe_Ici
Global InfoClasse.Classe::InfoClasse
; Fonction
Interface Fonction Extends Nom_Classe_Parent_Ici::Fonction
; TODO : votreNouvelle_Fonction.i(param1)
EndInterface
; Structure gestion données
Structure Struct_Donnees Extends Nom_Classe_Parent_Ici::Struct_Donnees
; TODO : champ1.i
EndStructure
; Héritage de fonctions éxistantes
Classe::Fonction_Heritee_de_la_Classe(Nom_Classe_Parent_Ici::)
; Déclaration créateur
Declare.i Creer()
EndDeclareModule
Module Nom_Classe_Ici
; Constructor
Procedure.i Creer()
Classe::Init(*obj.Struct_Donnees)
; TODO : *obj\champ1 = ...
ProcedureReturn *obj
EndProcedure
; Méthodes
; TODO : Procedure.i Votre_Nouvelle_Fonction(*obj.Struct_Donnees, param1, ...)
; Destructeur
Procedure Liberer(*obj.Struct_Donnees)
; TODO : ClearStructure(*obj, Struct_Donnees)
Classe::Detruire(*obj)
EndProcedure
; Destructeur surcharge
Classe::Fonction_Surcharge(Liberer())
; Fonction Ajouter dans la tableVirtuelle
; TODO : Classe::Ajouter_Fonction(Votre_Nouvelle_Fonction())
EndModule
CompilerEndIf ; à supprimer
Code : Tout sélectionner
; EXEMPLE :
IncludeFile "MODULE_Classe.pb"
;{ MODULE Rectangle : parent = Classe
DeclareModule Rectangle
Global InfoClasse.Classe::InfoClasse
; Fonction
Interface Fonction Extends Classe::Fonction
Longueur.d()
Largeur.d()
Diagonale.d()
EndInterface
; Structure gestion des données
Structure Struct_Donnees Extends Classe::Struct_Donnees
longueur.i
largeur.i
diagonale.i
EndStructure
; Héritage de fonctions éxistantes
Classe::Fonction_Heritee_de_la_Classe(Classe::)
; Déclaration créateur
Declare.i Creer()
EndDeclareModule
Module Rectangle
; Constructeur
Procedure.i Creer()
Classe::Init(*obj.Struct_Donnees)
*obj\longueur = 100
*obj\largeur = 50
*obj\Diagonale = Sqr((*obj\longueur * *obj\longueur) + (*obj\largeur * *obj\largeur))
ProcedureReturn *obj
EndProcedure
; Méthodes
Procedure Longueur(*v.Struct_Donnees)
Debug "Longueur : " + *v\longueur
EndProcedure
Procedure Largeur(*v.Struct_Donnees)
Debug "Largeur : " + *v\largeur
EndProcedure
Procedure.i Diagonale(*v.Struct_Donnees)
Debug "Diagonale = " + *v\Diagonale
EndProcedure
; Destructeur
Procedure Liberer(*obj.Struct_Donnees)
Debug "Destructeur pour la Classe : Rectangle"
ClearStructure(*obj, Struct_Donnees)
Classe::Detruire(*obj)
EndProcedure
; Destructeur surcharge
Classe::Fonction_Surcharge(Liberer())
; Fonction Ajouter dans la tableVirtuelle
Classe::Ajouter_Fonction(Longueur())
Classe::Ajouter_Fonction(Largeur())
Classe::Ajouter_Fonction(Diagonale())
EndModule
;MODULE Carre:parent = Rectangle
DeclareModule Carre
Global InfoClasse.Classe::InfoClasse
;Fonction
Interface Fonction Extends Rectangle::Fonction
Cote.d()
EndInterface
; Structure gestion des données
Structure Struct_Donnees Extends Rectangle::Struct_Donnees
Cote.i
EndStructure
; Héritage de fonctions éxistantes
classe::Fonction_Heritee_de_la_Classe(Rectangle::)
; Déclaration créateur
Declare.i Creer()
EndDeclareModule
Module Carre
;Constructeur
Procedure Creer()
Classe::Init(*Obj.Struct_Donnees)
*obj\Cote = 50
*Obj\diagonale = *Obj\Cote * Sqr(2)
ProcedureReturn *Obj
EndProcedure
; Méthodes
Procedure Cote(*v.Struct_Donnees)
Debug "Côté : " + *v\Cote
EndProcedure
; Destructeur
Procedure Liberer(*obj.Struct_Donnees)
Debug "Destructeur pour la Classe : Cote"
ClearStructure(*obj, Struct_Donnees)
Classe::Detruire(*obj)
EndProcedure
; Destructeur surcharge
Classe::Fonction_Surcharge(Liberer())
; Fonction Ajouter dans la tableVirtuelle
Classe::Ajouter_Fonction(Cote())
EndModule
;{ MODULE Rectangle : parent = Classe
DeclareModule TriangleRectangle
Global InfoClasse.Classe::InfoClasse
; Fonction
Interface Fonction Extends Rectangle::Fonction
CoteA.d()
CoteB.d()
Hypothenuse.d()
EndInterface
; Structure gestion des données
Structure Struct_Donnees Extends Rectangle::Struct_Donnees
CoteA.i
CoteB.i
Hypothenuse.i
EndStructure
; Héritage de fonctions éxistantes
Classe::Fonction_Heritee_de_la_Classe(Rectangle::)
; Déclaration créateur
Declare.i Creer()
EndDeclareModule
Module TriangleRectangle
; Constructeur
Procedure.i Creer()
Classe::Init(*obj.Struct_Donnees)
*obj\CoteA = 120
*obj\CoteB = 60
*obj\Hypothenuse = Sqr((*obj\CoteA * *obj\CoteA) + (*obj\CoteB * *obj\CoteB))
ProcedureReturn *obj
EndProcedure
; Méthodes
Procedure CoteA(*v.Struct_Donnees)
Debug "Côté A : " + *v\CoteA
EndProcedure
Procedure CoteB(*v.Struct_Donnees)
Debug "Côté B : " + *v\CoteB
EndProcedure
Procedure.i Hypothenuse(*v.Struct_Donnees)
Debug "Hypothénuse = " + *v\Hypothenuse
EndProcedure
; Destructeur
Procedure Liberer(*obj.Struct_Donnees)
Debug "Destructeur pour la Classe : TriangleRectangle"
ClearStructure(*obj, Struct_Donnees)
Classe::Detruire(*obj)
EndProcedure
; Destructeur surcharge
Classe::Fonction_Surcharge(Liberer())
; Fonction Ajouter dans la tableVirtuelle
Classe::Ajouter_Fonction(CoteA())
Classe::Ajouter_Fonction(CoteB())
Classe::Ajouter_Fonction(Hypothenuse())
EndModule
;}
Debug "Classe Rectangle"
Debug ""
*Rectangle.Rectangle::Fonction = Rectangle::Creer()
*Rectangle\Longueur()
*Rectangle\Largeur()
*Rectangle\Diagonale()
Debug ""
Debug "Classe Carre"
Debug ""
*Carre.Carre::Fonction = Carre::Creer()
*Carre\Cote()
*Carre\Diagonale()
Debug ""
Debug "Classe TriangleRectangle"
Debug ""
*TriangleRectangle.TriangleRectangle::Fonction = TriangleRectangle::Creer()
*TriangleRectangle\CoteA()
*TriangleRectangle\CoteB()
*TriangleRectangle\Hypothenuse()
Debug ""
Debug "info générale : "
Debug ""
Debug "Classe : " + Rectangle::InfoClasse\NomClasse
Debug "Nb instance : " + Rectangle::InfoClasse\Instance_Objet
Debug "Classe Parent : " + Rectangle::InfoClasse\ClasseParent\NomClasse
Debug ""
Debug "Classe : " + Carre::InfoClasse\NomClasse
Debug "Nb instance : " + Carre::InfoClasse\Instance_Objet
Debug "Classe Parent : " + Carre::InfoClasse\ClasseParent\NomClasse
Debug ""
Debug "Classe : " + TriangleRectangle::InfoClasse\NomClasse
Debug "Nb instance : " + TriangleRectangle::InfoClasse\Instance_Objet
Debug "Classe Parent : " + TriangleRectangle::InfoClasse\ClasseParent\NomClasse
Debug ""
Code : Tout sélectionner
IncludeFile "MODULE_Classe.pb"
;{ MODULE Voiture : parent = Classe
DeclareModule Voiture
Global InfoClasse.Classe::InfoClasse
; Fonction
Interface Fonction Extends Classe::Fonction
Avance(Vitesse.d)
ObtenirPuissance.i()
EndInterface
; Structure gestion des données
Structure Struct_Donnees Extends Classe::Struct_Donnees
Puissance.i
Couleur.i
x.i
EndStructure
; Héritage de fonctions éxistantes
Classe::Fonction_Heritee_de_la_Classe(Classe::)
; Déclaration créateur
Declare.i Creer()
EndDeclareModule
Module Voiture
; Constructeur
Procedure.i Creer()
Classe::Init(*obj.Struct_Donnees)
*obj\x = 50
*obj\Puissance = 1000
ProcedureReturn *obj
EndProcedure
; Méthodes
Procedure Avance(*v.Struct_Donnees, v.d)
*v\x + v
Debug "Avance : " + *v\x
EndProcedure
Procedure.i Obtenir_Puissance(*v.Struct_Donnees)
ProcedureReturn *v\Puissance
EndProcedure
; Destructeur
Procedure Liberer(*obj.Struct_Donnees)
Debug "Destructeur pour la Classe : Voiture"
ClearStructure(*obj, Struct_Donnees)
Classe::Detruire(*obj)
EndProcedure
; Destructeur surcharge
Classe::Fonction_Surcharge(Liberer())
; Fonction Ajouter dans la tableVirtuelle
Classe::Ajouter_Fonction(Avance())
Classe::Ajouter_Fonction(Obtenir_Puissance())
EndModule
;}
;{ MODULE Peugeot : parent = Voiture
DeclareModule Peugeot
Global InfoClasse.Classe::InfoClasse
; Fonction
Interface Fonction Extends Voiture::Fonction
ObtenirNom.s()
EndInterface
; Structure gestion des données
Structure Struct_Donnees Extends Voiture::Struct_Donnees
Nom.s
EndStructure
; Héritage de fonctions éxistantes
Classe::Fonction_Heritee_de_la_Classe(Voiture::)
; Déclaration créateur
Declare.i Creer()
EndDeclareModule
Module Peugeot
; Constructeur
Procedure.i Creer()
Classe::Init(*obj.Struct_Donnees)
*obj\x = 50
*obj\Puissance = 2000
*obj\Nom = "Ma belle peugeot"
ProcedureReturn *obj
EndProcedure
; Méthodes
Procedure.s Obtenir_Nom(*v.Struct_Donnees)
ProcedureReturn *v\Nom
EndProcedure
; Destructeur
Procedure Liberer(*obj.Struct_Donnees)
Debug "Destructeur pour la Classe : Peugeot"
ClearStructure(*obj, Struct_Donnees)
Classe::Detruire(*obj)
EndProcedure
; Destructeur surcharge
Classe::Fonction_Surcharge(Liberer())
; Fonction Ajouter dans la tableVirtuelle
Classe::Ajouter_Fonction(Obtenir_Nom())
EndModule
;}
Debug "Classe voiture"
Debug " "
*Voiture.Voiture::Fonction = Voiture::Creer()
*Voiture\Avance(1)
Debug "*Voiture\ObtenirPuissance() = " + *Voiture\ObtenirPuissance()
Debug " "
Debug "Classe Peugeot"
Debug " "
*ma_voiture.Peugeot::Fonction = Peugeot::Creer()
*ma_voiture\Avance(10)
Debug "*ma_voiture\ObtenirPuissance() = " + *ma_voiture\ObtenirPuissance()
Debug *ma_voiture\ObtenirNom()
Debug ""
Debug "info générale : "
Debug ""
Debug "Classe : " + Voiture::InfoClasse\NomClasse
Debug "Nb instance : " + Voiture::InfoClasse\Instance_Objet
Debug "Classe Parent : " + Voiture::InfoClasse\ClasseParent\NomClasse
Debug ""
Debug "Classe : " + Peugeot::InfoClasse\NomClasse
Debug "Nb instance : " + Peugeot::InfoClasse\Instance_Objet
Debug "Classe Parent : " + Peugeot::InfoClasse\ClasseParent\NomClasse
Debug ""
Debug "info sur '*ma_voiture' : "
Debug ""
*Classe_info.Classe::InfoClasse = *ma_voiture\ObtenirInfoClasse()
Debug "Classe : " + *Classe_info\NomClasse
Debug "Nb instance : " + *Classe_info\Instance_Objet
Debug "Classe Parent : " + *Classe_info\ClasseParent\NomClasse
donc on pourrais "traduire" / "convertir" les appels aux objet C en PureBasic ?Flype a écrit : concernant la question pointeur/id il est vrai que çà fait souvent débat.
à mon avis,
les pointeurs meme s'ils permettent un accès direct, donc plus rapide
ne sont pas pour autant dans l'esprit basic.
les identifiants, eux, le sont !
la grande majorité des fonctions purebasic sont avec des Id dont le fameux #PB_Any. c'est bien pratique, et çà émule entre guillemets des objets.
le SDK purebasic propose justement un fichier ObjectManager.lib spécialement dédié à la programmation des Id pour être le proche de l'esprit purebasic.
à noter que la meme API est dispo aussi en C si tu as besoin.Code : Tout sélectionner
Import #PB_Compiler_Home + "Compilers/ObjectManager.lib" PB_Object_GetOrAllocateID (Objects, Object.l) PB_Object_GetObject (Objects, Object.l) PB_Object_IsObject (Objects, Object.l) PB_Object_EnumerateAll (Objects, ObjectEnumerateAllCallback, *VoidData) PB_Object_EnumerateStart (Objects) PB_Object_EnumerateNext (Objects, *object.Long) PB_Object_EnumerateAbort (Objects) PB_Object_FreeID (Objects, Object.l) PB_Object_Init (StructureSize.l, IncrementStep.l, ObjectFreeFunction) PB_Object_GetThreadMemory (MemoryID.l) PB_Object_InitThreadMemory(Size.l, InitFunction, EndFunction) EndImport
En fait ce qui me rend fou, c'est que on peut bien souvent faire une analogie entre ce que fait la POO et le procedural.Spock a écrit :en POO ils utilisent des bout de codes tout fait sans se preoccuper de comment le resultat est obtenu