PureBasic

Salut

voilà, j'ai un code assez complexe pour notre jeu 3arks, dont l'architecture ressemble à ça :

Structure stjoueur
  x.w
  y.w
EndStructure


Procedure joueurGame(*joueur.stjoueur)
  Debug Str(*joueur\x) +"/"+ Str(*joueur\y)
EndProcedure

Procedure joueurEcran(*joueur.stjoueur)
  *joueur.stjoueur = AllocateMemory(500)
  *joueur\x = 50
  *joueur\y = 50
  Debug "Creation"
  joueurGame(*joueur)
EndProcedure

Procedure Ecran(*joueur.stjoueur)
  joueurEcran(*joueur)
  joueurGame(*joueur)
EndProcedure

Procedure Game(*joueur.stjoueur)
  joueurGame(*joueur)
EndProcedure

Ecran(@joueur)   
Debug "game"
Game(@joueur)

Evidémment, j'ai énormément simplifier et c'est beaucoup plus complexe, mais c'est l'idée globale ^^.

Comment puis-je récupérer les données de *joueur dans game() ou dans ecran() ?
(je ne peux pas refaire de allocatememory() bien sur sur *joueur.stjoueur

)

Merci

.

ben un truc genre : non ?

Code : Tout sélectionner

Procedure Game(*joueur.stjoueur)

  
  
   With *joueur
       
    Debug str(\x)
	Debug str(\y)
  EndWith

EndProcedure

hélas, ça me renvoie encore 0/0 au lieu de 50/50

"joueur" est déclaré ou dans ton code ?

Code : Tout sélectionner

Structure stjoueur
  x.w
  y.w
EndStructure




Procedure joueurGame(*joueur.stjoueur)
  Debug Str(*joueur\x) +"/"+ Str(*joueur\y)
EndProcedure

Procedure joueurEcran(*joueur.stjoueur)
  *joueur.stjoueur = AllocateMemory(500)
  *joueur\x = 50
  *joueur\y = 50
  Debug "Creation"
  joueurGame(*joueur)
EndProcedure

Procedure Ecran(*joueur.stjoueur)
  joueurEcran(*joueur)
  joueurGame(*joueur)
EndProcedure

Procedure Game(*joueur.stjoueur)
  joueurGame(*joueur)
EndProcedure

Ecran(@joueur)   
Debug "game"
Game(@joueur)





Procedure.i NewJoueur()
  *joueur.stjoueur = AllocateMemory(500)
  *joueur\x = 50
  *joueur\y = 50
  ProcedureReturn *joueur
EndProcedure


Debug "--"
Debug "--"

*GROM.stjoueur = NewJoueur()


Ecran(*GROM)   
Debug "game"
Game(*GROM)

G-Rom a écrit :"joueur" est déclaré ou dans ton code ?

tu as raison, je me suis trompé, ça ressemble plutôt à ça en fait.

J'ai essayé d'être le plus proche possible du code que j'ai (en simplifié)

Code : Tout sélectionner

Structure stjoueur
  x.w
  y.w
EndStructure

Global i.a


Procedure joueurGame(*joueur.stjoueur)
  Debug Str(*joueur\x) +"/"+ Str(*joueur\y)
EndProcedure

Procedure InitJoueur()
  *joueur.stjoueur = AllocateMemory(500)
  *joueur\x = 50
  *joueur\y = 50
  Debug "Creation"
  joueurGame(*joueur)
  ProcedureReturn *joueur
EndProcedure

Procedure event_Ecran(*joueur.stjoueur)  
  If i = 0
    *joueur.stjoueur= InitJoueur()  
  EndIf
  If i= 1
    joueurGame(*joueur)
  EndIf
EndProcedure

Procedure Game(*joueur.stjoueur)
  joueurGame(*joueur)
EndProcedure

Procedure Ecran(*joueur.stjoueur)
  Repeat
    event_Ecran(*joueur)
    i+1
  Until  i =2
EndProcedure

Ecran(@joueur)   
Debug "game"
Game(@joueur)

*joueur est déclaré dans la procédure event_Ecran, pas à l'extérieur ^^.

chez pas pourquoi tu t'emm avec mes pointeurs pour ça

j'aurai fais ça perso :

Code : Tout sélectionner

Structure stjoueur
	id.l
	x.w
	y.w
EndStructure
global dim joueur.stjoueur(500)

Procedure joueurGame(id)
	Debug Str(joueur(id)\x) +"/"+ Str(joueur(id)\y)
EndProcedure

Procedure joueurEcran(id)
	
	joueur(id)\id=id
	joueur(id)\x = 50
	joueur(id)\y = 50
	Debug "Creation"
	joueurGame(id)
	ProcedureReturn joueur
EndProcedure

Procedure Ecran(id)
	joueurEcran(id)
	joueurGame(id)
EndProcedure

Procedure Game(id)
	
	debug "retour"
	debug joueur(id)\id
	debug joueur(id)\x
	debug joueur(id)\y
	
EndProcedure

calldebugger
id=2
Ecran(id)   

Debug "game"
id=2
Game(id)


; EPB

C'est normal que ca ne marche pas:
dans Ecran(), tu peux modifier la valeur pointée par *joueur mais pas *joueur elle-même. En fait le contenu de *joueur (c'est à dire \x et \y) peuvent être modifiés mais pas *joueur (c'est à dire l'adresse qui pointe vers \x et \y). Je suppose que tu veux faire un truc un peut style POO, tu devrais plutôt faire un truc du style:

Code : Tout sélectionner

Structure stjoueur
  x.w
  y.w
EndStructure


Procedure joueurGame(*joueur.stjoueur)
  Debug Str(*joueur\x) +"/"+ Str(*joueur\y)
EndProcedure

Procedure joueurEcran()
  *joueur.stjoueur = AllocateMemory(SizeOf(stjoueur))
  *joueur\x = 50
  *joueur\y = 50
  Debug "Creation"
  joueurGame(*joueur)
  ProcedureReturn *joueur
EndProcedure

Procedure Game(*joueur.stjoueur)
  joueurGame(*joueur)
  Debug "modif dans la game"
  *joueur\x = 25
  joueurGame(*joueur)
EndProcedure

joueur = joueurEcran()
joueurGame(joueur)
Game(joueur)
joueurGame(joueur)

"L'objet" joueur doit être "créé" et ensuite tu lui appliques les fonctions que tu veux. Mais on ne créée pas "l'objet" dans une fonction pour le récupérer ensuite.
Je ne sais pas si je suis très clair ...

salut

Merci pour vos réponses.

Finalement, avec Ombre on est passé par une variable globale pour résoudre le problème (oui, je sais c'est pas forcément top, mais le code est assez compliqué et on n'a pas trouvé comment résoudre ça sans variable globale).

blendman a écrit : Finalement, avec Ombre on est passé par une variable globale pour résoudre le problème (oui, je sais c'est pas forcément top, mais le code est assez compliqué et on n'a pas trouvé comment résoudre ça sans variable globale).

utiliser des variables global , c'est pas sale ! ( Ref : Doc&Deefool )

c'est juste une question de portée , rien de plus

a en croire ce que tu ecris , il y aurai quelque chose de honteux a utiliser les variables globales ....

je ne vois pas le probleme dans un code qui t'appartiens entierement ...

encore tu travaillerais en équipe , il y aurai un risque d'utilisation par un autre du meme nom ...
il n'y a qu'a etre imaginatif , par exemple faire débuter tes variables Globales par "blendman_" , ça évite le principale écueil
des variables globales , l'homonymie ..

Dobro a écrit : utiliser des variables global , c'est pas sale ! ( Ref : Doc&Deefool )

c'est juste une question de portée , rien de plus

a en croire ce que tu ecris , il y aurai quelque chose de honteux a utiliser les variables globales ....

encore tu travaillerais en équipe , il y aurai un risque d'utilisation par un autre du meme nom ...
il n'y a qu'a etre imaginatif , par exemple faire débuter tes variables Globales par "blendman_" , ça évite le principale écueil
des variables globales , l'homonymie ..

ne t'inquiète pas je suis tout à fait d'accord avec toi, je les utilise énormément

.
C'est juste que je sais que certains développeurs trouvent que c'est à éviter, mais personnellement, je trouve que c'est souvent très pratique (j'en abuse un peu j'avoue).

Je les utilise très souvent et j'ai pas honte ^^.

Ce n'est ni honteux ni sale, sinon, ben c'est bon la honte

.

ce n'est pas une question de honte, mais de pratique.
là, tu développe un jeu complet, tu peut donc voir dans la phase de développement , plusieurs phases.
ton jeu va nécessité , des outils , ton code n'est pas dans un seul fichier ( j'espère pour toi )
ton code est fragmenté et spécialisé dans différentes tâches , par exemple tu as fait une GUI , un bon dev te diras que cette GUI doit être réutilisable dans un autre projet sans changer une seule ligne de code, si tu colles des variables globales un peu partout , comment tu t'y retrouves ?
un conseil , ne code pas à l'arrache , car ton projet ne verra jamais le jour.

G-Rom a écrit : ton jeu va nécessité , des outils , ton code n'est pas dans un seul fichier ( j'espère pour toi )

la encore , c'est une question de gouts..

tout mes prg sont chacun dans un seul fichier . !
je n'utilise pas les includes ,parce que je trouve que c'est justement generateur de soucis
le jour ou tu aura un bug bien chiant , tu va perdre 3 plombes a chercher dans quel fichier se trouve le bug en question ...
(ça m'est deja arrivé ) ....

alors qu'en ayant le listing entier sous le nez , ça peut meme arriver a te trouver le bug direct , qu'en mode include il ne détectait rien !

et plantait plus loin ...

part peut etre pour de tres gros projets ... + de 10.000 lignes.. là faut voir

un bon dev te diras que cette GUI doit être réutilisable dans un autre projet sans changer une seule ligne de code,

heu là , on est dans le phantasme , ou la légende ... d'abords , j'en verrai pas l'utilité.. mais bon ..

si tu colles des variables globales un peu partout , comment tu t'y retrouves ?

comme je l'ai dit plus haut.., en donnant des noms explicites .. c'est une question d'habitude ..

maintenant, ne me faites pas dire ce que je dis pas , je ne prône pas ici le tout globale ..
juste qu'il ne faut pas avoir peur de les utiliser ...

heu là , on est dans le phantasme , ou la légende ... d'abords , j'en verrai pas l'utilité.. mais bon ..

La raison est simple, imagine que tu créer des jeux , que tu ne fait que ca, tu ne vas pas t'amuser à codé à chaque fois une gui.
il te faut un code que tu puisses réutilisé ailleurs dans un autre projet.
c'est courant pour les studios de faire ainsi , le jeu à blendman ne fait pas 2500 lignes de code à mon avis , mais bien plus...

c'est courant pour les studios de faire ainsi , le jeu à blendman ne fait pas 2500 lignes de code à mon avis , mais bien plus

Oh oui, enfait, mon jeu fait déjà 15 000 lignes et ce n'est pas terminé ^^.
Alors, je te rassure G-rom, il est découpé en plein de fichiers. J'essaie de ne pas dépasser les 1500 lignes par fichiers, mais j'ai aussi des fichiers qui ne font que quelques lignes. et j'essaie dès que c'est possible de réutiliser du code

.

J'ai tout organiser dans des dossiers et chaque concerne un domaine particulier du code ou du jeu (declaration, procedures, lib (texte, math, keyboard, mouse..), draw, event, init, etc..)
Je m'y retrouve bien comme ça et cette organisation me plait assez (j'utilise bien sûr les include, xincludefile, etc.. je trouve personnellement que c'est très pratique ^^).

Concernant les variables, j'ai tendance à privilégier les variables locales (shared, protected ou static en fonction du besoin), et sinon, les pointeurs ou les variables globales.
Comme j'utilise des threads, j'ai du faire attention au niveau des pointeurs, et lorsque c'est nécessaire je passe par des variables globales.
Celles-ci sont d'ailleurs toutes regroupées sur un unique fichier (variables.pb) et portent le suffixe Gb pour le reconnaitre (GbEcran par exemple).
Donc c'est très facile à retrouver.

Sinon, j'essaye effectivement de réutiliser le plus de code possible dès que je le peux ^^ (pas que les GUi, même le moteur graphique par exemple, mon moteur de particules, le depth, les procédures de transformation de sprite, etc..).
Même si mes premiers codes étaient assez mal fichus (c'est normal car depuis, j'ai un peu progressé j'imagine), je pense toujours à pouvoir réutiliser certains codes si celui-ci me semble convenir

.

D'ailleurs, mon jeu commence à être jouable et c'est vraiment sympa

Edit :
voici d'ailleurs une nouvelle vidéo de la dernière version (il reste encore quelques petits bugs d'ailleurs dessus ^^) :
https://vimeo.com/40642408

PureBasic

[RESOLU] Pointeurs

[RESOLU] Pointeurs

Re: Pointeurs

Re: Pointeurs

Re: Pointeurs

Re: Pointeurs

Re: Pointeurs

Re: Pointeurs

Re: Pointeurs

Re: Pointeurs

Re: Pointeurs

Re: Pointeurs

Re: Pointeurs

Re: Pointeurs

Re: Pointeurs

Re: Pointeurs