first commit

pacman-project/coin.rkt

@@ -0,0 +1,39 @@
+#lang r7rs
+
+(define-library (pacman-project coin)
+  (import (scheme base)
+          (pp1 graphics)
+          (pacman-project screen)
+          (pacman-project maze))
+
+  (export draw-coins!
+          remove-coin!)
+
+  (begin
+
+    (define coin-size-offset 20)
+
+    (define coins-layer (make-new-layer!))
+    (define coin-tile (make-tile screen-width screen-height))
+    ((coins-layer 'add-drawable!) coin-tile)
+
+    ;tekent de muntjes
+    (define (draw-coins!)
+      (do ((row 0 (+ row 1)))
+        ((= row maze-rows))
+        (do ((col 0 (+ col 1)))
+          ((= col maze-cols))
+          (when (cell-coin? row col)
+            ((coin-tile 'draw-rectangle!)
+             (+ (* col cell-size) 7)
+             (+ (* row cell-size) maze-offset-y 7)
+             (- cell-size coin-size-offset)
+             (- cell-size coin-size-offset)
+             "yellow")))))
+
+    (draw-coins!)
+
+    ;muntjes verwijderen 
+    (define (remove-coin! row col)
+      ((coin-tile 'clear!)) ;alle coins verwijderen en alleen de coins die niet verwijderdt zijn tekenen 
+      (draw-coins!))))

pacman-project/game-logic.rkt

@@ -0,0 +1,70 @@
+#lang r7rs
+
+; Game-logic ; 
+
+
+(define-library (pacman-project game-logic)
+  (import (scheme base)
+          (pacman-project maze)
+          (pacman-project pacman)
+          (pacman-project coin)
+          (pacman-project key)
+          (pacman-project score)
+          (pacman-project time-limit))
+
+  (export move-pacman!)
+
+  (begin
+
+    (define key-taken? #f)
+
+    ;muntje opeten
+    (define (eat-coin! row col)
+      (cell-set! row col 2)
+      (remove-coin! row col))
+
+    ;sleutel oppakem
+    (define (take-key! row col)
+      (cell-set! row col 2)
+      (set! key-taken? #t)
+      (remove-key!))
+
+    ;beweegt pacman en checkt voor muren, muntjes, sleutels etc.
+    (define (move-pacman! x y)
+      (when (not (time-up?))
+        (let* ((cur-x (pacman-x))
+               (cur-y (pacman-y))
+               (next-x (+ cur-x x))
+               (next-y (+ cur-y y))
+               (grid-col (quotient next-x cell-size))
+               (grid-row (quotient (- next-y maze-offset-y) cell-size)))
+
+          (cond
+            ;van links naar rechts
+            ((< grid-col 0)
+             (set-pacman-x! (* (- maze-cols 1) cell-size))
+             (set-pacman-y! next-y))
+
+            ;van rechts naar links
+            ((>= grid-col maze-cols)
+             (set-pacman-x! 0)
+             (set-pacman-y! next-y))
+
+            ;als het een deur is openen we de deur
+            ((cell-door? grid-row grid-col)
+             (when key-taken?
+               (remove-door! grid-row grid-col)))
+
+            ;normale beweging
+            (else
+             (when (not (cell-wall? grid-row grid-col))
+               (set-pacman-x! next-x)
+               (set-pacman-y! next-y)
+               ;om te zien wat er op de volgende pos staat
+               (cond
+                 ((cell-key? grid-row grid-col)
+                  (take-key! grid-row grid-col))
+                 ((cell-coin? grid-row grid-col)
+                  (eat-coin! grid-row grid-col)
+                  (update-time-limit!)
+                  (update-score!)))))))))))

pacman-project/game.rkt

@@ -0,0 +1,19 @@
+#lang r7rs
+
+; Game ;
+
+(define-library (pacman-project game)
+  (import (scheme base)
+          (pacman-project score)
+          (pacman-project time-limit)
+          (pacman-project keyboard-handler)
+          (pacman-project main-loop)
+          (pacman-project test))
+ 
+  (begin
+    ;om het spel op te starten
+    (start-main-loop!)
+    (start-keyboard-handler!)
+    (draw-score!)
+    (draw-time-limit!)))
+ 

pacman-project/game.rkt~

@@ -0,0 +1,19 @@
+#lang r7rs
+
+; Game ;
+
+(define-library (pacman-project game)
+  (import (scheme base)
+          (pacman-project score)
+          (pacman-project time-limit)
+          (pacman-project keyboard-handler)
+          (pacman-project main-loop)
+          (pacman-project test))
+ 
+  (begin
+    ;om het spel op te starten
+    (start-main-loop!)
+    (start-keyboard-handler!)
+    (draw-score!)
+    (draw-time-limit!)))
+ 

pacman-project/key.rkt

@@ -0,0 +1,60 @@
+#lang r7rs
+
+(#%require (only racket/base random))
+
+
+; Key ADT ;
+
+(define-library (pacman-project key)
+  (import (scheme base)
+          (pp1 graphics)
+          (pacman-project screen)
+          (pacman-project maze)
+          (pacman-project coin))
+
+  (export draw-key!
+          remove-key!)
+
+  (begin
+
+    (define key-layer (make-new-layer!))
+
+    ;bitmap voor de sleutel
+    (define key (make-bitmap-tile "pacman-sprites/key.png"))
+    ((key 'set-scale!) 1.5)
+    ((key-layer 'add-drawable!) key)
+
+    ;sleutel naast de score tekenen
+    (define taken-key (make-bitmap-tile "pacman-sprites/key.png"))
+    ((taken-key 'set-scale!) 3)
+    ((taken-key 'set-x!) 20)
+    ((taken-key 'set-y!) 35)
+
+    
+      
+    ;de sleutel op een random positie in het doolhof plaatsen 
+    (define (place-key-at-random-position!)
+      (let loop ((attempts 0)) ;attempts is het aantal keer dat er een key geplaats wordt.
+        ;dit wordt gedaan zodat er geen herhaling is bij het plaatsen van keys
+        (if (>= attempts 1000)
+            (error "valid position not found") ;
+            (let ((col (random 0 maze-cols))
+                  (row (random 0 maze-rows)))
+              (if (cell-coin? row col) ;als de cell een valid cell is (dus de plek waar een coin kan komen)
+                  (begin
+                    ((key 'set-x!) (* cell-size col))
+                    ((key 'set-y!) (+ (* row cell-size) maze-offset-y))
+                    (cell-set! row col 3)
+                    (remove-coin! row col))
+                  (loop (+ attempts 1)))))))
+
+    ;sleutel tekenen
+    (define (draw-key!)
+      (place-key-at-random-position!))
+
+    (draw-key!)
+
+    ;sleutel verwijderen en aanduiden dat de sleutel gepakt werd
+    (define (remove-key!)
+      ((key-layer 'remove-drawable!) key)
+      ((key-layer 'add-drawable!) taken-key))))

pacman-project/keyboard-handler.rkt

@@ -0,0 +1,52 @@
+#lang r7rs
+
+; Keyboard-handler ; 
+
+
+(define-library (pacman-project keyboard-handler)
+  (import (scheme base)
+          (scheme write)
+          (pacman-project screen)
+          (pacman-project maze)
+          (pacman-project pacman)
+          (pacman-project game-logic)
+          (pacman-project pause-menu)
+          (pacman-project main-loop))
+
+  (export start-keyboard-handler!)
+
+  (begin
+
+    ;toetsen te beheren
+    (define (handle-keyboard! state key)
+      (when (eq? state 'pressed)
+        (cond
+          ((eq? key 'escape)
+           (if (not (paused?))
+               (begin
+                 (set-paused! #t)
+                 (stop-main-loop!)
+                 (draw-pause-menu!))
+               (begin
+                 (remove-pause-menu!)
+                 (set-paused! #f)
+                 (start-main-loop!))))
+          ((not (paused?))
+           (let ((cell cell-size))
+             (cond
+               ((eq? key 'right)
+                (move-pacman! cell 0)
+                (rotate-pacman! 'right))
+               ((eq? key 'left)
+                (move-pacman! (- cell) 0)
+                (rotate-pacman! 'left))
+               ((eq? key 'up)
+                (move-pacman! 0 (- cell))
+                (rotate-pacman! 'up))
+               ((eq? key 'down)
+                (move-pacman! 0 cell)
+                (rotate-pacman! 'down))))))))
+
+    ;zodat de keyboard geconnecteert is met het spelscherm 
+    (define (start-keyboard-handler!)
+      ((screen 'set-key-callback!) handle-keyboard!))))

pacman-project/main-loop.rkt

@@ -0,0 +1,30 @@
+#lang r7rs
+
+; Main loop ADT ;
+
+(define-library (pacman-project main-loop)
+  (import (scheme base)
+          (pacman-project screen)
+          (pacman-project pacman)
+          (pacman-project time-limit))
+
+  (export start-main-loop!
+          stop-main-loop!)
+
+  (begin
+ 
+    ;stopt de game-loop
+    (define (stop-main-loop!)
+      ((screen 'set-update-callback!)
+       (lambda (ms) (values))))
+
+    ;start de game-loop 
+    (define (start-main-loop!)
+      ((screen 'set-update-callback!)
+       (lambda (ms)
+         (cond
+           ((time-up?) ;wanneer de tijd om is stopt het spel
+            (stop-main-loop!))
+           (else
+            (animate-pacman! ms)
+            (decrease-time-limit! ms))))))))

pacman-project/maze.rkt

@@ -0,0 +1,128 @@
+#lang r7rs
+
+; Maze ADT ;
+
+
+(define-library (pacman-project maze)
+  (import (scheme base)
+          (pp1 graphics)
+          (pacman-project screen))
+
+  (export maze-rows
+          maze-cols
+          cell-size
+          maze-offset-y
+          cell-ref
+          cell-set!
+          cell-wall?
+          cell-coin?
+          cell-empty?
+          cell-key?
+          cell-door?
+          draw-maze!
+          remove-door!)
+
+  (begin
+
+    ;conmstanten
+    (define cell-size 24)
+    (define maze-offset-y 97)  ;offsets om de maze mooi te kunnen plaatsen 
+    (define maze-size-offset 6)
+
+    ;we maken een maze aan van 31 rijen x 28 kolommen
+    ;vector ipv #() omda vector mutable is en #() ni.
+
+    ;0 = muntje 
+    ;1 = muur   
+    ;2 = leeg   
+    ;3 = sleutel 
+    ;4 = deur   
+    (define maze
+      (vector (vector 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+              (vector 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1)
+              (vector 1 0 1 1 1 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 0 1 1 1 1 0 1)
+              (vector 1 0 1 0 0 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 0 1 1 1 1 0 1)
+              (vector 1 0 1 4 1 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 0 1 1 1 1 0 1)
+              (vector 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1)
+              (vector 1 0 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 1 0 1 1 0 1 1 1 1 0 1)
+              (vector 1 0 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 1 0 1 1 0 1 1 1 1 0 1)
+              (vector 1 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 0 1)
+              (vector 1 1 1 1 1 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 0 1 1 1 1 1 1)
+              (vector 2 2 2 2 2 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 0 1 2 2 2 2 2)
+              (vector 2 2 2 2 2 1 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 1 2 2 2 2 2)
+              (vector 2 2 2 2 2 1 0 1 1 0 1 1 1 4 4 1 1 1 0 1 1 0 1 2 2 2 2 2)
+              (vector 1 1 1 1 1 1 0 1 1 0 1 2 2 2 2 2 2 1 0 1 1 0 1 1 1 1 1 1)
+              (vector 2 0 0 0 0 0 0 0 0 0 1 2 2 2 2 2 2 1 0 0 0 0 0 0 0 0 0 2)
+              (vector 1 1 1 1 1 1 0 1 1 0 1 2 2 2 2 2 2 1 0 1 1 0 1 1 1 1 1 1)
+              (vector 2 2 2 2 2 1 0 1 1 0 1 1 1 1 1 1 1 1 0 1 1 0 1 2 2 2 2 2)
+              (vector 2 2 2 2 2 1 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 1 2 2 2 2 2)
+              (vector 2 2 2 2 2 1 0 1 1 0 1 1 1 1 1 1 1 1 0 1 1 0 1 2 2 2 2 2)
+              (vector 1 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1)
+              (vector 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1)
+              (vector 1 0 1 1 1 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 0 1 1 1 1 0 1)
+              (vector 1 0 1 1 1 1 0 1 1 1 1 1 0 1 1 0 1 1 1 1 1 0 1 1 1 1 0 1)
+              (vector 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1)
+              (vector 1 1 1 0 1 1 0 1 1 0 1 1 1 1 1 1 1 1 0 1 1 0 1 1 0 1 1 1)
+              (vector 1 1 1 0 1 1 0 1 1 0 1 1 1 1 1 1 1 1 0 1 1 0 1 1 0 1 1 1)
+              (vector 1 0 0 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 4 1 0 0 0 0 0 0 1)
+              (vector 1 0 1 1 1 1 1 1 1 1 1 1 0 1 1 0 1 1 1 0 0 1 1 1 1 1 0 1)
+              (vector 1 0 1 1 1 1 1 1 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 1 1 1 0 1)
+              (vector 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1)
+              (vector 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))
+
+    (define maze-rows (vector-length maze))
+    (define maze-cols (vector-length (vector-ref maze 0)))
+
+
+    ;geeft waarde terug v/e cell
+    (define (cell-ref row col)
+      (vector-ref (vector-ref maze row) col))
+
+    ;past waarde aan v/e cell
+    (define (cell-set! row col value)
+      (vector-set! (vector-ref maze row) col value))
+
+    (define (cell-wall? row col)
+      (= (cell-ref row col) 1))
+
+    (define (cell-coin? row col)
+      (= (cell-ref row col) 0))
+
+    (define (cell-empty? row col)
+      (= (cell-ref row col) 2))
+
+    (define (cell-key? row col)
+      (= (cell-ref row col) 3))
+
+    (define (cell-door? row col)
+      (= (cell-ref row col) 4))
+
+
+    (define maze-layer (make-new-layer!))
+    (define maze-tile (make-tile screen-width screen-height))
+    ((maze-layer 'add-drawable!) maze-tile)
+
+    ;tekent de maze
+    (define (draw-maze!)
+      (do ((row 0 (+ row 1)))
+        ((= row maze-rows))
+        (do ((col 0 (+ col 1)))
+          ((= col maze-cols))
+          (let ((cell (cell-ref row col)))
+            (cond
+              ((= cell 1)
+               ((maze-tile 'draw-rectangle!) (* col cell-size) (+ (* row cell-size) maze-offset-y) (- cell-size maze-size-offset) (- cell-size maze-size-offset) "blue"))
+              ((= cell 4)
+               ((maze-tile 'draw-rectangle!) (* col cell-size) (+ (* row cell-size) maze-offset-y) (- cell-size maze-size-offset) (- cell-size maze-size-offset) "pink"))))))) ;we tekenen hier ook de deuren aangezien ze deel uitmaken van de maze
+
+    (draw-maze!)
+
+    ;verwijdert een deur uit de maze 
+    (define (remove-door! row col)
+      (cell-set! row col 2)
+      ((maze-tile 'draw-rectangle!)
+       (* col cell-size)
+       (+ (* row cell-size) maze-offset-y)
+       (- cell-size maze-size-offset)
+       (- cell-size maze-size-offset)
+       "black"))))

pacman-project/pacman.rkt

@@ -0,0 +1,69 @@
+#lang r7rs
+
+; Pacman ADT ; 
+
+
+(define-library (pacman-project pacman)
+  (import (scheme base)
+          (pp1 graphics)
+          (pacman-project screen)
+          (pacman-project maze))
+
+  (export pacman-x
+          pacman-y
+          set-pacman-x!
+          set-pacman-y!
+          animate-pacman!
+          rotate-pacman!)
+
+  (begin
+
+    (define time-since-last-animation 0)
+    (define animation-interval 100)
+
+    (define pacman-layer (make-new-layer!))
+
+    ;bitmap-sequence voor pacman 
+    (define pacman-bitmap-tiles
+      (list (make-bitmap-tile "pacman-sprites/pacman-death-1.png")
+            (make-bitmap-tile "pacman-sprites/pacman-closed.png")
+            (make-bitmap-tile "pacman-sprites/pacman-open.png")))
+
+    (define pacman-sprite (make-tile-sequence pacman-bitmap-tiles))
+    ((pacman-sprite 'set-scale!) 1.5)
+    ((pacman-layer 'add-drawable!) pacman-sprite)
+
+    ;start-positie van pacman
+    ((pacman-sprite 'set-x!) (* 2 cell-size))
+    ((pacman-sprite 'set-y!) (+ (* 5 cell-size) maze-offset-y))
+
+
+    ;geeft x-waarde terug
+    (define (pacman-x)
+      ((pacman-sprite 'get-x)))
+
+    ;geeft y-waarde terug
+    (define (pacman-y)
+      ((pacman-sprite 'get-y)))
+
+    ;past de x-waarde aan
+    (define (set-pacman-x! x)
+      ((pacman-sprite 'set-x!) x))
+
+    ;past de y-waarde aan
+    (define (set-pacman-y! y)
+      ((pacman-sprite 'set-y!) y))
+
+    ;pacman roteren obv zijn direction
+    (define (rotate-pacman! direction)
+      (cond ((eq? direction 'right) ((pacman-sprite 'rotate!) 0))
+            ((eq? direction 'left)  ((pacman-sprite 'rotate!) 180))
+            ((eq? direction 'up)    ((pacman-sprite 'rotate!) 90))
+            ((eq? direction 'down)  ((pacman-sprite 'rotate!) -90))))
+
+    ;pacman animaten door langs de bitmap sequence te gaan 
+    (define (animate-pacman! ms)
+      (set! time-since-last-animation (+ time-since-last-animation ms))
+      (when (>= time-since-last-animation animation-interval)
+        ((pacman-sprite 'set-next!))
+        (set! time-since-last-animation 0)))))

pacman-project/pause-menu.rkt

@@ -0,0 +1,39 @@
+#lang r7rs
+
+; Pause-menu ADT ;
+
+
+(define-library (pacman-project pause-menu)
+  (import (scheme base)
+          (pp1 graphics)
+          (pacman-project screen))
+
+  (export paused?
+          set-paused!
+          draw-pause-menu!
+          remove-pause-menu!)
+
+  (begin
+
+    (define pause-status #f)
+
+    (define pause-layer (make-new-layer!))
+
+    ;checken of we gepauzeerd zijn
+    (define (paused?)
+      pause-status)
+
+    ;om de pauze status aan te passen
+    (define (set-paused! status)
+      (set! pause-status status))
+
+    ;pauzescherm tekenen
+    (define (draw-pause-menu!)
+      (let ((pause-tile (make-tile screen-width screen-height)))
+        ((pause-layer 'add-drawable!) pause-tile)
+        ((pause-tile 'draw-rectangle!) 0 90 670 screen-height "black")
+        ((pause-tile 'draw-text!) "Game Paused" 40 200 400 "red")))
+
+    ;pauzescherm verwijderen 
+    (define (remove-pause-menu!)
+      ((pause-layer 'empty!)))))

pacman-project/score.rkt

@@ -0,0 +1,36 @@
+#lang r7rs
+
+; Score ADT ;
+
+
+(define-library (pacman-project score)
+  (import (scheme base)
+          (pp1 graphics)
+          (pacman-project screen))
+
+  (export draw-score!
+          update-score!
+          get-score)
+
+  (begin
+
+    (define score 0)
+
+    (define score-layer (make-new-layer!))
+    (define score-tile (make-tile screen-width screen-height))
+    ((score-layer 'add-drawable!) score-tile)
+
+    ;de current score teruggeven 
+    (define (get-score)
+      score)
+
+    ;score op het scherm tekenen
+    (define (draw-score!)
+      ((score-tile 'draw-text!)
+       (number->string score) 40 560 20 "white"))
+
+    ;wanneer een muntje gegeten wordt wordt de score met 10 verhoogt 
+    (define (update-score!)
+      (set! score (+ score 10))
+      ((score-tile 'clear!))
+      (draw-score!))))

pacman-project/screen.rkt

@@ -0,0 +1,26 @@
+#lang r7rs
+
+; Screen ADT ;
+
+(define-library (pacman-project screen)
+  (import (scheme base)
+          (pp1 graphics))
+
+  (export screen
+          screen-width
+          screen-height
+          make-new-layer!)
+
+  (begin
+
+    ;constanten
+    (define screen-width 1000)
+    (define screen-height 830)
+
+    ;scherm aanmaken
+    (define screen (make-window screen-width screen-height "Pacman"))
+    ((screen 'set-background!) "black")
+
+    ;nieuwe layer op her scherm maken
+    (define (make-new-layer!)
+      ((screen 'new-layer!)))))

pacman-project/test.rkt

@@ -0,0 +1,60 @@
+#lang r7rs
+
+;;; Tests voor de spelinteracties van het Pac-Man project.
+
+(define-library (pacman-project tests)
+  (import (scheme base)
+          (scheme write)
+          (pp1 graphics)
+          (pacman-project screen)
+          (pacman-project maze)
+          (pacman-project coin)
+          (pacman-project key)
+          (pacman-project pacman)
+          (pacman-project score)
+          (pacman-project time-limit)
+          (pacman-project pause-menu)
+          (pacman-project game-logic))
+
+  (begin
+
+    ;test of pacman door de muur kan of niet
+    (set-pacman-x! (* 1 cell-size))
+    (set-pacman-y! (+ (* 1 cell-size) maze-offset-y))
+    (display "Pac-Man kan niet door de muur: ")
+    (display (= (pacman-x) (begin (move-pacman! (- cell-size) 0) (pacman-x))))
+    (newline)
+
+    ;test of pacman een muntje opeet 
+    (set-pacman-x! (* 4 cell-size))
+    (set-pacman-y! (+ (* 5 cell-size) maze-offset-y))
+    (move-pacman! cell-size 0)
+    (display "Muntje wordt opgegeten: ")
+    (display (cell-empty? 5 5))
+    (newline)
+    (cell-set! 5 5 0)
+    (remove-coin! 5 5)
+
+    ;test of de score verhoogd wordt of niet
+    (display "Score is verhoogd: ")
+    (display (>= (get-score) 10))
+    (newline)
+
+    ;check of de teleportatie werkt
+    (set-pacman-x! (* 0 cell-size))
+    (set-pacman-y! (+ (* 14 cell-size) maze-offset-y))
+    (move-pacman! (- cell-size) 0)
+    (display "Teleportatie links naar rechts: ")
+    (display (= (pacman-x) (* (- maze-cols 1) cell-size)))
+    (newline)
+
+    ;test of een deur pas open gaat als de sleutel opgepakt werd. 
+    (set-pacman-x! (* 2 cell-size))
+    (set-pacman-y! (+ (* 4 cell-size) maze-offset-y))
+    (let ((x-voor (pacman-x)))
+      (move-pacman! cell-size 0)
+      (display "Deur blokkeert zonder sleutel: ")
+      (display (= (pacman-x) x-voor))
+      (newline)
+      (set-pacman-x! (* 2 cell-size))
+      (set-pacman-y! (+ (* 5 cell-size) maze-offset-y)))))

pacman-project/time-limit.rkt

@@ -0,0 +1,63 @@
+#lang r7rs
+
+; Time limit ADT ;
+
+
+(define-library (pacman-project time-limit)
+  (import (scheme base)
+          (pp1 graphics)
+          (pacman-project screen))
+
+  (export draw-time-limit!
+          decrease-time-limit!
+          update-time-limit!
+          time-up?)
+
+  (begin
+
+    (define time-remaining 60) ;1 min = 60 seconden
+    (define time-since-last-tick 0)
+
+    (define time-layer (make-new-layer!))
+    (define time-tile (make-tile screen-width screen-height))
+    ((time-layer 'add-drawable!) time-tile)
+
+
+
+    ;omn de tijdslimiet mooi op het scherm te kunnen krijgen 
+    (define (format-time seconds)
+      (let* ((minutes (quotient seconds 60)) ;om het aantal minuten te krijgen 
+             (seconds (remainder seconds 60)) ;om het aantal seconden te krijgen
+             (min-str (number->string minutes))
+             (sec-str (number->string seconds))) 
+        (string-append min-str
+                       ":"
+                       (if (< seconds 10) 
+                           (string-append "0" sec-str) ;om .. : 0.. te krijgen
+                           sec-str)))) ;anders gwn tekenen
+
+    ;teken de remaning time op het scherm
+    (define (draw-time-limit!)
+      ((time-tile 'draw-text!) "Time remaining:" 35 710 300 "white")
+      ((time-tile 'draw-rectangle!) 670 0 24 screen-height "white")
+      ((time-tile 'draw-text!)
+       (format-time time-remaining) 40 800 400 "white"))
+
+    ;tijd verminderdt met 1 seconde 
+    (define (decrease-time-limit! ms)
+      (set! time-since-last-tick (+ time-since-last-tick ms))
+      (when (>= time-since-last-tick 1000)
+        (set! time-since-last-tick 0)
+        (when (> time-remaining 0)
+          (set! time-remaining (- time-remaining 1))
+          ((time-tile 'clear!))
+          (draw-time-limit!))))
+
+    ;tijd verhogen met 1 seconde wanneer pacman een muntje opeet
+    (define (update-time-limit!)
+      (set! time-remaining (+ time-remaining 1))
+      ((time-tile 'clear!))
+      (draw-time-limit!))
+
+    (define (time-up?)
+      (= time-remaining 0))))