Peut -on modifier le FLIPMODE d'un screen à la volée ?

[drfloyd]

Hello

J'ai envie de commencer un jeu de role 2D, mais je voudrais ressoulever une question autour du flipbuffer (j'en ai deja causé une fois) :

J'utilise OPENSCREEN pour créer mon ecran de jeu
OpenScreen(Width, Height, Depth, Title$ [, FlipMode [, RefreshRate]])
avec un mode flip #PB_Screen_SmartSynchronization

Jusque là tout va bien, a chaque boucle FLIPBUFFER rafraichit mon image

Mais parfois dans une boucle de jeu, je voudrais faire des pauses pour afficher par exemple un texte, une mini fenetre, etc... sans devoir me retaper toute la boucle d'affichage (ca evite de mettre plein de conditions)

Je me demandais si on pouvait modifier à la volée le flipmode du screen ? C'est à dire le passer en #PB_Screen_NoSynchronization afin d'afficher immédiatement à l'ecran sans repasser par la boucle (et donc sans FLIPBUFFER) ??

Je sais pas si je suis clair.... Je crois pas LOL

[case]

salut,

#PB_Screen_NoSynchronization n'annule pas l'utilisation de flipbuffers()
c'est jusque que flipbuffers() n'attend pas la synchronisation verticale de l'ecran.

en gros toute les commandes graphiques sont effectuer dans un buffer memoire et lorsque tu utilise flipbuffers() le buffer utilise est echangé avec celui qu'utilise la carte graphique pour afficher l'image
l'image sur un écran est affichée d'en haut a gauche vers en bas a droite par un balayage de l'écran.

avec #PB_Screen_SmartSynchronization lorsque tu utilise la commande flipbuffers()
pure basic attend que le balayage arrive a la fin du balayage pour echange les buffers.
donc la carte graphique affiche les pixels depuis le haut de l'ecran vers le bas

avec #PB_Screen_NoSynchronization lorsque tu utilise la commande flipbuffers()
pure basic n'attend pas que le balayage arrive a la fin du balayage pour afficher la nouvelle image la carte graphique vas continuer d'afficher l'image en cours avec les nouvelles données a partir de l'endroit ou le balayage se trouve. ce qui n'affichera que partiellement la nouvelle image.

Code : Tout sélectionner

InitSprite()
InitKeyboard()
Dim col(1)
col(0)=0
col(1)=$ffffff
a=0

OpenScreen(800,600,32,"",#PB_Screen_SmartSynchronization)
Repeat
  ClearScreen(col(a))
  StartDrawing(ScreenOutput())
  DrawText(0,0,"#PB_Screen_SmartSynchronization")
  StopDrawing()
  a=Abs(a-1)
  ExamineKeyboard()  
  FlipBuffers()
Until KeyboardReleased(#PB_Key_Escape)
CloseScreen()


OpenScreen(800,600,32,"",#PB_Screen_WaitSynchronization)
Repeat
  ClearScreen(col(a))
  StartDrawing(ScreenOutput())
  DrawText(0,0,"#PB_Screen_WaitSynchronization")
  StopDrawing()
  a=Abs(a-1)
  ExamineKeyboard()  
  FlipBuffers()
Until KeyboardReleased(#PB_Key_Escape)
CloseScreen()


OpenScreen(800,600,32,"",#PB_Screen_NoSynchronization)
Repeat
  ClearScreen(col(a))
  StartDrawing(ScreenOutput())
  DrawText(0,0,"#PB_Screen_NoSynchronization")
  StopDrawing()
  a=Abs(a-1)
  ExamineKeyboard()  
  FlipBuffers()
Until KeyboardReleased(#PB_Key_Escape)
CloseScreen()

[drfloyd]

Merci pour ces précisions.

Donc pas de solution, à part un bidouillage :

boucle dans la boucle, avec capture d'ecran total pour débuter la "sous-boucle"

[case]

c'est une possibilitée

[drfloyd]

le GFA basic a une autre methode de refresh, tres sympa quand on ne code pas un jeu d'action :

le refresh se fait à volonté quand on le souhaite,
et il ne rafraichi que ce qui a été modifié depuis le refresh précédent.

C'est pratique pour certains programmes

[G-Rom]

Hello

J'ai envie de commencer un jeu de role 2D, mais je voudrais ressoulever une question autour du flipbuffer (j'en ai deja causé une fois) :

J'utilise OPENSCREEN pour créer mon ecran de jeu
OpenScreen(Width, Height, Depth, Title$ [, FlipMode [, RefreshRate]])
avec un mode flip #PB_Screen_SmartSynchronization

Jusque là tout va bien, a chaque boucle FLIPBUFFER rafraichit mon image

Mais parfois dans une boucle de jeu, je voudrais faire des pauses pour afficher par exemple un texte, une mini fenetre, etc... sans devoir me retaper toute la boucle d'affichage (ca evite de mettre plein de conditions)

Je me demandais si on pouvait modifier à la volée le flipmode du screen ? C'est à dire le passer en #PB_Screen_NoSynchronization afin d'afficher immédiatement à l'ecran sans repasser par la boucle (et donc sans FLIPBUFFER) ??

Je sais pas si je suis clair.... Je crois pas LOL

ce n'est pas la meilleur méthode

je te propose le code ci-dessous

L'idée est de stocker ton jeu dans différente partie de ton code via des structure , splash screen , le menu , le jeu en lui meme , l'écran de pause , etc... sans avoir a codé comme un porc des conditions qui n'en finissent pas et à se perdre dans son code.
C'est une sorte de "machine a état" que je te propose, chaque état est un élément distinct de ton jeu représenté par la structure suivante :

Code : Tout sélectionner

Prototype.l initialize()
Prototype   update(deltatime.f)
Prototype   render()
Prototype   exit()

Structure GameState
  initialize.initialize
  update.update
  render.render
  exit.exit  
EndStructure

Chaque état de ton jeu ( menu , splash screen , le jeu en lui même ) va dérivé de cet état
par exemple un menu :

Code : Tout sélectionner

Structure MyMenu Extends GameState
  button_new_game.l
  button_load_game.l
  button_options.l
  etc...
EndStructure

ensuite il faut des procédures commune aux état ( les prototypes plus haut )

Code : Tout sélectionner

Procedure.l MyMenu_initialize()
 ; tu load tes sprite , son , image, etc...
endprocedure

Procedure MyMenu_update(deltatime.f)
 ; tu code l'interaction avec ton menu
endprocedure

Procedure MyMenu_render()
 DisplaySprite(...
endprocedure

puis tu créer une variable de type MyMenu qui sera la répresentation de ton "état" menu et tu lui assigne ces procédures :
La signature des procédures doit être la même que les prototypes vu plus haut

Code : Tout sélectionner

Global MyMenuState.MyMenu 

MyMenuState\initialize = @MyMenu_initialize()
MyMenuState\update   = @MyMenu_update()
MyMenuState\render   = @MyMenu_render()

ensuite , il faut managé tout cela , après cela , tu n'auras plus qu'a codé des Etats différent sans te soucier de quoi que se soit d'autres

Code : Tout sélectionner

;//////////////////////////////////////////////////////////////////////////////
; Le manager qui "manage" les états
;//////////////////////////////////////////////////////////////////////////////
Structure GameStateManager
  *current_state.GameState
EndStructure

Global StateManager.GameStateManager

c'est un "manager" simple avec un pointeur sur un état quelconque , il lui faut quelques fonction de bases :

Procedure pour passer d'un état à l'autre,
si un état est déjà présent, on appelle la procedure exit() si elle existe , puis on initialise le nouvel état :

Code : Tout sélectionner

Procedure change_state(*state)  
  
  If StateManager\current_state
    If StateManager\current_state\exit <> #Null 
      StateManager\current_state\exit()
    EndIf   
  EndIf 
  
  StateManager\current_state = *state  
  
  If StateManager\current_state\initialize <> #Null 
     StateManager\current_state\initialize()   
   EndIf 
   
EndProcedure

et deux autre procédures bateau , update et render :

Code : Tout sélectionner

Procedure update(deltatime.f)
  If StateManager\current_state\update <> #Null 
    StateManager\current_state\update(deltatime)
  EndIf 
EndProcedure

Procedure render()
  If StateManager\current_state\render <> #Null 
    StateManager\current_state\render()
  EndIf 
EndProcedure

voici un code fonctionnel qui affiche un menu et écran de jeu factice :

Code : Tout sélectionner

;//////////////////////////////////////////////////////////////////////////////
; Patron d'état de jeu
;//////////////////////////////////////////////////////////////////////////////
Prototype.l initialize()
Prototype   update(deltatime.f)
Prototype   render()
Prototype   exit()

Structure GameState
  initialize.initialize
  update.update
  render.render
  exit.exit  
EndStructure



;//////////////////////////////////////////////////////////////////////////////
; Le manager qui "manage" les états
;//////////////////////////////////////////////////////////////////////////////
Structure GameStateManager
  *current_state.GameState
EndStructure

Global StateManager.GameStateManager
Global gamerunning = #True 


Procedure change_state(*state)  
  
  If StateManager\current_state
    If StateManager\current_state\exit <> #Null 
      StateManager\current_state\exit()
    EndIf   
  EndIf 
  
  StateManager\current_state = *state  
  
  If StateManager\current_state\initialize <> #Null 
     StateManager\current_state\initialize()   
   EndIf 
   
EndProcedure


Procedure update(deltatime.f)
  If StateManager\current_state\update <> #Null 
    StateManager\current_state\update(deltatime)
  EndIf 
EndProcedure

Procedure render()
  If StateManager\current_state\render <> #Null 
    StateManager\current_state\render()
  EndIf 
EndProcedure





;//////////////////////////////////////////////////////////////////////////////
; etat de jeu principal
;//////////////////////////////////////////////////////////////////////////////
Structure MyGame Extends GameState
  un_sprite.l
  timeBidon.l
EndStructure

Declare.l MyGame_initialize()
Declare MyGame_update(deltatime.f)
Declare MyGame_render()
Declare MyGame_exit()

;//////////////////////////////////////////////////////////////////////////////
; un menu...
;//////////////////////////////////////////////////////////////////////////////
Structure MyMenu Extends GameState
  button_image.l
  background_image.l
  timeBidon.f
EndStructure

Declare.l MyMenu_initialize()
Declare MyMenu_update(deltatime.f)
Declare MyMenu_render()
Declare MyMenu_exit()


;//////////////////////////////////////////////////////////////////////////////
; mes états , menu , jeu
;//////////////////////////////////////////////////////////////////////////////
Global MyMenuState.MyMenu
Global MyGameState.MyGame




;//////////////////////////////////////////////////////////////////////////////
; les fonctions de mes différents etat 
;//////////////////////////////////////////////////////////////////////////////
MyGameState\initialize  = @MyGame_initialize()
MyGameState\update      = @MyGame_update()
MyGameState\render      = @MyGame_render()
MyGameState\exit        = @MyGame_exit()

Procedure.l MyGame_initialize()
  ;MyMenuState\button_image = load...()
  ;MyMenuState\background_image = load...()
  MyGameState\timeBidon = ElapsedMilliseconds() + 2000
  Debug "initialisation du jeu"
EndProcedure

Procedure MyGame_update(deltatime.f)
  ; Position_x + 50 * deltatime...
;   Debug "game update"
  
  ExamineKeyboard()
  
  If KeyboardReleased(#PB_Key_Escape)
    change_state(@MyMenuState) ; on retourne au menu
  EndIf 
  
EndProcedure

Procedure MyGame_render()
  
  ClearScreen($A0)
  
  StartDrawing(ScreenOutput())
  DrawText(10,10,"boucle de jeu bidon")
  DrawText(10,30,"echap pour retourné au menu")
  StopDrawing()
  
  FlipBuffers()
  
  ;DisplaySprite(...
;  Debug "game render"    
EndProcedure

Procedure MyGame_exit()
  ;FreeSprite(...
;   Debug "game exit"
EndProcedure






;//////////////////////////////////////////////////////////////////////////////
; les fonctions de mes différents etat 
;//////////////////////////////////////////////////////////////////////////////
MyMenuState\initialize  = @MyMenu_initialize()
MyMenuState\update      = @MyMenu_update()
MyMenuState\render      = @MyMenu_render()
MyMenuState\exit        = @MyMenu_exit()

Procedure.l MyMenu_initialize()
  ;MyMenuState\button_image = load...()
  ;MyMenuState\background_image = load...()
  
  Debug "initialisation du menu"
  
  MyMenuState\timeBidon = 0
  
EndProcedure

Procedure MyMenu_update(deltatime.f)
  ; Position_x + 50 * deltatime...
  
  
  MyMenuState\timeBidon + deltatime

  If MyMenuState\timeBidon > 2.0
    change_state(@MyGameState)
  EndIf 
  
  ExamineKeyboard()
  
  If KeyboardPushed(#PB_Key_Escape)
    End
  EndIf   
  
;   Debug "menu update"
EndProcedure

Procedure MyMenu_render()
  
  ClearScreen($BAA0)
  
  StartDrawing(ScreenOutput())
  DrawText(10,10,"menu bidon qui disparaît en 2 sec...")
  DrawText(10,30,"echap pour quitter")
  StopDrawing()
  
  FlipBuffers()
  
  ;DisplaySprite(...
;  Debug "menu render"    
EndProcedure

Procedure MyMenu_exit()
  ;FreeSprite(...
   Debug "menu exit"
EndProcedure












deltatime.f = 0

InitSprite() : InitKeyboard()
w = 800
h = 600


wnd = OpenWindow(#PB_Any,0,0,w,h,"")
OpenWindowedScreen(WindowID(wnd),0,0,w,h,1,0,0)

; On commence par le menu
change_state(@MyMenuState)


; Boucle principale
;
While gamerunning = #True   
  
  Repeat
    event = WindowEvent()
    If event = #PB_Event_CloseWindow
      gamerunning = #False 
    EndIf 
  Until event = 0
  
  
  begin_time.l = ElapsedMilliseconds()  
    update(deltatime)
    render()    
  end_time.l = ElapsedMilliseconds()
  deltatime = (end_time - begin_time) / 1000
  
Wend

End 

Le GameStateManager est simple, avec un peu d'astuce , tu peu avoir un Etat en pause ( pas d'appel à update() par exemple , mais quand même appel a render() , et afficher un autre state par dessus ) , ou faire tourné 2 etat en même temps pour faire une transition graphique par exemple...
tu peu approfondir le sujet en tapant sur ton moteur de recherche "Game State" , "Game State Manager"

En espérant t'avoir aidé.

@++

[drfloyd]

je ne sais pas si m'a aidé... je n'ai pas trop l'habitude de coder de façon structurée

Je vais quand meme étudier ta proposition

merci !

[case]

quelle master-classe g-rom je garde ça de cote ^^

[G-Rom]

il y a une petite coquille dans mon code, il faut plutôt faire :

Code : Tout sélectionner

Prototype.l initialize(*self)
Prototype   update(*self,deltatime.f)
Prototype   render(*self)
Prototype   exit(*self)

Structure GameState
  initialize.initialize
  update.update
  render.render
  exit.exit  
EndStructure




Structure MonMenu Extends GameState
  
EndStructure


Procedure MonMenu_init(*self.MonMenu)
  
EndProcedure

Procedure MonMenu_update(*self.MonMenu, deltatime.f)
  
EndProcedure

Procedure MonMenu_render(*self.MonMenu)
  
EndProcedure

Procedure MonMenu_exit(*self.MonMenu)
  
EndProcedure

[Ollivier]

Code : Tout sélectionner

Prototype   update(*self,deltatime.f)
Prototype   render(*self)

Tu sépares l'horloge de la update de l'horloge "réelle" (balayages clavier, souris, écran, etc...)

À la place d'une parade en 3 temps (création, modification, destruction), tu architectures en 4 temps (création, modif virtuelle, modif "réelle", destruction)

C'est dur à saisir dans un 1er temps, mais ça vaut le coup de s'aventurer, et ça donne une utilité ludique de travailler avec les prototypes.

[Ollivier]

Code : Tout sélectionner

Prototype.l initialize(*self)

Petite question, en te passant le bonjour : ça ne serait pas plutôt .i (en sortie de fonction) ?

[Ollivier]

Comme j'ai vu "partie bidon de jeu", comme d'hab je me suis lancé bêtement dans un jeu bidon. C'est du code source pur porc, mais le coeur y est ! Juste flèche gauche, flèche droite et la souris. Mais il n'y a même pas le tir... Libre à vous d'en faire un bel exemple.

Code : Tout sélectionner

Procedure aGray(x)
    ProcedureReturn RGBA(x, x, x, x)
EndProcedure

Procedure transform(sp, z.d, x0, y0, x1, y1, x2, y2, x3, y3)
    TransformSprite(sp, x0 * z, y0 * z, x1 * z, y1 * z, x2 * z, y2 * z, x3 * z, y3 * z)
EndProcedure

InitSprite()
InitKeyboard()
InitMouse()
ExamineDesktops()
scW = DesktopWidth(0)
scH = DesktopHeight(0)
OpenScreen(scW, scH, 32, "", #PB_Screen_SmartSynchronization)
scBackC = RGB(32, 64, 128)
msCursZoom.d = 3.2
msCurs = CreateSprite(#PB_Any, 64, 64)
StartDrawing(SpriteOutput(msCurs) )
Box(0, 0, 64, 64, RGB(0, 0, 0) )
Box(10, 5, 50, 50, RGB(255, 255, 255) )
StopDrawing()
transform(msCurs, msCursZoom, 8, 8, 3, 8, 0, 12, 0, 0)

pen = CreateSprite(#PB_Any, 3, 3, #PB_Sprite_AlphaBlending)
StartDrawing(SpriteOutput(pen) )
DrawingMode(#PB_2DDrawing_AllChannels)
Box(0, 0, 3, 3, RGBA(0, 0, 0, 0) )
Box(0, 1, 3, 1, RGBA(255, 255, 255, 255) )
StopDrawing()

head = CreateSprite(#PB_Any, 32, 32, #PB_Sprite_AlphaBlending)
StartDrawing(SpriteOutput(head) )
DrawingMode(#PB_2DDrawing_AllChannels)
Box(0, 0, 32, 32, RGBA(0, 0, 0, 0) )
For i = 16 To 1 Step -1
    Circle(16, 16, i, aGray(256 - Pow(i, 3/5) * 16) )
Next
StopDrawing()



Structure xy
    x.d
    y.d
EndStructure



Procedure pointCreate(x.d, y.d)
    Protected *r.xy = AllocateMemory(SizeOf(xy) )
    With *r
        \x = x
        \y = y
    EndWith
    ProcedureReturn *r
EndProcedure



Structure transform
    
    A.xy
    B.xy
    
    ang.d
    rad.d
    
    an0.d
    an1.d
    an2.d
    an3.d
    
    rd0.d
    
    pen.i
    
    C.xy
    D.xy
    E.xy
    F.xy
    
EndStructure



Procedure traceCreate()
    Protected *r.transform = AllocateMemory(SizeOf(transform) )
    ProcedureReturn *r
EndProcedure




Procedure trans(pen, *a.xy, *r.xy, ang.d, rad.d, thickness.d = 1.0)
    
    
    Define.d ax, ay, bx, by, cx, cy, dx, dy, ex, ey, fx, fy
    Define.d an0, an1, an2, an3
    Define.d rd
    
    ax = *a\x
    ay = *a\y
    ;rd = Sqr(2) * 1.5 * thickness ; 1.5 = spriteHeight (3) / 2
    rd = Sqr(1) * 1.5 * thickness ; 1.5 = spriteHeight (3) / 2
    
    bx = ax + Cos(ang) * rad
    by = ay - Sin(ang) * rad
    
    ;an0 = ang + (3 * #PI / 4)
    ;an1 = ang + (1 * #PI / 4)
    ;an2 = ang - (1 * #PI / 4)
    ;an3 = ang - (3 * #PI / 4)
    
    an0 = ang + (#PI / 2)
    an1 = ang + (#PI / 2)
    an2 = ang - (#PI / 2)
    an3 = ang - (#PI / 2)
    
    cx = ax + Cos(an0) * rd
    cy = ay - Sin(an0) * rd
    dx = bx + Cos(an1) * rd
    dy = by - Sin(an1) * rd
    ex = bx + Cos(an2) * rd
    ey = by - Sin(an2) * rd
    fx = ax + Cos(an3) * rd
    fy = ay - Sin(an3) * rd
    
    TransformSprite(pen, cx, cy, dx, dy, ex, ey, fx, fy)
    DisplayTransparentSprite(pen, 0, 0, RGB(255, 0, 0) )
    *r\x = bx
    *r\y = by
    ProcedureReturn *r
EndProcedure

Procedure.d max(a.d, b.d)
    If a > b
        ProcedureReturn a
    Else
        ProcedureReturn b
    EndIf
EndProcedure

#pMax = 31
Global Dim *p.xy(#pMax)
Global Dim *gp.xy(63, #pMax)

Procedure guy(man, pen, head, j.d, timeScale.d, scW.d, scH.d)
    For i = 0 To #pMax
        If i <> pen
            ;*p(i) = *gp(man, i)
        EndIf
    Next
    trans(pen, *p(0), *p(1), 3*#PI/2 + Cos(j) / 4 * timeScale, scW/32, 20)
    trans(pen, *p(1), *p(2), 3*#PI/2 + (Cos(j) / 4 - ((1 - Cos(j) ) / 8) ) * timeScale, scW/32, 20)
    trans(pen, *p(0), *p(4), 3*#PI/2 + Cos(j+#PI) / 4 * timeScale, scW/32, 20)
    trans(pen, *p(4), *p(5), 3*#PI/2 + (Cos(j+#PI) / 4 - ((1 - Cos(j+#PI) ) / 8) ) * timeScale, scW/32, 20)
    *p(8)\x = *p(0)\x
    *p(8)\y = *p(0)\y - scW/32
    trans(pen, *p(8), *p(12), 3*#PI/2 + Cos(j+#PI) / 4 * timeScale, scW/40, 16)
    trans(pen, *p(12), *p(13), 3*#PI/2 + ((Cos(j+#PI) / 4) + ((1 + Cos(j+#PI) ) / 8 * (1 * timeScale) ) ) * timeScale, scW/40, 16)
    trans(pen, *p(8), *p(9), 3*#PI/2 + Cos(j) / 4 * timeScale, scW/40, 16)
    trans(pen, *p(9), *p(10), 3*#PI/2 + ((Cos(j) / 4) + ((1 + Cos(j) ) / 8 * (1 * timeScale) ) ) * timeScale, scW/40, 16)
    *p(16)\x = *p(8)\x + (scW / 640) * Pow(timeScale, 2)
    *p(16)\y = *p(8)\y
    trans(head, *p(16), *p(17), #PI/2, scW/40, scW/160)
    *p(0)\x + 3*Sqr(max((Cos(j) + 1), Cos(j + #PI) + 1) )*Pow(timeScale, 2)
    For i = 0 To #pMax
        ;*gp(man, i) = *p(i)
    Next
EndProcedure

Procedure released(x)
    Static Dim stat(255)
    k = KeyboardPushed(x)
    If k And stat(x) = 0
        stat(x) = k
        ProcedureReturn 1
    EndIf
    stat(x) = k
EndProcedure

For i = 0 To #pMax
    *p(i) = AllocateMemory(SizeOf(xy) )
Next
SpriteQuality(#PB_Sprite_BilinearFiltering)
*p(0)\x = scW / 2
*p(0)\y = scH / 2
timeScale.d = 0
Repeat
    *p(0)\x - MouseDeltaX()
    *p(0)\y - MouseDeltaY()
    Delay(1)
    ExamineKeyboard()
    ExamineMouse()
    ClearScreen(scBackC)
    j.d = ElapsedMilliseconds() / 100 * timeScale
    For i = 0 To 0
        guy(0, pen, head, j, timeScale, scW, scH)
        
        *p(20)\x = 0
        *p(20)\y = scH / 2
        trans(pen, *p(20), *p(21), 0, scW, 1)
        *p(22)\x = scW / 2
        *p(22)\y = 0
        trans(pen, *p(22), *p(23), 3*#PI/2, scH, 1)
    Next
    
    If *p(0)\x > scW
        *p(0)\x - scW
    EndIf
    If Released(#PB_Key_Right)
        timeScale + 0.5
    EndIf
    If Released(#PB_Key_Left)
        If timeScale >= 0.5
            timeScale - 0.5
        EndIf
    EndIf
    ;DisplaySprite(msCurs, MouseX(),  MouseY() )
    FlipBuffers()   
Until KeyboardPushed(#PB_Key_Escape) Or MouseButton(#PB_MouseButton_Middle)

[G-Rom]

Code : Tout sélectionner

Prototype.l initialize(*self)

Petite question, en te passant le bonjour : ça ne serait pas plutôt .i (en sortie de fonction) ?

Bonjour Ollivier, bien sûr , tu fait comme tu l'entends et selon tes besoins

Code : Tout sélectionner

Prototype   update(*self,deltatime.f)
Prototype   render(*self)

Tu sépares l'horloge de la update de l'horloge "réelle" (balayages clavier, souris, écran, etc...)

À la place d'une parade en 3 temps (création, modification, destruction), tu architectures en 4 temps (création, modif virtuelle, modif "réelle", destruction)

C'est dur à saisir dans un 1er temps, mais ça vaut le coup de s'aventurer, et ça donne une utilité ludique de travailler avec les prototypes.

Effectivement, pour la simple et bonne raison de clarté et de maintenance , mais pas que. imagine que demain tu doit rendre ton jeu en réseau et que tu veut créer un serveur dédié sans faire de rendu , tu n'appelles plus le rendu , mais uniquement les updates / event , pas besoins de grosses adaptations pour faire fonctionner ton code.

[Ollivier]

J'ai testé la syntaxe des protypes avant de tapoter mon petit jeu bidon. Et il y a quand même un level !

Le coup de la couche avec la structure, ça donne le vertige.
Je vais tenter de m'habituer avec CallFunctionFast(*proc(a, b), *object(a, b) )

En planifiant un tableau 2D qui est librement accessible client, ça fait une sorte de prototype-runtime. Ça peut me permettre de m'habituer à l'utilisation des prototypes seuls (sans CallFunctionFast() ).

[G-Rom]

Tu peu aussi aller un peu plus loin en utilisant les modules / interfaces :

Code : Tout sélectionner

DeclareModule Foo
  
  Interface iFoo
    Free()
    SetCallBack(*callback, type.l)
    Init()
    Exit()
  EndInterface
  
  Enumeration 
    #CB_INIT  
    #CB_EXIT  
  EndEnumeration
  
  
  Prototype.i on_init(*self)
  Prototype   on_exit(*self)
        
  Structure sFoo
    *vtable  
    on_init.on_init
    on_exit.on_exit
  EndStructure
  
  Declare.i New(sizeof.l)
  
EndDeclareModule



Module Foo

  Procedure.i New(sizeof.l)
    *f.sFoo = AllocateMemory(sizeof)
    *f\vtable = ?vtable
    ProcedureReturn *f
  EndProcedure
  
  Procedure Free(*foo.sFoo)
    If *foo\on_exit <> #Null 
      *foo\on_exit(*foo)
    EndIf 
    FreeMemory(*foo)
  EndProcedure
  
  Procedure SetCallBack(*foo.sFoo, *callback, type)
    Select type
      Case #CB_INIT        
        *foo\on_init = *callback
      Case #CB_EXIT
        *foo\on_exit = *callback
    EndSelect
  EndProcedure
  
  Procedure Init(*foo.sFoo)
    If *foo\on_init
      *foo\on_init(*foo)
    EndIf 
  EndProcedure
  
  Procedure Exit(*foo.sFoo)
    If *foo\on_exit
      *foo\on_exit(*foo)
    EndIf 
  EndProcedure
  
  
  
  DataSection
    vtable:
    Data.i @Free()  
    Data.i @SetCallBack()  
    Data.i @Init()  
    Data.i @Exit()  
  EndDataSection

EndModule



Structure sTest Extends Foo::sFoo
  *memory
  string.s  
EndStructure

Procedure.i test_init(*t.sTest)
  *t\string = "Hello world !"
  *t\memory = AllocateMemory(512)
  Debug "test_init() : " + *t\string
EndProcedure

Procedure test_exit(*t.sTest)
  FreeMemory(*t\memory)
  Debug "test_exit"
EndProcedure
  

test.Foo::iFoo = Foo::New(SizeOf(sTest))
test\SetCallBack(@test_init(),Foo::#CB_INIT)
test\SetCallBack(@test_exit(),Foo::#CB_EXIT)


test\Init()

; test\Exit()
test\Free()