Zu viel vorm Bildschirm gesessen?

winduff · **Registriert:** 10.02.2006 21:05 **Wohnort:** Gießen

1-400 sind die richtigen namen, siehe den dload-code

Edit: Wunderbar, jetzt muss sich nurnoch einer dranmachen und die Sightseeing Tour richtig machen, mit Wegweiser usw xD

Kaeru Gaman · **Registriert:** 10.11.2004 03:22

die richtigen namen sind 001-400.

ich lehne es kathegorisch ab, bildarchive ohne führende nullen zu verwenden.

PMV · **Verfasst:** 07.10.2006 20:06

Hier hab ich ne kleine Prozedur erstellt, die ein Sprite mit der
entsprechenden Szene zurück gibt. Damit sind Diashows mit größeren
Schick-Schnack kein problem. (Stichwort "Überblenden" als Beispiel)

Zur veranschaulichung hab ich zusätzlich noch ein kleines Programm
geschrieben, das diese Prozedur nutzt, um eine Diashow in der
einfachsten Form zu zeigen. Die größe des Fensters kann beliebig
verändert werden.

Code:

;die Größe des Fensters kann nach belieben verändert werden
#WindowWidth = 800
#WindowHeight = 300

; ----------------------------------------------------------------------
; ----------------------------------------------------------------------
;ab hier beginnt das Programm selber, Änderungen auf eigene Gefahr *lol*
#MapWidth = 20
#MapHeight = 20
Global Dim Map(#MapWidth - 1, #MapHeight - 1)
#TileWidth = 500
#TileHeight = 500

;Gibt ein Sprite mit der übergebenen Szene zurück
Procedure CreateScene(X, Y, Width, Height, Mode=0)
  Protected TileX.l, TileY.l, DisplayX.l, DisplayY.l
  If X > 0 : X * -1 : EndIf
  If Y > 0 : Y * -1 : EndIf
  If -X > #TileWidth * #MapWidth - #WindowWidth 
    ProcedureReturn #False
  ElseIf -Y > #TileHeight * #MapHeight - #WindowHeight
    ProcedureReturn #False
  EndIf
  
  Sprite = CreateSprite(#PB_Any, Width, Height, Mode)
  If Not Sprite : ProcedureReturn #False : EndIf
  UseBuffer(Sprite)
  
  TileX = Abs(Int(X / #TileWidth))
  TileY = Abs(Int(Y / #TileHeight))
  For DisplayX = X % #TileWidth To Width-1 Step #TileWidth
    For DisplayY = Y % #TileHeight To Height-1 Step #TileHeight
      DisplaySprite(Map(TileX, TileY), DisplayX, DisplayY)
      TileY + 1
    Next
    TileY = Abs(Int(Y / #TileHeight))
    TileX + 1
  Next

  UseBuffer(-1)
  ProcedureReturn Sprite
EndProcedure
; -------------------------------------------------------------

InitSprite()
UsePNGImageDecoder()

MainWindow = OpenWindow(#PB_Any, 0, 0, #WindowWidth, #WindowHeight, "LovePix - Diashow", #PB_Window_Invisible | #PB_Window_SystemMenu | #PB_Window_ScreenCentered)
OpenWindowedScreen(WindowID(MainWindow), 0, 0, #WindowWidth, #WindowHeight, 0, 0, 0)

ProgressWindow = OpenWindow(#PB_Any, 0, 0, 310, 30, "Loading...", #PB_Window_BorderLess |#PB_Window_ScreenCentered)
CreateGadgetList(WindowID(ProgressWindow))
ContainerGadget(#PB_Any, -1, -1, 310, 30, #PB_Container_Raised)
Progress = ProgressBarGadget(#PB_Any, 3, 3, 300, 20, 0, 400)

;laden der Grafiken
x = 0
y = 0
For i = 0 To 399
  While WindowEvent() : Wend
  Map(x, y) = LoadSprite(#PB_Any, "Pic\" + RSet(Str(i+1), 3, "0") + ".png")
  If Not Map(X, Y)
    MessageRequester("Error", "Can't load sprite " + RSet(Str(i+1), 3, "0") + "!")
    End
  EndIf
  x + 1
  If x >= 20 : y + 1 : x = 0 : EndIf
  SetGadgetState(Progress, i + 1)
Next
CloseWindow(ProgressWindow)
HideWindow(MainWindow, #False)

;Hauptschleife
Time = Random(3000) + 1000 ;zufällige Anzeigedauer pro Bild
Timer = ElapsedMilliseconds() - Time
Repeat
  If Timer + Time <= ElapsedMilliseconds()
    Timer = ElapsedMilliseconds()
    Time = Random(3000) + 1000 ;zufällige Anzeigedauer pro Bild

    If Szene : FreeSprite(Szene) : EndIf
    PosX = Random(#TileWidth * #MapWidth - #WindowWidth)
    PosY = Random(#TileHeight * #MapHeight - #WindowHeight)
    Szene = CreateScene(PosX, PosY, #WindowWidth, #WindowHeight)

    DisplaySprite(Szene, 0, 0)
    FlipBuffers()
  EndIf
Until WaitWindowEvent(100) = #PB_Event_CloseWindow

Die Nummerierung der Grafiken hab ich so gemacht, wie Kaeru Gaman
es gerne hätte :wink:

... aber ihr seit ja selber in der Lage, das nach
euren bedürfnissen an zu passen.

Ach ja, noch was. Ist Anstifftung zu einer Straftat nicht schon strafbar?
Ich mein, Copyright verletzten ist ja eine Straftat ...

Wichtig:
Ich möchte hiermit klarstellen, das ich keinen dazu ermuntern möchte die
in diesem Thread thematisierten Grafiken außerhalb der Copyright-
bestimmungen zu nutzten.

MFG PMV

Kaeru Gaman · **Registriert:** 10.11.2004 03:22

mann, is das viel Grafix, meine Graka läuft über...
wollte erst nochn Zoom einbaun, aber dann fehlte das untere drittel.
so geht es, aber bei mir (256MB GraKa) zuckelt es im unteren Bereich.

die doppelt sternchenmakierten stellen beachten, dort sind ggf. änderungen vorzunehmen:
1) Screen-Größe
2) Namenskonvention
3) FrameRate (bei Bedarf)
aber ansonsten nich soviel rumlesen vorher, wer die Bilder hat, einfach mal ausprobieren.

Code:

; **************
; Hier bei Bedarf Screengröße ändern
#ScrnWd = 1280
#ScrnHg = 1024
; **************
#XMid = #ScrnWd/2
#YMid = #ScrnHg/2
InitSprite()
InitKeyboard()
InitMouse()
OpenScreen(#ScrnWd,#ScrnHg,32,"Flyer")
UsePNGImageDecoder()
  ClearScreen($402010)
  StartDrawing(ScreenOutput())
    DrawingMode(4)
    Box(#XMid-202,#YMid-2,404,24,$FFFF00)
  StopDrawing()
  FlipBuffers()
  ClearScreen($402010)
  StartDrawing(ScreenOutput())
    DrawingMode(4)
    Box(#XMid-202,#YMid-2,404,24,$FFFF00)
  StopDrawing()
For n=1 To 400
; **************
; Namenskonvention auswählen
  name$ = Right("00"+Str(n),3)+".png"   ; mit führenden nullen
  ;name$ = Str(n)+".png"                 ; ohne führende nullen
; **************
  LoadSprite(n, name$)
  StartDrawing(ScreenOutput())
    Box(#XMid-200,#YMid,n,20,$FF0000)
  StopDrawing()
  FlipBuffers()
Next
UseBuffer(1)
GrabSprite(0,44,44,320,235)
UseBuffer(-1)
StartDrawing(SpriteOutput(1))
  BckCol = Point(2,2)
  Box(44,44,320,235,BckCol)
StopDrawing()
TransparentSpriteColor(0,BckCol)
XPos = 4080 : YPos = 3240
; **************
; Hier bei Bedarf Framerate einsetzen
;SetFrameRate(60)
; **************
Repeat
  ExamineKeyboard()
;*** Bewegungs-Tasten
  If KeyboardPushed(#PB_Key_Left)  And XMov > -100 : XMov -2 : EndIf
  If KeyboardPushed(#PB_Key_Right) And XMov <  100 : XMov +2 : EndIf
  If KeyboardPushed(#PB_Key_Up)    And YMov > -100 : YMov -2 : EndIf
  If KeyboardPushed(#PB_Key_Down)  And YMov <  100 : YMov +2 : EndIf
  If XMov > 0 : XMov -1 : EndIf
  If XMov < 0 : XMov +1 : EndIf
  If YMov > 0 : YMov -1 : EndIf
  If YMov < 0 : YMov +1 : EndIf
;*** Bewegungs-Verrechnung
  If XMov
    XPos + XMov
    If XPos < 0 : XPos = 200000 : EndIf
    If XPos > 200000 : XPos = 0 : EndIf
  EndIf
  If YMov
    YPos + YMov
    If YPos < 0 : YPos = 200000 : EndIf
    If YPos > 200000 : YPos = 0 : EndIf
  EndIf
;*** Darstellen
  ClearScreen($100804)
  For YC = 0 To 19
    For XC = 0 To 19
      Num = 20 * YC + XC +1
      DisplaySprite(Num,#XMid-XPos/20+500*XC,#YMid-YPos/20+500*YC)
    Next
  Next
  DisplayTransparentSprite(0,#XMid-160,#YMid-118)
  FlipBuffers()
Until KeyboardPushed(#PB_Key_Escape)

ich bin der auffassung, da wir keine kopien der bilder ins netz stellen,
sondern nur open-source-codes, die diese bilder verarbeiten können,
und jeder selber entscheidet, ob er die bilder zieht,
und jeder, der sie zieht, selber entscheidet,
ob er sie nur privat nutzt, mit diesen codes oder wie auch immer,
oder ob er sie weitergeben will,
ist es eigentlich legal was wir hier tun.

wer die bilder woanders zum download anbietet oder sie sonstwie für
nicht rein private zwecke runterlädt, verstößt gegen das copyright.

winduff · **Registriert:** 10.02.2006 21:05 **Wohnort:** Gießen

Jetzt kommst du Sack mir sogar zuvor :mrgreen:

Gute arbeit, btw:

Code:

  ; ************** 
  ; Namenskonvention auswählen 
  ;name$ = Right("00"+Str(n),3)+".png"   ; mit führenden nullen 
  name$ = Str(n)+".png"                 ; ohne führende nullen 
  ; ************** 

n, nicht x

Kaeru Gaman · **Registriert:** 10.11.2004 03:22

oshit... im auskommentierten hab ich vergessen, die Var umzubenennen...
hatte den Term einfach reingepatcht aus der downloadroutine...

> Jetzt kommst du Sack mir sogar zuvor

is mir ein Fest :mrgreen:

wie gesagt, ich hatte es auch mit Zoom schon (fast) fertig,
(nur noch ein mini-bug in den relativen koordinaten),
aber das hat meine Graka leider nicht mitgemacht.
es passen halt nicht alle 400 pics in den Graka-Speicher,
sind ja auch immerhin 400x500x500x32bit = 381,5 MB
wer ne 512MB-Graka hat, kann das durchziehen...

winduff · **Registriert:** 10.02.2006 21:05 **Wohnort:** Gießen

Muss man denn die ganze Map gleich in die Graka laden?

Wäre doch Toll noch Wegpunkte zu setzen, dann nen Pixel-Car schnappen und rumdüsen ^^

Ist klasse sowas zur Vorlage, man kann einiges damit bauen

Auch Geschichten lassen sich daraus erzählen, da passieren Morde / Schießereien / erste Liebe usw usw.

Wer auch immer das designt hat, hat eindeutig zuviel Zeit ...

PMV · **Verfasst:** 08.10.2006 03:32

So ... tada :mrgreen:

... das ganze mit Zoomfaktor und ich denke mal,
auch für schwächere Grafikkarten. Durch #PB_Sprite_Memory werden
alle Grafiken in den RAM-Speicher geladen, aber wehe es hat wer nicht
genug RAM. :wink:

Benötigter RAM:

Kaeru Gaman hat geschrieben:

400x500x500x32bit = 381,5 MB

bei #WidthoutAA = 1 werden auch die 4 Grafiken, welche für das zoomen
benutzt werden in den RAM geladen. Wenn mich nicht alles teuscht wäre
die Berechnung dann folgende: 800 x 600 x 32 = 14,65 MB
Beim Zoomen müsste der Wert dann Quadratisch zum Zoomfaktor
steigen. Ich habs mit meiner Geforce 7600 über den Zoom von 1100%
geschaft: 800 x 600 x 32 x 11² = 1772 MB :shock:

Aber die FPS gehen sofort beim rauszoomen runter -.-, am Ende sinds
2-3 FPS ...

PB-BUG:
Naja, genug Mathe ... Bei mir ergibt

Code:

If Zoom >= #ZoomStep

selbst bei gleichen Werten ein nicht eintrehten des Ereignisses, wodurch
man dann plötzlich eine 1 an der letzten Stelle hat -.-
Selbst das * 100 und dann mit Int() arbeiten hat nicht funktioniert.

Edit:
kleine optimierung des Ramverbrauchs.
Die 4 Ausschnitte werden nun fürs Rauszoomen nacheinander Berechnet,
dadurch sinkt der RAM-Verbrauch erheblich. (Rechnung mach ich
vielleicht später zu) Max. auf 1250% zoomen, das ist die ganze Karte
:wink:

... eine Beschränkung mach ich da jetzt extra für nicht rein.

So, jetzt aber der Code ... ist nicht besonders Übersichtlich, aber es ist
viel zu Spät um weiter drann zu arbeiten ... vielleicht irgend wann die
Tage mal wieder:

Code:

EnableExplicit

;die Größe des Fensters kann nach belieben verändert werden
#ScreenWidth = 800
#ScreenHeight = 600

;Startposition auf der Map
#StartX = 3000  ; >= 0 Und < 10000 - #ScreenWidth * Zoom
#StartY = 1000  ; >= 0 Und < 10000 - #ScreenHeight * Zoom 

#WidthoutAA = 0 ; 0 oder 1  -> ein- oder ausschalten des AA 
;WICHTIG!!!!
;bei ausgeschalteter AA werden die großen Grafiken in den 
;Hauptspeicher gelegt!

#ScrollArea = 20          ;in Pixel
Global ScrollSpeed.f=0.1 ;pro Millisekunde (bei 100% Zoomfaktor)
Global Zoom.f = 1.0      ;in Prozent
#ZoomStep = 0.1           ;in Prozent

; ----------------------------------------------------------------------
; ----------------------------------------------------------------------
;ab hier beginnt das Programm selber, Änderungen auf eigene Gefahr *lol*
#MapWidth = 20
#MapHeight = 20
#TileWidth = 500
#TileHeight = 500

Global Sprite_LU.l, Sprite_RU.l, Sprite_LD.l, Sprite_RD.l
Global Dim Map(#MapWidth - 1, #MapHeight - 1)


Macro DisplayMapScene()
  TileX = Abs(Int(X / #TileWidth))
  TileY = Abs(Int(Y / #TileHeight))
  For DisplayX = X % #TileWidth To Width-1 Step #TileWidth
    For DisplayY = Y % #TileHeight To Height-1 Step #TileHeight
      DisplaySprite(Map(TileX, TileY), DisplayX, DisplayY)
      TileY + 1
    Next
    TileY = Abs(Int(Y / #TileHeight))
    TileX + 1
  Next
EndMacro


Macro ResizeError(Text)
 CloseScreen():MessageRequester("ResizeSprite - Error", Text):End
EndMacro

;folgende Prozedur ist für das Zoomen nötig, aber nicht von mir:
; 02 Nov 2004 10:54:59          © by Stefan - deutsches PB-Forum
; http://forums.purebasic.com/german/viewtopic.php?t=605&start=0#DDBLT_WAIT=16777216 
#DDBLT_WAIT=16777216 
Structure PB_Sprite 
  Sprite.l 
  Width.w 
  Height.w 
  Depth.w 
  Mode.w 
  FileName.l 
  RealWidth.w 
  RealHeight.w 
  ClipX.w 
  ClipY.w 
EndStructure 
Procedure ResizeSprite(Sprite,Width,Height);Gibt bei Fehlern 0 zurück. 
  Protected *Sprite.PB_Sprite, *DDS.IDirectDrawSurface7, *DD.IDirectDraw7
  Protected *DDS2.IDirectDrawSurface7, rect.rect, DDSD.l
  
  If Width<=0 Or Height<=0:ProcedureReturn 0:EndIf 
  
  *Sprite.PB_Sprite=IsSprite(Sprite) 
  If *Sprite=0:ResizeError("Not a pb-sprite!"):EndIf 
  
  *DDS.IDirectDrawSurface7=*Sprite\Sprite 
  If *DDS=0:ResizeError("Not enought memory!"):EndIf 
  
  *DDS\GetDDInterface(@*DD.IDirectDraw7) 
  If *DD=0:ResizeError("GetInterface() faild!"):EndIf 
  
  DDSD=AllocateMemory(124) 
  If DDSD=0:ResizeError("Not enought memory!"):EndIf 
  
  PokeL(DDSD,124) 
  If *DDS\GetSurfaceDesc(DDSD):FreeMemory(DDSD):ResizeError("GetSurfaceDesc() faild!"):EndIf 
  PokeL(DDSD+8,Height) 
  PokeL(DDSD+12,Width) 
  
  If *DD\CreateSurface(DDSD,@*DDS2.IDirectDrawSurface7,0):FreeMemory(DDSD):ResizeError("CreateSurface() faild!"):EndIf 
  
  rect\left=0 
  rect\right=Width 
  rect\top=0 
  rect\bottom=Height 
  If *DDS2\Blt(rect,*DDS,0,#DDBLT_WAIT,0):FreeMemory(DDSD):*DDS\Release():ResizeError("Blt() faild!"):EndIf 
  
  FreeMemory(DDSD) 
  *DDS\Release() 
  *Sprite\Sprite=*DDS2 
  *Sprite\Width=Width 
  *Sprite\Height=Height 
  *Sprite\RealWidth=Width 
  *Sprite\RealHeight=Height 
  *Sprite\ClipX=0 
  *Sprite\ClipY=0 
  ProcedureReturn *DDS2 
EndProcedure 
; --------------------------------------------

;zeichnet die Karte an der aktuellen Position mit dem aktuellen Zoomfaktor
Procedure DisplayMap(X, Y, Width, Height)
  Protected MapX.l, MapY.l, TileX.l, TileY.l, DisplayX.l, DisplayY.l
  ;größer als 1
  If Zoom > 1
    Width / 2
    Height / 2
    MapX = -X
    MapY = -Y

    ;Ausschnitt links oben
    ResizeSprite(Sprite_LU, Width, Height) ;Sprites auf die richtige Größe bringen
    X = MapX
    Y = MapY
    UseBuffer(Sprite_LU);Karte auf die angepassten Sprites zeichnen  
      DisplayMapScene()
    ResizeSprite(Sprite_LU, #ScreenWidth/2, #ScreenHeight/2);Sprites wieder an den Screen anpassen
  
    ;Ausschnitt rechts oben
    ResizeSprite(Sprite_RU, Width, Height)
    X = MapX - Width
    Y = MapY
    UseBuffer(Sprite_RU)
      DisplayMapScene()
    ResizeSprite(Sprite_RU, #ScreenWidth/2, #ScreenHeight/2)

    ;Ausschnitt links unten
    ResizeSprite(Sprite_LD, Width, Height)
    X = MapX
    Y = MapY - Height
    UseBuffer(Sprite_LD)
      DisplayMapScene()
    ResizeSprite(Sprite_LD, #ScreenWidth/2, #ScreenHeight/2)

    ;Ausschnitt rechts oben
    ResizeSprite(Sprite_RD, Width, Height)
    X = MapX - Width
    Y = MapY - Height
    UseBuffer(Sprite_RD)
      DisplayMapScene()
    ResizeSprite(Sprite_RD, #ScreenWidth/2, #ScreenHeight/2)

    UseBuffer(-1)
  
    ;Sprites wieder an den Screen anpassen
    ResizeSprite(Sprite_LU, #ScreenWidth/2, #ScreenHeight/2)
    ResizeSprite(Sprite_RU, #ScreenWidth/2, #ScreenHeight/2)
    ResizeSprite(Sprite_LD, #ScreenWidth/2, #ScreenHeight/2)
    ResizeSprite(Sprite_RD, #ScreenWidth/2, #ScreenHeight/2)

    ;Sprites auf den Screen zeichnen
    DisplaySprite(Sprite_LU, 0, 0)
    DisplaySprite(Sprite_RU, #ScreenWidth/2, 0)
    DisplaySprite(Sprite_LD, 0, #ScreenHeight/2)
    DisplaySprite(Sprite_RD, #ScreenWidth/2, #ScreenHeight/2)
  
  ElseIf Zoom = 1
    X = -X
    Y = -Y
    DisplayMapScene()
  Else ; Zoom < 1    
    X = -X
    Y = -Y
    ResizeSprite(Sprite_LU, Width, Height)
    UseBuffer(Sprite_LU)
      DisplayMapScene()
    UseBuffer(-1)
    ResizeSprite(Sprite_LU, #ScreenWidth, #ScreenHeight)
    DisplaySprite(Sprite_LU, 0, 0)
  EndIf
  
EndProcedure


;Gibt ein Sprite mit der übergebenen Szene zurück
Procedure CreateScene(X, Y, Width, Height, Mode=0)
  Protected Sprite, TileX.l, TileY.l, DisplayX.l, DisplayY.l
  If X > 0 : X * -1 : EndIf
  If Y > 0 : Y * -1 : EndIf
  If -X > #TileWidth * #MapWidth - #ScreenWidth 
    ProcedureReturn #False
  ElseIf -Y > #TileHeight * #MapHeight - #ScreenHeight
    ProcedureReturn #False
  EndIf
  
  Sprite = CreateSprite(#PB_Any, Width, Height, Mode)
  If Not Sprite : ProcedureReturn #False : EndIf
  UseBuffer(Sprite)
    TileX = Abs(Int(X / #TileWidth))
    TileY = Abs(Int(Y / #TileHeight))
    For DisplayX = X % #TileWidth To Width-1 Step #TileWidth
      For DisplayY = Y % #TileHeight To Height-1 Step #TileHeight
        DisplaySprite(Map(TileX, TileY), DisplayX, DisplayY)
        TileY + 1
      Next
      TileY = Abs(Int(Y / #TileHeight))
      TileX + 1
    Next
  UseBuffer(-1)
  ProcedureReturn Sprite
EndProcedure
; -------------------------------------------------------------

InitSprite()
InitKeyboard()
InitMouse()
UsePNGImageDecoder()
If Not OpenScreen(#ScreenWidth, #ScreenHeight, 32, "")
  MessageRequester("Error", "Can't open screen! (" + Str(#ScreenWidth) + " X " + Str(#ScreenHeight))
  End
EndIf


;laden der Grafiken
Define X.l, Y.l, i.l, Text$
x = 0
y = 0
For i = 0 To 399
  ExamineKeyboard()
  If KeyboardPushed(#PB_Key_All) <> #False : End : EndIf

  Map(x, y) = LoadSprite(#PB_Any, "Pic" + RSet(Str(i+1), 3, "0") + ".png", #PB_Sprite_Memory)
  If Not Map(X, Y)
    CloseScreen()
    MessageRequester("Error", "Can't load sprite " + RSet(Str(i+1), 3, "0") + "!")
    End
  EndIf
  x + 1
  If x >= 20 : y + 1 : x = 0 : EndIf
  
  Text$ = StrF((i+1) / 400 * 100, 0) + "%"
  StartDrawing(ScreenOutput())
    DrawingMode(#PB_2DDrawing_Default)
    Box(#ScreenWidth/2 - 103, #ScreenHeight/2 - 11, 206, 22, RGB(113, 2, 0))
    Box(#ScreenWidth/2 - 100, #ScreenHeight/2 - 7, ((i+1)/2), 14, RGB(162, 3, 0))
    DrawingMode(#PB_2DDrawing_Transparent | #PB_2DDrawing_XOr)
    DrawText(#ScreenWidth/2 - TextWidth(Text$)/2, #ScreenHeight/2 - TextHeight(Text$)/2, Text$, $f0f0f0f0)
  StopDrawing()
  FlipBuffers()

Next

Define.l Sprite, Timer
Define.f MapX, MapY
MapX = #StartX
MapY = #StartY

Sprite = CreateScene(MapX, MapY, #ScreenWidth, #ScreenHeight, #PB_Sprite_Memory)
Timer = ElapsedMilliseconds()
Repeat
  ExamineKeyboard()
  If KeyboardPushed(#PB_Key_All) <> #False : End : EndIf

  ClearScreen(0)
  StartSpecialFX()
    DisplayTranslucentSprite(Sprite, 0, 0, 255 * (ElapsedMilliseconds() - Timer) / 5000)
  StopSpecialFX()
  FlipBuffers()
Until Timer + 1000 <= ElapsedMilliseconds()
FreeSprite(Sprite)

Define.l LoopTime, MapX, MapY, FPSCounter, FPS, FPSTimer
Timer = ElapsedMilliseconds()
Sprite_LU = CreateScene(0, 0, #ScreenWidth/2, #ScreenHeight/2, #WidthoutAA * #PB_Sprite_Memory)
Sprite_RU = CreateScene(#ScreenWidth/2, 0, #ScreenWidth/2, #ScreenHeight/2, #WidthoutAA * #PB_Sprite_Memory)
Sprite_LD = CreateScene(0, #ScreenHeight/2, #ScreenWidth/2, #ScreenHeight/2, #WidthoutAA * #PB_Sprite_Memory)
Sprite_RD = CreateScene(#ScreenWidth/2, #ScreenHeight/2, #ScreenWidth/2, #ScreenHeight/2, #WidthoutAA * #PB_Sprite_Memory)
MouseLocate(#ScreenWidth/2, #ScreenHeight/2)
Repeat
  ;Mausereignisse  
  ExamineMouse()
  ;bewegen in der Umgebung indem die Maus an den Rand bewegt wird
  If MouseX() < #ScrollArea
    If MouseY() < #ScrollArea
      MapX = MapX - LoopTime * ScrollSpeed/2
      MapY = MapY - LoopTime * ScrollSpeed/2
      If MapY < 0 : MapY = 0 : EndIf
    ElseIf MouseY() > #ScreenHeight - #ScrollArea
      MapX = MapX - LoopTime * ScrollSpeed/2
      MapY = MapY + LoopTime * ScrollSpeed/2
      If MapY > #TileHeight * #MapHeight - #ScreenHeight * Zoom : MapY = #TileHeight * #MapHeight - #ScreenHeight * Zoom : EndIf
    Else
      MapX = MapX - LoopTime * ScrollSpeed
    EndIf
    If MapX < 0 : MapX = 0 : EndIf

  ElseIf MouseX() > #ScreenWidth - #ScrollArea
    If MouseY() < #ScrollArea
      MapX = MapX + LoopTime * ScrollSpeed/2
      MapY = MapY - LoopTime * ScrollSpeed/2
      If MapY < 0 : MapY = 0 : EndIf
    ElseIf MouseY() > #ScreenHeight - #ScrollArea
      MapX = MapX + LoopTime * ScrollSpeed/2
      MapY = MapY + LoopTime * ScrollSpeed/2
      If MapY > #TileHeight * #MapHeight - #ScreenHeight  * Zoom: MapY = #TileHeight * #MapHeight - #ScreenHeight * Zoom : EndIf
    Else
      MapX = MapX + LoopTime * ScrollSpeed
    EndIf
    If MapX > #TileWidth * #MapWidth - #ScreenWidth * Zoom : MapX = #TileWidth * #MapWidth - #ScreenWidth * Zoom : EndIf

  ElseIf MouseY() < #ScrollArea
    MapY = MapY - LoopTime * ScrollSpeed
    If MapY < 0 : MapY = 0 : EndIf

  ElseIf MouseY() > #ScreenHeight - #ScrollArea
    MapY = MapY + LoopTime * ScrollSpeed
    If MapY > #TileHeight * #MapHeight - #ScreenHeight * Zoom : MapY = #TileHeight * #MapHeight - #ScreenHeight * Zoom : EndIf
  EndIf
  
  ;Zoomfaktor per Mausrad
  i = -MouseWheel()
  While i 
    If i > 0
      ;-PB-BUG
      ;If Int(Zoom*100) >= Int(#ZoomStep*100)
      If Zoom >= #ZoomStep
        ScrollSpeed * (1 + #ZoomStep)
        Zoom + #ZoomStep
        MapX - #ZoomStep/2 * #ScreenWidth
        MapY - #ZoomStep/2 * #ScreenHeight
      Else
        ScrollSpeed * (1 + #ZoomStep/10)
        Zoom + #ZoomStep/10
        MapX - #ZoomStep/20 * #ScreenWidth
        MapY - #ZoomStep/20 * #ScreenHeight
      EndIf
      If MapX < 0 : MapX = 0 : EndIf
      If MapY < 0 : MapY = 0 : EndIf
      If MapY > #TileHeight * #MapHeight - #ScreenHeight * Zoom : MapY = #TileHeight * #MapHeight - #ScreenHeight * Zoom : EndIf
      If MapX > #TileWidth * #MapWidth - #ScreenWidth * Zoom : MapX = #TileWidth * #MapWidth - #ScreenWidth * Zoom : EndIf
      i - 1
    ElseIf i < 0 
      If Zoom > #ZoomStep
        ScrollSpeed / (1 + #ZoomStep)
        Zoom - #ZoomStep
        MapX + #ZoomStep/2 * #ScreenWidth
        MapY + #ZoomStep/2 * #ScreenHeight
      ElseIf Zoom > #ZoomStep/10
        ScrollSpeed / (1 + #ZoomStep / 10)
        Zoom - #ZoomStep/10
        MapX + #ZoomStep/20 * #ScreenWidth
        MapY + #ZoomStep/20 * #ScreenHeight
      EndIf
      i + 1
    EndIf
  Wend
  
  ;Karte anzeigen
  DisplayMap(MapX, MapY, #ScreenWidth * Zoom, #ScreenHeight * Zoom)
  
  FPSCounter + 1 
  If ElapsedMilliseconds() >= FPSTimer + 1000 : FPS = FPSCounter : FPSCounter = 0 : FPSTimer = ElapsedMilliseconds() : EndIf 

  ;GUI
  StartDrawing(ScreenOutput())
    DrawingMode(1)
    DrawText(5, 5, "FPS: " + Str(FPS))
    DrawText(75, 5, "Zoom: " + Str(Zoom * 100) + " %")
    Circle(MouseX(), MouseY(), 2, $FFFFFF)
  StopDrawing()
  FlipBuffers()
  
  ;Zeitberechnung
  LoopTime = ElapsedMilliseconds() - Timer
  Timer = ElapsedMilliseconds()
  
  ;Tastatur, per Any-Key aus dem ganzen raus gehen
  ExamineKeyboard()
Until KeyboardPushed(#PB_Key_All) <> #False

Ach ja, gesteuert wird mit der Maus. Das heißt an die Ränder bewegen
oder das Mausrad benutzten zum zoomen. Eigentlich wollt ich noch das
Scrollen beschleunigen, wenn man dem Rand näher kommt, aber keine
Zeit^^
Ok, Tastatur ist auch drinne, aber nur für die Any-Key ... zum beenden.

Also ... viel Spaß damit

Wichtig:
Benutzung des Programmes nur für private Zwecke. Die benötigten Bilder
dürfen nicht mit dem obigen Code weiter verbreitet werden, sofern diese
durch ein Copyright geschützt sind, so wie es für die Grafiken der
verlinkten Seite dieses Threads der Fall ist!

MFG PMV

Kaeru Gaman · **Registriert:** 10.11.2004 03:22

interessant... und sehr kryptisch....

also, du verwendest DirectDraw-Objekte zum resizen?

puh... is ja kaum zu durchschaun...

ich hatte es halt über Sprite3D versucht, aber wie gesagt,
da ist die datenmenge einfach zu groß für GraKas < 512MB.

PMV · **Verfasst:** 08.10.2006 16:22

Ich hatte mal vor nen paar Monaten wegen eines anderen Projektes das
ganze ausprobiert ... Sprite3D hat halt den nachteil, dass es nicht mehr
auf älteren Rechnern läuft. (mal von der Datenmenge abgesehen)
Bei niedrigen Auflösungen könnte das ganze so durchaus auch auf Älteren
funktionieren.
Sprite3D ist aber um einiges schneller, sofern die Hardware überhaupt
mitmacht :lol:

. Zumindest hab ich eine Roution geschrieben gehabt für
ein aktuelles Projekt, welche mit einer der zwei Möglich (kann ausgewählt
werden) die original Auflösung an jede beliebige andere Auflösung
anpasst. Sprite3D ist auf meinen PC hier ca. 40% schneller.

Fals ich die Tage noch mal ein zwei Stunden zeit hab kann ich ja die
Sprite3D Lösung mit einbauen und das ganze mal etwas übersichtlicher
mache. Aber ich denke, der Code oben ist noch so grad an der Grenze
des vertrehtbaren :lol:

MFG PMV

PureBoard

Zu viel vorm Bildschirm gesessen?

Wer ist online?