Re: PURE BASIC - Le Topic officiel

[Dobro]

et voici la version "souris"

il faut bouger la souris... etonnant non ?

Code:



Declare Sprites()

#Window = 0


ExamineDesktops()
Width=DesktopWidth(0)
height=DesktopHeight(0)
Enumeration
      #brique
      #balle
EndEnumeration
Global xbrique,ybrique,xpas,ypas,xb,yb,flag
dep = 10


;- Initialisation de DirectX
InitMouse()
If InitSprite() = 0 Or InitKeyboard() = 0
      
      End
EndIf
;- Ouverture de la fenêtre et de l'écran
hwnd = OpenWindow(#Window, 0, 0, Width, Height,"", #PB_Window_BorderLess| #PB_Window_ScreenCentered)
OpenWindowedScreen(hwnd, 0, 0, Width, Height, 1, 0, 0)
Sprites()
;- Initialisation des sprites
xbrique = 86 : ybrique = 138
xb= 0 : yb= 0
xpas = 5 : ypas = 5



;- Boucle des évènements
Repeat
      ClearScreen(rgb(0, 0, 0)) : ExamineKeyboard()
      ExamineMouse()
      xm=mousex()
      ym=mousey()
      if xm<0
            xm=0
      endif
      if xm>width
            wm=width
      endif
      if ym<0
            ym=0
      endif
      if ym>height
            ym=height
      Endif
      
      ; Affichage des sprites
      DisplayTransparentSprite(#brique, xbrique, ybrique)
      DisplayTransparentSprite(#balle, xb, yb)
      FlipBuffers()
      xb=xb + xpas
      yb=yb + ypas
      
      If SpritePixelCollision(#balle, xb, yb, #brique, xbrique-5, ybrique)<>0 And flag=0
            flag=1
            SetWindowTitle(#window ,"Collision à gauche")
            xpas=-xpas
            Goto su ; sort du test !!!
      EndIf
      If SpritePixelCollision(#balle, xb, yb, #brique, xbrique+5, ybrique)<>0 And flag=0
            flag=1
            SetWindowTitle(#window,"Collision à droite")
            xpas=-xpas
            Goto su ; sort du test !!!
      EndIf
      If SpritePixelCollision(#balle, xb, yb, #brique, xbrique, ybrique-5)<>0  And flag=0
            flag=1
            SetWindowTitle(#window,"Collision au dessus")
            ypas=-ypas
            Goto su ; sort du test !!!
      EndIf
      If SpritePixelCollision(#balle, xb, yb, #brique, xbrique, ybrique+5)<>0  And flag=0
            flag=1
            SetWindowTitle(#window,"Collision au dessous")
            ypas=-ypas
            Goto su ; sort du test !!!       
      EndIf
      
      su: ; <<<<<<<<<<<<<<< -------------------- sortie du test
      If flag=1
            attente+1
      EndIf
      If attente>4
            attente=0
            flag=0
      EndIf
      
      ;Delay(2)
   ;
   If KeyboardPushed(#PB_Key_Escape) : quit = 1    : EndIf
;       If KeyboardPushed(#PB_Key_Left)  : xbrique - dep : EndIf
;       If KeyboardPushed(#PB_Key_Right)  : xbrique + dep : EndIf
;       If KeyboardPushed(#PB_Key_Up)    : ybrique - dep : EndIf
;       If KeyboardPushed(#PB_Key_Down)  : ybrique + dep : EndIf

      
      xbrique=xm
      ybrique=ym
      
      
      
      
      
      If xb <=0  : xpas= -xpas  : EndIf
      If yb <=0  : ypas= -ypas  : EndIf
      If xb >=Width : xpas= -xpas  : EndIf
      If yb >=height : ypas= -ypas  : EndIf
      While WindowEvent() : Wend
Until quit = 1
;
;******************* procedures Zone *****************************************

Procedure Sprites()
      ; Procedure de création des sprites
      If CreateSprite(#brique,128,24,#PB_Sprite_PixelCollision)          ; Sprite Fixe
            StartDrawing(SpriteOutput(#brique))
                  Box(0,0,128,24,RGB($FF,$0,$0))
            StopDrawing()
      EndIf
      If CreateSprite(#balle,20,20,#PB_Sprite_PixelCollision)          ; Sprite Mobile
            StartDrawing(SpriteOutput(#balle))
                  Circle(10,10,10,RGB($0,$0,$FF))
            StopDrawing()
      EndIf
EndProcedure



; Epb


[Dobro]

@drFloyd, je pense que tu te prends trop la tete sur un rien ...

probablement que tu as gardé des reflexe d'autres langage, et que tu ne pense pas "Purebasic"

je m'explique , la plupart des langage Basic t'enferme dans un univers
je connais le probleme avec AGK2 par exemple

on est completement pris en mains par le prg (le langage n'est dans ce cas qu'un prolongement d'un programme)

tout comme lorsque tu es dans Photoshop , tu es dans le context photoshop pour faire
des truc de retouches photo ....


avec Purebasic, c'est comme pour les langage type C , C++
tu n'es pas dans un context, le context c'est windows, et c'est toi avec ton code
qui va imposer un context ....

je sais pas si je suis bien clair


en clair, tu es le seul maitre a bords , et qu'il faut pour ça recreer un contexte graphique,ben tu le fait

car tu n'as pas le confort d'etre enfermé dans un ecran qu'un programme "langage" aura créé pour toi

par exemple, avec Purebasic tu peux te creer un ecran tout rond !!   ou triangulaire ...


tu peux aussi te creer une fenetre qui en fait est une image .... sans bords la tete de mickey si tu veux LOL

[drfloyd]

Oui tu es clair... En BLITZ je pouvais programmer comme je tape un texte à la machine à ecrire.... du vrai basic ou tout est préparé.... c'etait quasi un game maker

Non mais sinon j'arrive à faire exctement ce que je veux en terme de programme avec PURE... J'ai deja testé un RPG enteirement à la souris, un shoot up up avec 2000 sprites et des scrollings.... meme avant tes exemples de qualité

mais c'est l'affichage plein ecran qui varie d'un pc à un autre, le texte aussi (!!! rien compris aux fontes, elles varient selon le pc !!!!) et puis tout qui deconne quand je lance un EXE.... La definition graphique devient folle.... La souris qui tournait bien se met à délirer.... etc....

Ca doit etre parce que je suis sur la version démo c'est pas possible autrement ????

[drfloyd]

Je ne suis pas fou

meme ton casse brique, quand je crée un EXE la souris deconne totalement

[Urbinou]

Tu as nettoyé ta bille et les petites roulettes à l'alcool ?

[Dobro]

ben oui c'est bizarre ...

c'est quoi ton pc en Carton ?? (LOL)

tu as encore confondu le pc avec le grille pain, c'est pas possible autrement :)

j'ai utilisé Purebasic sur differents PC, un netbook (samsung NC10 avec rez native 1024x600) , ou bien sur mes 2 MSI gamer (un gt780 dxr , et mon actuel Msi GT72 dominator pro ) ,  sur un Asus portable , bref, jamais rencontré de probleme :)

[Dobro]

haaa mais attends, .... tu as pas par hasard une Razer en souris ??

(certaines souris haute resolution peuvent causer un crash ...ça me reviens )

on en avait parlé sur le Forum Purebasic ici:
https://www.purebasic.fr/french/viewtopic.php?f=4&t=15356&hilit=SOURIS+RAZER

[drfloyd]

j'ai un N4200 (genre netbook) et un i7 de bureau.... tout à fait classiques, et des souris HP/Acer de base...

En dev tout va bien, des que je crées un .EXE rien ne se comporte normalement....

[Dobro]

si tu as un probleme lié a ta souris (probablement haute resolution...)

la solution conciste a poser cette procedure dans ton code (a la fin )

Code:


Procedure mousethread(flag.i) ; souris roccat, razer .....
 Static quit.i
 If flag
 Repeat
 If ExamineMouse()
 mouseX=MouseX()
 mouseY=MouseY()
 EndIf
 Delay(1)
 Until quit
 quit=#False
 Else
 If Not flag
 quit=#True
 While quit
 Delay(1)
 Wend
 EndIf
 EndIf
EndProcedure

et juste apres ton openscreen
tu fais :

Code:


OpenScreen(ScreenWidth, ScreenHeight, 32, "")
thread=CreateThread(@mousethread(),#True)

en n'oubliant pas d'activer le Threads dans les parametres de compilation


si tu as bien ce genre de souris, teste et dis moi



ou bien ...... teste avec une autre souris (LOL)

[Dobro]

sinon dans tes parametres de compilation
coche DPI aware a tout hasard ....

des fois que tu n'affiches pas windows a 100% mais a 125%

[drfloyd]

t'es un Dieu, c'etait ca.... la souris refonctionne et l'ecran est redevenu normal

J'etais sur le point de relancer BLITZ tellement j'etais énervé 

[drfloyd]

Il me reste les fontes à comprendre. Je ne voulais meme pas en utiliser, juste afficher du texte avec drawtext, c'est tout, en toute simplicité

Donc j'ai rien spéficié du tout mais le resultat donne un texte trop gros... faut que je reduise sa taille....

Du coup j'ai tenté comme lu dans la doc :

LoadFont(0, "courrier",8)   (j'ai mis courrier au pif, comme j'aurai pu mettre arial)
 DrawingFont (FontID(0))

ca permet d'avoir une fonte plus petite mais je peux peux mettre "cacaboudin" ou "zizi" à la place de courrier ou arial que le resultat est le même !

Et en plus selon les PC la taille de la fonte est plus ou moins grande à l'affichage

Du coup j'ai tenté d'importer une fonte à moi :

LoadFont(0, "DATA/fonteperso.ttf",8)
 DrawingFont (FontID(0))

Mais pareil, c'est toujours la meme fonte qui apparait, et toujours variable selon les PCs

Rien pigé... ne me dites pas que la doc est claire, c'est pas vrai 

Bref, comment on fait PRINT "HELLO WORLD" avec PURE ? 

Je veux juste afficher du texte moi et me voici emmerdé avec les fontes... qui ne donnent pas le meme resultat (en taille surtout) selon les PC

Le DOc au bord de la dépression

[Dobro]

pardon j'etais occupé

alors pour ce qui concerne
LoadFont(0, "courrier",8)  ,  le "8" determine la taille de ta fonte

et pour le "je rentre n'importe quel nom ça marche pas..
c'est fait Expres !!  :)

Fred (le createur de Pb) a fait en sorte que la fonction LoadFont n'echoue jamais
cela evite des problemes lorsque par exemple une fonte viens a manquer

les fontes fonctionnent tres bien si tu entre le nom d'une fonte existante sur ton systeme ...

si tu veux connaitre les fontes installé sur ton system, il te faut utilise un traitement de text par exemple LibreOffice
tu recup le nom exacte d'une fonte, et utilise le dans la fonction LoadFont ...

et là, tu vas me dire, oui mais moi je voudrai connaitre le nom des fonte installées
sans avoir a lancer mon traitement de texte préféré ....

et là je te repond (t'as vu, je fait tout ici les questions et les reponses LOL )
ben il te faut la version complete de PB (j'ai aucune actions dans la boite de prod)

car la version complete, te permet d'utiliser les APIs
en effet, seule l'api windows te permettra de lister les fonte du systeme

note, que tu peut te faire une procedure qui utilise l'api
chose que tu trouverai dans un langage X ou y sous la forme d'une commande
toute faite (en fait, faites par le createur de ton super langage Basic )
sauf que là, c'est toi qui le fait .....
c'est cool Purebasic non ?  LOL

voici le code qui utilise l'api windows pour lister les fontes de ton system

Code:


fonte.logfont
;fonte\lfCharSet = #DEFAULT_CHARSET
fonte\lfFaceName =0

Procedure enumcallback(*a.LOGFONT,*b.TEXTMETRIC,fonttype.l,param.l)
 If PeekB(@*a\lfFaceName) <> 0
 Debug PeekS(@*a\lfFaceName)
 ProcedureReturn 1
 Else
 ProcedureReturn 0
 EndIf
EndProcedure


Repeat
 Delay(10)
Until (EnumFontFamiliesEx_(GetDC_(0),@fonte,@enumcallback(),0,0) = 1) ; EPB

;
; EPB


ce qui chez moi renvoi ceci :

liste de mes fontes:

je pense que si tu utilises "Comic Sans MS" ça dois le faire

donc un LoadFont(#font,"Comic Sans MS",6) devrai fonctionner avec une petite fonte de corp 6 


a propos des fontes , pour un jeux, tu peux aussi te faire des fontes sous la forme Graphique
une planche de Sprite , et ensuite avec un GrabSprite , recuperer tes caracteres un par un ... :)
style Old School 

[Shaoth]

Tu peux quand même utilisé des fonts bitmap ?
Le Doc est plus fainéant, mais si on veut faire des jeux retro il faut des assets retro.

EDIT :
Je viens de lire la fin de ton post !
Elle est là ta réponse Doc, utilise des fonts bitmap, avec plusieurs couleurs en plus, rien de plus beau !

[Dobro]

oui c'est ce que j'ai ecris, tu peux aussi utiliser des images ... ou des planches d'images ...  :)

(ça me fait pensé que j'avais codé un "Demo construction kit" , faudra que je remette la main sur mon code  )


en attendant voici en utilisant les fontes systeme

Code:


#window = 0

; mais si tu veux du plein ecran alors on interoge la resolution en cours
ExamineDesktops()

Width=DesktopWidth(0)
height=DesktopHeight(0)  ; <<<<<<<< voila on connais la resoltuion


Enumeration
 #Window
 #fonta
 #fontb
 #fontc
EndEnumeration

;- Initialisation de DirectX
If InitSprite() = 0 Or InitKeyboard() = 0 Or InitMouse() = 0
 MessageRequester("Erreur", "Impossible d'initialiser DirectX", 0)
 CloseWindow(#window) : End
EndIf

;--------- les fontes ----------------------
LoadFont(#fonta,"Courrier",6)
LoadFont(#fontb,"Arial",15)
LoadFont(#fontc,"Comic Sans MS",24)




;- Ouverture de la fenètre et de l'écran
hwnd = OpenWindow(#window, 0, 0,  Width, Height, "",#PB_Window_BorderLess|#PB_Window_ScreenCentered)  ;#PB_Window_TitleBar | #PB_Window_ScreenCentered|#PB_Window_SystemMenu  )
;***********If CreateGadgetList(hwnd)
; ScrollAreaGadget(#Panel,10, 10,800,600, 1024, 768, 30)
; hCont = ContainerGadget(#Cont,10,10,1024,768,#PB_Container_Double)
OpenWindowedScreen(hwnd, 0, 0, Width, height, 0, 0, 0)
;***********EndIf

If CreateSprite(1000,24,24)
 StartDrawing(SpriteOutput(1000))
 Box(0,0,24,24,RGB($0,$0,$FF))
 StopDrawing()
EndIf

Dep = 8

;- début de la boucle
yf=10
yf2=50
yf3=100
pas=5
pas2=5
pas3=5

Repeat
 
 
 yf=yf+pas
 yf2=yf2+pas2
 yf3=yf3+pas3
 
 if yf>=height-10 or yf<10
 pas=-pas
 Endif
 
 if yf2>=height-10 or yf2<10
 pas2=-pas2
 Endif
 
 if yf3>=height-10 or yf3<10
 pas3=-pas3
 Endif
 
 
 ExamineMouse()  ; on demande a purebasic de surveiller les event de souris !
 ExamineKeyboard() ; on demande a purebasic de surveiller les event de clavier!
 evnt= WindowEvent()
 Delay(2)
 Select    evnt
 
 Case #PB_Event_CloseWindow
 End
 EndSelect
 StartDrawing(ScreenOutput())
 DrawingMode(#PB_2DDrawing_AlphaBlend ) ; on va utiliser la transparence
 
 
 DrawingFont(fontId(#fonta)) ; on choisi la font corp 6
 DrawText(10, yf, "touche ESC pour quitter  (fonte courier corp 6)" ,RGB(255,255,0),RGB(0,0,0))
 ;
 DrawingFont(fontId(#fontb)) ; on choisi la font corp 15
 DrawText(10, yf2, "touche ESC pour quitter (fonte ARIAL  corp 15) " ,RGB(255,0,0),RGB(0,0,0))
 
 DrawingFont(fontId(#fontc)) ; on choisi la font corp 24
 DrawText(10, yf3, "touche ESC pour quitter (Fonte Comic Sans MS corp 24) " ,RGB(0,255,255),RGB(0,0,0))
 StopDrawing()
 
 
 FlipBuffers() : ClearScreen(RGB(0,0,0))
 DisplaySprite(1000, x, 100)
 
 
 ;************** deplacement d'un sprte **************
 x + Dep
 If x >=Width Or x <=0 : Dep = -Dep : EndIf ; mouvement horizontle de notre sprite
 ;  *************************************************
 
Until KeyboardPushed(#PB_Key_Escape)




[Dobro]

allez pour le fun , prosternez vous devant la puissance du Purebasic

(bon ici on utilise une fonction qui permet de condenser un code en un minimum de caratere



 

Code:


;*****************************************************************************
;*
;* Name   : 3D Wave
;* Author : Petr Vavrin (peterb)
;* Date   : 14.06.09
;* Notes  :
;*
;*****************************************************************************
Macro _(u,v):If u<28:LineXY(a(c),a(c+1),a(c+v),a(c+v+1),b(c)):EndIf:EndMacro:k.f
o=1024:InitSprite():OpenWindow(0,0,0,o,o,""):Dim a(5*o):Dim b(5*o):s=WindowID(0)
OpenWindowedScreen(s,0,0,o,o,1,0,0):l=99:While WindowEvent()<>16:ClearScreen(0)
StartDrawing(ScreenOutput()):If l=99:h=Random(2):i=k-Random(40):j=a.f-Random(8)
l=0:EndIf:a-j/99:k-i/99:l+1:v.f+0.01:w.f+0.003:y=-30:While y<30:x=-30:While x<30
z.f=a*Sin((k*Sqr(x*x+y*y)-p)/57):g.f=Sin(v)*y+Cos(v)*z:cw.f=Cos(w):sw.f=Sin(w)
f.f=o/(99-(cw*g-sw*x)):r=(z+a)*127/a:b(m)=r<<(8*h):a(m)=(cw*x+sw*g)*f+o/2
a(m+1)=(Cos(v)*y-Sin(v)*z)*f+o/2:m+2:x+2:Wend:y+2:Wend:p+9:m=0:For u=1 To 28
For t=1 To 28:c=(t+u*30)*2:_(t,2):_(u,60):Next:Next:StopDrawing():FlipBuffers()
Delay(20):Wend

;
; EPb


[Dobro]

avec les fontes ont peut aussi s'amuser

Code:


; code Dobro
LoadFont (1, "arial" , 50 )
LoadFont (2, "arial" , 50 )
Resultat = InitSprite ()
Global angle,Amplitude
Amplitude=10
Texte.s= "Le Lac d'annecy !"

WindowID = OpenWindow (1, 50, 50, 640, 200, "hello" , #PB_Window_SystemMenu|#PB_Window_MinimizeGadget )
WindowID = WindowID (1)
OpenWindowedScreen ( WindowID , 0, 0, 640, 200, 1, 0, 0)

CreateImage (100, 640, 100)
StartDrawing ( ImageOutput (100))
    FrontColor ( RGB ($0,$FF,$FF))
    BackColor ( RGB (0, 0, 0))
   
   
    DrawingFont ( FontID (1))
    DrawingMode (1)
   
    DrawText (0,0,Texte.s)
StopDrawing ()

For t=0 To 100
    GrabImage (100, t, 0, t, 640,1)
Next t
Repeat
   
   
    For Y= 0 To 100
        StartDrawing ( ScreenOutput ())
            angle+1 : If angle=360*10: angle=0 : EndIf
            x=1+( Sin (angle*2*3.1415926/50)* Amplitude)
            DrawImage ( ImageID (Y), x+40, Y+20*x/25+50,640,1)
        StopDrawing ()
        dep+1 : If dep>640 :dep=-100: EndIf
    Next Y
   
    StartDrawing ( ScreenOutput ())
        DrawingFont ( FontID (2))
        DrawingMode (1)
        FrontColor ( RGB ($95,$25,$BA))
        BackColor ( RGB (0, 0, 0))
        DrawText (40,0,Texte.s)
    StopDrawing ()
   
    FlipBuffers ()
    ClearScreen ( RGB (0, 0, 0))
    Event= WaitWindowEvent (100/60)
    ;Delay(1)
Until Event= #PB_Event_CloseWindow



[Dobro]

bon je vous laisse digérer tout ça  a+++ 

bonne soirée a vous


ps j'allais oublier ....

pour un hello world 

on peut utiliser  simplement 

Code:

debug "hello world"

ou bien

Code:



MessageRequester("hello", "hello world")

ou bien

Code:

OpenConsole("hello")
   print("hello world")
   input()
CloseConsole()

ou bien les codes ci dessus en mode graphique .....

[Shaoth]

Je crois que le flux d'informations est trop important pour le Doc...
Il peut assimiler à quelle vitesse le Doc ? 1200 bauds quand tout va bien ?
On va le perdre 

[drfloyd]

Le Dr Dobro est en mode vitesse démesurée... Mes 16ko de RAM ne sont plus assez, je vais devoir acheter une extension de cerveau 64ko.

COSMOS II est en chemin !!! Vous pensiez avoir tout vu avec le premier.....

[drfloyd]

bah avec Pure oui j'ai l'impression, comme avec BLITZ

Mais ca dépend des langages, en RC Basic ou NAALAA quoi que tu fasses en terme de reso, du 320x300 ou du 658x349, l'image est toujours nickelle et parfaite à l'affichage. C'est hyper surprenant, je ne sais pas comment ils font.

Oui c'est surprenant, parce qu'à la base c'est un souci physique. Tu dois extrapoler 480 points en 1080, soit 2.25 pixels physiques pour un pixel logique, et la même chose en horizontal. Les pixels intermédiaires sont calculés en faisant une moyenne des pixels adjacents, d'où le flou.

j'ai contacté le créateur de RCBasic pour comprendre pourquoi l'affichage est toujours super net, meme avec des definitons ttoalement exotiques en fullscreen.

Il me dit (sans surprise) que pour son basic orienté 100% 2D quelque soit la definition choisie (c'est du scale de l'image, pas de changement de définition en hard) il n'y a aucun filtre qui est appliqué, 0, rien... et que du coup il y a 0 flou.

Etonnant que d'autres basics ne proposent pas çà (j'en ai essayé des dizaines, et y a que RC Basic et NAALAA qui proposent ça)

Le rendu est exceptionnel, comme sur les jeux à gros pixels sur PS4 et XOne.

seul truc qui peut apparaitre de ce fait : des cercles non parfaits, on des dessins un poil déformé, mais franchement c'est quasi invisible.

Je ne sais pas si il possible de reproduire ça en Pure ?

[Urbinou]

Donc certains pixels logiques seront plus épais que d'autres... à voir selon les graphismes utilisés, mais je crois que je préfère un léger flou à ce phénomène : )

[Dobro]

(c'est du scale de l'image, pas de changement de définition en hard)

Salut,

en fait pour etre franc, je ne comprends pas cette phrase


je ne sais pas s'il parle du chargement d'une image avec un LoadImage() ou loadSprite()

s'il parle de la façon de dessiner une image ou sprite sur l'ecran ?


parceque mis a part peut etre les fonctions de chargement d'un fichier image

je ne vois pas dans la façon de dessiner un pixel a l'ecran du Purebasic
l'utilisation d'un Filtre ....


en Purebasic on ouvre un context graphique

StarDrawing( ici on met sur quel type on va dessiner ex  spriteOutput(num_sprite) )

ensuite on plot(x,y,couleur) le pixel

Stopdrawing() on sort du context graphique


plus simple ça n'existe pas !!!


dans un basic lambda ça fait la meme chose
sauf que le context Graphique est deja ouvert en interne !


Purebasic etant bas niveau, il t'oblige a creer ce context avant de l'utiliser ...

apres comme je te l'ai dis, le choix de l'univers du context peut avoir son importance

le fait de compiler pour OpenGL ou DirectX11 peut donner des differences...

possible dans ce cas, que ton ordi soit legerement alergique au numero de version de DirectX (11 pour le Purebasic) et qu'un emulation se fasse alors...

passe ta compilation en sous system "OpenGL"  a ecrire telquel sans guillemet ici : (option de compilation )


en meme temps , certains membres du forum Purebasic (Ar-s)
fait remonter que sur ses ecrans geants , tes graphs sont vraiment tres (trop) petit

je pense que lorsqu'on veux faire du old scool en prog , il faut aussi s'adapter aux materiel actuel ..
en clair on ne code pas en  320x200  comme a l'epoque du ST

on code en 1024x768  ou mieux en 1920x1080  en dessinant des sprites simplement
plus gros ... comme ça on reste dans le Pixel Art, mais avec des sprites adapté a nos systemes ... 

[Dobro]

a propos des fontes , on peut s'amuser a faire du oldScool :)

Code:


;*******************************************************************************************************
;- déclarations des procedures
;*******************************************************************************************************
Declare  Ondulation(spr,x,y,taille_x,xt,Texte$,couleur.l)
Declare   msg_erreur(Chaine$)

;*******************************************************************************************************
;;DisableDebugger

;- test du materiel
;*******************************************************************************************************
If InitSprite()=0
   msg_erreur("impossible d'initialiser les sprites"+Chr(10)+" le prg va quitter ")
   End
EndIf
If InitMouse()=0
   msg_erreur("impossible d'initialiser la souris"+Chr(10)+" le prg va quitter ")
   End
EndIf

If InitKeyboard()=0
   msg_erreur("impossible d'initialiser le clavier"+Chr(10)+" le prg va quitter ")
   End
EndIf
;*******************************************************************************************************
;-initialisations constante structure tableaux variables
;*******************************************************************************************************
Enumeration
   #win
EndEnumeration
Enumeration
   #degrade
   #boule
EndEnumeration
Enumeration
   #police
EndEnumeration

Largeur_screen=1024
Hauteur_screen=768

Structure degrade
   x.w
   y.w
   sensx.l
   sensy.l
EndStructure

degrade.degrade
degrade\sensy.l=10
degrade\sensx.l=0
degrade\x.w=0
degrade\y.w=0
Largeur_degrade=Largeur_screen
Hauteur_degrade=Hauteur_screen


Structure boule
   x.w
   y.w
   sensx.f
   sensy.f
EndStructure
Global Dim boule.boule(500)
For i=0 To 499
   boule(i)\x.w=Random(largeur_screen)
   boule(i)\y.w=Random(hauteur_screen)
Next i
; ****************************************
Structure sprite
   x.w
   y.w
   sensx.l
   sensy.l
EndStructure

sprite.sprite
sprite\sensy.l=0
sprite\sensx.l=-10
sprite\x.w=-Largeur_screen
sprite\y.w=hauteur_screen/2
Largeur_sprite=500
Hauteur_sprite=100

;-ouvre ecran
;*******************************************************************************************************
OpenWindow(#win,1,1,Largeur_screen,Hauteur_screen,"test",#PB_Window_SystemMenu |#PB_Window_ScreenCentered    )
OpenWindowedScreen(WindowID(#win),1,1,Largeur_degrade, Hauteur_degrade,1, 1,1,#PB_Screen_WaitSynchronization )
KeyboardMode(1)
;SystemParametersInfo_(#SPI_SETFONTSMOOTHING,#False,0,0)
;*******************************************************************************************************
LoadFont(#Police, "Bauhaus 93", 50 ,#PB_Font_Bold)
;**************************************************************************************************
texte$="By Dobro and Fig ..."
;Affiche un fond
CreateSprite(#boule,32,32)
StartDrawing(SpriteOutput(#boule))
   DrawingFont(FontID(#Police))
   Largeur_sprite=TextWidth(texte$)
   Hauteur_sprite=TextHeight(texte$)
   DrawingMode(#PB_2DDrawing_Gradient)  
   BackColor($E65352)
   FrontColor($0)
   CircularGradient(16,16, 16)
   Circle(16,16,16)
StopDrawing()
;
;-boucle principale
Repeat
  
   WindowEvent()
   ;- Examine le materiel
   ;*******************************************************************************************************
   ExamineKeyboard()
   ExamineMouse()
   ;*******************************************************************************************************
   ;- logique de deplacement
   ;*******************************************************************************************************
   degrade\y.w=degrade\y.w+degrade\sensy.l
   ;  degrade\x.w=degrade\x.w+degrade\sensx.l
   ;* Nécessaire si on veut un dégradé changeant horizontalement en plus...
   ;    If degrade\x.w>largeur_screen/2 Or degrade\x.w<1
   ;       degrade\sensx*-1
   ;    EndIf
   If degrade\y.w>Hauteur_sprite<<2 Or degrade\y.w<0
      degrade\sensy*-1
   EndIf
   ; *************
   ;-deplacement
   ;*************
   sprite\y.w=sprite\y.w+sprite\sensy.l
   sprite\x.w=sprite\x.w+sprite\sensx.l
   If sprite\y.w>(hauteur_screen-hauteur_sprite-10) Or sprite\y.w<10
      sprite\sensy*-1
   EndIf  
   If sprite\x.w<-Largeur_Sprite
      sprite\x.w=Largeur_Screen+Largeur_Sprite
   EndIf
   ;*******************************************************************************************************
   ;-changement du texte si besoin
   ;*******************************************************************************************************
   texte$="By Dobro ...... PureBasic Power ..........  Scroll fontes Color ........."
   ;*******************************************************************************************************
   ;-affichage des sprites
  
  
  
  
  
   ;*******************************************************************************************************
   ;Affiche un fond
   For i=1 To 500
      boule(i)\sensx.f=Random(2)+ -1
      boule(i)\x=boule(i)\x+boule(i)\sensx.f
      boule(i)\sensy.f=Random(2)+ -1
      boule(i)\y=boule(i)\y+boule(i)\sensy.f
      DisplayTransparentSprite(#boule,boule(i)\x,boule(i)\y)
   Next i
  
   ;affiche le scroll
   taille_x=largeur_screen
  
   xt=xt-3; on deplace le text dans le sprite
  
   if xt<=-largeur_screen*3
      xt=largeur_screen
   Endif
   y=hauteur_screen/2
   x=1
   couleur.l= $0  ; rgb(255,0,255)
   Ondulation(#degrade,x,y,taille_x,xt,Texte$,couleur.l)
  
   FlipBuffers() ; affiche le resultat a l'ecran !
   ClearScreen(#Black) ; nettoie l'ecran apres affichage
Until KeyboardPushed(#PB_Key_Escape)
;SystemParametersInfo_(#SPI_SETFONTSMOOTHING,#True,0,0)
End
; ********* Zone des sous-programme ******************

; **************** Zone des procedures  ******************
Procedure Ondulation(spr,x,y,taille_x,xt,Texte$,couleur.l)
   ; procedure realisé par OLIV l'ondulation
   ; et DOBRO pour la mise en couleur... et la sortie sur Sprite
  
   ; ******* explication des parametres ***************
   ;spr = numero d'un sprite .. il sera cree et detruit par cette procedure )
   ; ce sprite contiendra le texte$ , c'est le texte$ qui bouge... pas le sprite il me sert d'ecran !
   ; X;Y = la coodonée d'affichage du sprite "ecran" qui contient donc le text
   ; taille_x  = la taille en X du Sprite "Ecran" .. en principe la taille_y est calculé automatiquement ...
   ; xt = c'est le deplacement horizontal du text dans le sprite "ecran" , si on veux que ça scroll => x=x-2
   ; Texte$ = le text a afficher
   ; Couleur.l  =   si egale a  0 ce sera un degradé mouvant dans la fonte !!!  ..... sinon , ce sera la couleur choisie
  
   memposy=taille_y
   static  angleo.f ; ceci anime les lettres
   #VitesseAngle = 1 * #PI / 50 ; vitesse de modification de l'angle de départ du texte
   #HauteurSin = 50 ; Coef qui joue sur la hauteur de la sinusoide
   #LargeurSin = 50 ; Coef qui joue sur la largeur de la sinusoide
  
   taille_y=#HauteurSin*4
   yt=#HauteurSin*2
  
  
   If createsprite(spr,taille_x,taille_y)
      StartDrawing(SpriteOutput(spr))
         DrawingFont ( FontID (0)) ; On change la police
         angleo + #VitesseAngle ; Angle de départ de la sinusoide en radian
         If angleo >= 2 * #PI
            angleo = 0
         EndIf
         ; On affiche toute les lettres
         PosX = 10 ; Position du caractère
        
         For n = 1 To Len (Texte$) ; Pour chaque lettre du texte
            Lettre.s = Mid (Texte$, n, 1) ; on récupère la lettre à la position n
            PosY =  #HauteurSin * Sin (angleo + PosX / #LargeurSin )-taille_y/4 ; on calcul la position en Y de la lettre
            
            if couleur.l=$0
               DrawingMode(#PB_2DDrawing_Gradient|#PB_2DDrawing_Transparent)  
               BackColor($0)
               For i=0 To 255
                  GradientColor(0.4, RGB(i,0,0))
                  GradientColor(0.8,RGB(0,i,0))
                  GradientColor(0.16,RGB(0,0,i))
                  GradientColor(0.32,RGB(0,i,i))
                  GradientColor(0.64,RGB(i,i,0))
               Next i
               LinearGradient(0, 0, taille_x,taille_y)
               else
               FrontColor ( couleur.l ) ; On change la couleur.
            Endif
            ;Box(0, 0, 1024, 768)
            DrawText (xt+PosX, yt+PosY,Lettre)
            PosX + TextWidth (Lettre)
         Next
        
      StopDrawing () ; On signife que l'on arrête les fonctions dessin 2D.
      DisplaytransparentSprite( spr,x,y)
      FreeSprite(spr)
      
   Endif
EndProcedure

Procedure  msg_erreur(Chaine$)
   MessageRequester("erreur", Chaine$, #PB_MessageRequester_Ok )
EndProcedure
; *************************************************************







;




;

; Epb




[jmg49]

ça y est Dobro est lancé ( salut ! au passage)

le code en punch c'est hard quand même ! tu vas nous les dégouter

[Dobro]

yo Jm49 ça roule?

[drfloyd]

plus personne ne peut arrêter Dobro !!!! (enorme ce que tu nous propose !)

Alors juste pour remercie Dobro et bien montrer que je ne pose pas ces questions pour rien, voici un premier essai de proto pour mon futur COSMOS II... c'est primaire, c'est vraiment un essai... et ca se joue à la souris

[Shaoth]

A la souris... 

[drfloyd]

oui pour ranger les objets, les echanger, manger, boire, etc... comme dans Dungeon Master

sinon pour se deplacer on pourra aussi au clavier et à la manette

[Shaoth]

A la souris !!!! Et pourquoi pas au trakball aussi !!!
Tu deviens fou Doc...
Je ne te reconnais plus...

[Urbinou]

Cosmos IV sera en VR !