Frame unabhängig coden

Übersicht BlitzBasic Allgemein

Neue Antwort erstellen

 

Till

Betreff: Frame unabhängig coden

 BeitragMi, Sep 15, 2004 9:52
Antworten mit Zitat
Benutzer-Profile anzeigen
Moin,


ich hoffe Ihr reisst mir nicht den kopf ab; ionpainters tut habe ich
dazu schon gelesen. aber irgendwie nen brett vorm kopp.

Also eigendlich möchte ich das im Spiel eine funktion 30 mal
pro sek ausgeführt wird.

gedacht - gemacht habe ich das hier:
Code: [AUSKLAPPEN]

Global HowOften4 = 30
Global WaitTime4 = 1000 / HowOften4
Global LastTime4 = MilliSecs()
...
...
...
...
Time = MilliSecs()
   If Time > LastTime4 + WaitTime4 Then
      ...
      ...

   EndIf


was eigendlich auch ganz gut läuft erweist sich jedoch als falsch
denn auf meinen testrechner startete ich das game und siehe da
nach ca. 20 sek konnte ich deutlich sehen das die langsamereren
rechner "hinterher" hinkten.

interessant würde ja für mich in diesem falle die frame-unabhängige
methode sein aber die habe ich irgendwie noch nicht so geschnallt
bin halt schon etwas älter:)

über kleine beispiele würde ich mich sehr freuen...falls jemand sogar
so nett ist mir da richitg zuhelfen könnte ich den source gerne auch
mailen. muss aber dazu sagen das das ganze auf blitzplay pro gebaut
ist....
 

morszeck

 BeitragMi, Sep 15, 2004 10:14
Antworten mit Zitat
Benutzer-Profile anzeigen
Wen du BlitzPlus hast, so könntest du bequem mit EventTimer arbeiten...

Sonst sollte es nicht so schwer sein. Dein Ansatz ist gut.

Jetzt kann es sein, dass deine Funktion oder auch der Rest des Programms "überladen" ist und somit diese auf langsameren Rechner das ganze Programm ausbremst...

Zur Zeit überprüfst du nur ob der Timer eine bestimmte Zeit überschreitet. Aber was ist wen er die Zeitlimite unterschreitet?

Hatte mal auch ein Problem mit dem Abgleich eines RealTime Programms (wen man es so nennen darf)

ACHTUNG: Debug rausnehmen und eine Wave-Datei bereithalten die am besten Ambient oder Drum&Bass enthält...


Code: [AUSKLAPPEN]
; WaveSample 1.5 @ René Morszeck
;
; Einlesen und Dekodieren von wave-Files 8 und 16 bit, mono und stereo
; Ausgabe der Wave's in Echtzeit mit Fehlerkorrektur
; So das die Ausgabe auch bei langsamen PC's synchron ist
;

Graphics3D 1024,768,32,2
SetBuffer BackBuffer()


;########################################

Global data_format          ; 0=mono 1=stereo / Normalfall auch bei Mono ist immer 1 für beide Lautspecher
Global data_kanal           ; 1 oder 2, gibt effektiven 1=mono/kanal 2= stereo/kanal
Global data_sample          ; Frequenzwiedergabe zbsp 44100 Hz
Global data_bytesprosekunde ; effektive abgespielte Bytes pro Sekunde
Global data_bytesprosample  ; 1 (1Byte,mono), 2(1Byte,stero oder 2Byte,mono) oder 4 (2Byte,stereo) Byte
Global data_bitsprosample   ; 8 oder 16 Bits pro Kanal
Global data_laenge          ; Gelesene/Abgespielte Daten in Byte
Global data_laengeeffektiv  ; Gespeicherte Datensätze in Byte im Type 'wave'
Global data_timetotal#      ; Totale Abspielzeit in Sekunden
Global data_timebyte#       ; Zeit in Millisekunden pro Datensatz aus Type 'wave' für Echtzeitwiedergabe

Global kanal1
Global kanal2

Global t
Global timer

;----------------------------------------

; Einstellungen für den Effekt

Dim s#(359)
Dim c#(359)

For i=0 To 359
   s#(i) = Sin(i)
   c#(i) = Cos(i)
Next


Const teiler = 256
Const data_rate = 360
a = 1
x = 1

pivot = CreatePivot()
cam = CreateCamera(pivot)
light = CreateLight(1,cam)
RotateEntity light, 90, 0, 0
MoveEntity cam, 0, 220, -250
TurnEntity cam, 45,0,0


AmbientLight 255,255,255
;CameraClsColor cam,0,0,255
CameraZoom cam, 1
;CameraProjMode cam, 2
;CameraFogMode cam, 1
;CameraFogRange cam,250,700
;CameraFogColor cam,180,180,180

objekt = data_rate/2

Dim o1(objekt)

For i=0 To objekt-1
   o1(i) = CreateSphere(4)
   j = 255.0/(objekt)*i
   EntityColor o1(i), j, 255-j, 0
;   EntityFX o1(i),12
Next


;########################################

file$ = "BSW_SF.wav"   ; <============= hier den Namen der WaveDatei eingeben


; öffnen der Wave Datei
Global datei = ReadFile(file$)

; Einlesen der WaveDaten
ReadDataWave()

; Laden der Wave Datei
sound = LoadSound(file$)
; und Abspielen des Sound's
musik = PlaySound(sound)

; Hilfsvariabel zum Berechnen der Zeitabstände für Echtzeitwiedergabe (Synchronisation)
t = MilliSecs()


;########################################


While Not KeyHit(1)

   ; Synchronsteuerung
   If (timer*data_timebyte#) < (MilliSecs()-t) Then
      ReadWave()
      timer = timer + 1
      If timer = data_laenge Then Exit
   EndIf
   
   
   ; Ab hier eigene Effekte die über Kanal 1+2 gesteuert werden.
   ; Wen die Musik:
   ;  8-bit ist, so nimmt Kanal 1+2 Werte zwischen 0-255 an.
   ; 16-bit ist, so nimmt Kanal 1+2 Werte zwischen 0-65535 an.
   ;

   m = (timer Mod data_rate)
   ss = s(m)*(x/4)
   cc = c(m)*100
   k1 = kanal1/teiler
   k2 = kanal2/teiler
   
   ;PositionEntity o1(m/2), ss, k1+(m/4) ,cc
   PositionEntity o1(m/2), m-180, k1-cc, k2-ss
   ;ScaleEntity o1(m/2),1,ss,1
   
      
   If m = 0 Then

      x=x+a
      If (x Mod 300)=0 Then a=a*(-1)
      
      TurnEntity pivot,0,1,0
      
      RenderWorld()
      
      td = MilliSecs()-ts
      Text 0,td*15,(1.0*td/data_rate)
      ts=MilliSecs()
      
      Flip 0
      Cls
      
   EndIf

   
Wend

;---


StopChannel musik
FreeSound musik
CloseFile datei

Text 0,550, "Ende <Taste Drücken>"
Flip
Waitkey()
End

;######################################## ENDE


Function ReadWave()

; Einlesen der Waves
; hier wird ab Byte 44 die WaveDaten eingelesen


   ; überprüfen ob Wave mono ist
   If data_kanal = 1 Then

      ; 8bit mono
      If data_bytesprosample = 1 Then
         kanal1 = ReadByte(datei)
         Return
      EndIf


      ; 16bit mono
      If data_bytesprosample = 2 Then
         kanal1 = ReadByte(datei)
         kanal1 = ReadByte(datei) * 2^8 + kanal1
         If kanal1 >= (2^15) Then kanal1 = (2^16 - kanal1) * (-1)
         Return
      EndIf

   EndIf


   ; überprüfen ob Wave stereo ist
   If data_kanal = 2 Then

      ; 8bit stereo
      If data_bytesprosample = 2 Then
         kanal1 = ReadByte(datei)
         kanal2 = ReadByte(datei)
         Return
      EndIf


      ; 16bit stereo
      If data_bytesprosample = 4 Then
         kanal1 = ReadByte(datei)
         kanal1 = ReadByte(datei) * 2^8 + kanal1
         kanal2 = ReadByte(datei)
         kanal2 = ReadByte(datei) * 2^8 + kanal2
         If kanal1 >= (2^15) Then kanal1 = (2^16 - kanal1) * (-1)
         If kanal2 >= (2^15) Then kanal2 = (2^16 - kanal2) * (-1)
         Return
      EndIf

   EndIf

End Function

;----

Function ReadDataWave()

   ; Byte 0-3 Name (RIFF)
   For t = 0 To 3
      head_name$ = head_name$ + Chr$(ReadByte(datei))
   Next

   ; Byte 4-7 Länge
   head_laenge = Int(ReadByte(datei))
   head_laenge = Int(ReadByte(datei))*2^8  + head_laenge
   head_laenge = Int(ReadByte(datei))*2^16 + head_laenge
   head_laenge = Int(ReadByte(datei))*2^24 + head_laenge

   ; Byte 8-11 Typ (WAVE)
   For t = 0 To 3
      head_typ$ = head_typ$ + Chr$(ReadByte(datei))
   Next

   ; Byte 12-15 Name (fmt)
   For t = 0 To 3
      data_name$ = data_name$ + Chr$(ReadByte(datei))
   Next

   ; Byte 16-19 Länge ($10 = 16)
   data_laenge = Int(ReadByte(datei))
   data_laenge = Int(ReadByte(datei))*2^8  + data_laenge
   data_laenge = Int(ReadByte(datei))*2^16 + data_laenge
   data_laenge = Int(ReadByte(datei))*2^24 + data_laenge

   ; Byte 20-21 FormatType [0=mono] [1=stereo] <!!!>
   data_format = Int(ReadByte(datei))
   data_format = Int(ReadByte(datei))*2^8  + data_format

   ; Byte 22-23 Kanalzahl <!!!>
   data_kanal = Int(ReadByte(datei))
   data_kanal = Int(ReadByte(datei))*2^8  + data_kanal

   ; Byte 24-27 Sample Rate in Herz <!!!>
   data_sample = Int(ReadByte(datei))
   data_sample = Int(ReadByte(datei))*2^8  + data_sample
   data_sample = Int(ReadByte(datei))*2^16 + data_sample
   data_sample = Int(ReadByte(datei))*2^24 + data_sample

   ; Byte 28-31 Bytes pro Sekunde <!!!>
   data_bytesprosekunde = Int(ReadByte(datei))
   data_bytesprosekunde = Int(ReadByte(datei))*2^8  + data_bytesprosekunde
   data_bytesprosekunde = Int(ReadByte(datei))*2^16 + data_bytesprosekunde
   data_bytesprosekunde = Int(ReadByte(datei))*2^24 + data_bytesprosekunde

   ; Byte 32-33 Bytes pro Sample [1=8bit/mono] [2=8bit/stereo oder 16bit/mono] [4=16bit/stereo] <!!!>
   data_bytesprosample = Int(ReadByte(datei))
   data_bytesprosample = Int(ReadByte(datei))*2^8  + data_bytesprosample

   ; Byte 34-35 Bits pro Sample <!!!>
   data_bitsprosample = Int(ReadByte(datei))
   data_bitsprosample = Int(ReadByte(datei))*2^8  + data_bitsprosample

   ; Byte 36-39 Name (data) !!! im Normalfall Byte 36-39 !!!
   Repeat
      data_name$ = data_name$ + Chr$(ReadByte(datei))
      If Right(data_name$,4) = "data" Then
         data_name$ = Right(data_name$,4)
         Exit
      EndIf
   Forever

   ; Byte 40-43 Länge <!!!> !!! im Normalfall Byte 40-43 !!!
   data_laenge = Int(ReadByte(datei))
   data_laenge = Int(ReadByte(datei))*2^8  + data_laenge
   data_laenge = Int(ReadByte(datei))*2^16 + data_laenge
   data_laenge = Int(ReadByte(datei))*2^24 + data_laenge

   ; Berechnen der orginal Länge in Byte
   If data_kanal = 1 Then
      If data_bytesprosample = 1 Then data_laengeeffektiv = data_laenge
      If data_bytesprosample = 2 Then data_laengeeffektiv = data_laenge / 2
   EndIf
   If data_kanal = 2 Then
      If data_bytesprosample = 2 Then data_laengeeffektiv = data_laenge / 2
      If data_bytesprosample = 4 Then data_laengeeffektiv = data_laenge / 4
   EndIf

   ; berechnung der Abpsiellänge in Sekunden
   data_timetotal# = Float(data_laengeeffektiv) / Float(data_sample)

   ; berechnung der Zeit pro Byte in Millisekunden
   data_timebyte# = 1.0 / Float(data_sample) * 1000


   Local ausgabe = 0

   If ausgabe = 1 Then
      Print data_kanal + " Kanal"
      Print data_sample + " Herz"
      Print data_bitsprosample + " Bits pro Sample"
      Print data_laenge + " Byte gelesene Rohdaten"
      Print data_laengeeffektiv + " Byte im Datensatz effektiv gespeichert"
      Print (data_timetotal# * 1000) + " Sekunden Abspielzeit"
      Print data_timebyte# + " Millisekunden Abspielzeit pro Datensatz"
   EndIf


;   Text 0,550, "zum Starten <Bitte Taste drücken>"
;   WaitKey()


End Function
WinXpProf&SP2, B3D V1.88, B+ V1.40, BMax101Beta, AMD TB1.4GHz, DDR266/768MB, GeForce3@64MB
  • Zuletzt bearbeitet von morszeck am Mi, Sep 15, 2004 10:18, insgesamt 2-mal bearbeitet
 

zocker2150

 BeitragMi, Sep 15, 2004 22:31
Antworten mit Zitat
Benutzer-Profile anzeigen
https://www.blitzforum.de/viewtopic.php?t=3065
Nur zur Volltändigkeit Wink
 

Till

 BeitragDo, Sep 16, 2004 9:14
Antworten mit Zitat
Benutzer-Profile anzeigen
Moin,


Zitat:

".....onpainters tut habe ich
dazu schon gelesen. aber irgendwie nen brett vorm kopp. "




nur zur vollständigkeit !
 

zocker2150

 BeitragDo, Sep 16, 2004 9:30
Antworten mit Zitat
Benutzer-Profile anzeigen
Genau deswegen auch der link Till!
Damit andere dies interessiert auch gleich das tut haben. Wink
 

Till

 BeitragDo, Sep 16, 2004 14:18
Antworten mit Zitat
Benutzer-Profile anzeigen
jetzt mal eine andere idee.....


da es sich in meinem Spiel um eine permanente bewegung
von objekten handelt....könnte man das nicht so machen das
die clients erkennen das sie die bewegung zu schnell/langsam
gemacht haben und sich somit der speed anpassen?!


was haltet ihr davon...was könnte das für vor bzw nachteile
haben ??
 

morszeck

 BeitragDo, Sep 16, 2004 15:38
Antworten mit Zitat
Benutzer-Profile anzeigen
Das ist ja ganz genau das was ich vorher gepostet habe... Schau dir nur mal den Teil in der While_Wend Schleife an, dort steht die Lösung...
WinXpProf&SP2, B3D V1.88, B+ V1.40, BMax101Beta, AMD TB1.4GHz, DDR266/768MB, GeForce3@64MB

Neue Antwort erstellen


Übersicht BlitzBasic Allgemein

Nach Oben

Gehe zu:

Powered by phpBB © 2001 - 2006, phpBB Group