· 6 years ago · Nov 20, 2019, 03:54 PM
1
2package snake
3import introprog.BlockGame
4
5abstract class SnakeGame(title: String) extends BlockGame(
6 title, dim = (50, 30), blockSize = 15, background = Colors.Background,
7 framesPerSecond = 50, messageAreaHeight = 3
8) {
9 var entities: Vector[Entity] = Vector.empty //Vector(new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))
10
11 var players: Vector[Player] = Vector.empty
12 /* Vector(Player("P1", "a", "s", "d", "w", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
13 Player("P2", "j", "k", "l", "i", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)))
14*///ska egentligen stå Vector.empty på players
15 sealed trait State
16 case object Starting extends State
17 case object Playing extends State
18 case object GameOver extends State
19 case object Quitting extends State
20
21 var state: State = Starting
22
23 def enterStartingState(): Unit = {
24 pixelWindow.clear() //VARFÖR INTE BLOCKGAMES.CLEARWINDOW?
25 println("Tryck <SPACE> för att starta")
26 state = Starting
27 } // rensa, meddela "tryck space för start"
28
29 def enterPlayingState(): Unit = {
30 pixelWindow.clear()
31 //entities.foreach(_.update)
32 entities.foreach(_.draw)
33 //rita ut alla enheter, kontrollera!!!!!!!!!!!!!)
34 state = Playing
35 } // rensa, rita alla entiteter
36
37 def enterGameOverState(): Unit = {
38 println("Game Over")
39 state = GameOver
40 } // meddela "game over"
41
42 def enterQuittingState(): Unit = {
43 println("Goodbye!")
44 pixelWindow.hide()
45 state = Quitting
46 }
47//dim här under är hårdkodat? men den givna koden var också det?
48 def randomFreePos(): Pos = {
49 var posCheck = Pos.random(dim = Dim(50,30))
50 while(pixelWindow.getPixel(posCheck.x, posCheck.y) != java.awt.Color.black) { //tar för lång tid, blir ej 50 fps, testa this
51 posCheck = Pos.random(dim = Dim(50, 30))
52 }
53 posCheck
54 }
55
56 // dra slump-pos tills ledig plats, används av frukt, ta hjälp av pair uppgift g
57
58 override def onKeyDown(key: String): Unit = {
59 println(s"""key "$key" pressed""")
60 state match {
61 case Starting => if (key == " ") enterPlayingState() //om man trycker på SPACE kommer man till Playing state under
62 case Playing => players.foreach(_.handleKey(key)) //ändrar om direction för Player
63 case GameOver =>
64 if (key == " ") enterPlayingState()
65 else if(key == "Escape") enterQuittingState()
66 case _ =>
67 }
68 }
69
70 override def onClose(): Unit = enterQuittingState()
71
72 def isGameOver(): Boolean // abstrakt metod, implementeras i subklass
73
74 override def gameLoopAction(): Unit = {//denna metoden kallas varje loop i gameLoop
75 //var randomPos = this.randomFreePos()
76 //this.drawBlock(randomPos.x, randomPos.y, Colors.Apple)
77 entities.foreach(_.update)
78 entities.foreach(_.draw)
79 //enterPlayingState
80 //entities.foreach(_.update)
81 //entities.foreach(_.erase)
82 //entities.foreach(_.draw)
83 //pixelWindow.clear()
84 /*entities.foreach(_.draw) //rita ut alla enheter, kontrollera!!!!!!!!!!!!!
85 entities.foreach(_.update) */
86 }
87
88 def startGameLoop(): Unit = {
89 pixelWindow.show() // möjliggör omstart även om fönstret stängts...
90 enterStartingState()
91 entities.foreach(_.reset)
92 gameLoop(stopWhen = state == Quitting)
93 }
94
95 def play(playerNames: String*): Unit // abstrakt, implementeras i subklass
96}
97
98
99
100
101
102
103
104
105
106package snake
107
108class Snake (
109 val initPos: Pos,
110 val initDir: Dir,
111 val headColor: java.awt.Color,
112 val tailColor: java.awt.Color,
113 val game: SnakeGame
114) extends CanMove {
115 var dir: Dir = initDir
116
117 val initBody: List[Pos] = List(initPos + initDir, initPos)
118
119 val body: scala.collection.mutable.Buffer[Pos] = initBody.toBuffer
120
121 val initTailSize: Int = 10 // välj själv vad som är lagom svårt
122
123 // var nbrOfStepsSinceReset = 0
124 // val growEvery = 10
125 // val startGrowingAfter = 400
126 // var nbrOfApples = 0
127
128 def reset(): Unit = {
129 //funkar inte
130 dir = initDir
131 body.clear
132 for (ib <- initBody) body += ib
133 for (p <- 1 to initTailSize){
134 body += body.last - initDir
135 }
136 } // återställ starttillstånd, ge rätt svanslängd
137
138 def grow(): Unit = {
139 body.append(body.last - East) //test, byt ut riktning
140 } // väx i rätt riktning med extra svansposition
141
142 def shrink(): Unit = if (body.size > 2) body -= body.last // krymp svansen om kroppslängden är större än 2
143
144 def isOccupyingBlockAt(p: Pos): Boolean = body.contains(p) // kolla om p finns i kroppen
145
146 def isHeadCollision(other: Snake): Boolean = body.head == other.body.head // kolla om huvudena krockar
147 def isTailCollision(other: Snake): Boolean = other.body.tail.contains(body.head) // mitt huvud i annans svans
148
149 def move(): Unit = {
150 println(body.toString)
151 body.prepend(body.head + dir)
152 shrink()
153 } // väx och krymp enl. regler; action om äter frukt
154
155 def draw(): Unit = {
156 game.drawBlock(body.head.x, body.head.y, headColor) // rita huvud
157 for (p <- body.tail){
158 game.drawBlock(p.x, p.y, tailColor)
159 }
160 erase()
161 }
162
163 // byt mot eraseBlock
164 def erase(): Unit = game.drawBlock(body.last.x, body.last.y, game.background)
165
166 override def toString = // bra vid println-debugging
167 body.map(p => (p.x, p.y)).mkString(">:)", "~", s" going $dir")
168}
169
170
171
172
173
174package snake
175
176class Apple(
177 val initPos: Pos,
178 val color: java.awt.Color,
179 val game: SnakeGame
180)
181 extends CanTeleport {
182
183 override def teleportAfterSteps: Int = ???
184
185 def draw = {
186 var randomPos = game.randomFreePos()
187 game.drawBlock(randomPos.x, randomPos.y, Colors.Apple)
188 }
189
190 def erase = ???
191
192 def isOccupyingBlockAt(p: Pos): Boolean = ???
193}
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217package snake
218
219class TwoPlayerGame extends SnakeGame(title = "Hej") { // ska ärva SnakeGame
220 override def isGameOver(): Boolean = false
221 /*var players: Vector[Player] = Vector(Player("P1", "a", "s", "d", "w", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
222 Player("P2", "j", "k", "l", "i", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))) //Vector(Player(...), Player(...)//Lägg till Players här.
223 *///Vector(Player("P1", "a", "s", "d", "w", Snake(Pos(10, 10, Dim(50,30)), Dir(0,1), java.awt.Color.white, java.awt.Color.white, SnakeGame("hej"))))
224
225 players = Vector(Player("P1", "A", "S", "D", "W", new Snake(Pos(10, 10, Dim(50,30)), Nothing, Colors.DarkGreen, Colors.Green, this)),
226 Player("P2", "J", "K", "L", "I", new Snake(Pos(20, 10, Dim(50,30)), Nothing, Colors.DarkBlue, Colors.Blue, this)))
227
228
229 val apples: Vector[Apple] = Vector(new Apple(Pos(20, 20, Dim(50,30)), Colors.Apple, this))
230
231 entities = Vector(players(0).snake, players(1).snake, apples(0))
232 // ormar och ev. äpple, bananer etc
233
234 override def play(playerNames: String*): Unit = {
235 println(playerNames) // ska överskugga play i SnakeGame
236 startGameLoop
237
238 }
239
240
241
242}
243
244package snake
245
246class Apple(
247 val initPos: Pos,
248 val color: java.awt.Color,
249 val game: SnakeGame
250)
251 extends CanTeleport {
252 var pos1 = initPos
253 override def teleportAfterSteps: Int = 100
254
255 def draw = {
256 game.eraseBlock(pos1.x, pos1.y)
257 game.drawBlock(pos1.x, pos1.y, Colors.Apple)
258 pos1 = pos
259 }
260
261 def erase(): Unit = game.drawBlock(initPos.x, initPos.y, game.background)
262 //finns eraseBlock i blockGAME API
263
264 def isOccupyingBlockAt(p: Pos): Boolean = ???
265}
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280package snake
281trait Pair[T] {
282 def x: T
283 def y: T
284 def tuple: (T, T) = (x, y)
285}
286
287case class Dim(x: Int, y: Int) extends Pair[Int]
288object Dim {
289 def apply(dim: (Int, Int)): Dim = Dim(dim._1, dim._2)
290}
291
292
293case class Pos private (x: Int, y: Int, dim: Dim) extends Pair[Int] {
294 import java.lang.Math.{floorMod => mod}
295
296 def +(p: Pair[Int]): Pos =
297 copy(x = mod(x + p.x, dim.x), y = mod(y + p.y, dim.y))
298
299 def -(p: Pair[Int]): Pos =
300 copy(x = mod(x - p.x, dim.x), y = mod(y - p.y, dim.y))
301}
302
303object Pos {
304 import java.lang.Math.{floorMod => mod}
305 import scala.util.Random
306
307 def apply(x: Int, y: Int, dim: Dim): Pos =
308 new Pos(mod(x, dim.x), mod(y, dim.y), dim)
309
310 def random(dim: Dim): Pos = {
311 Pos(Random.nextInt(dim.x), Random.nextInt(dim.y), dim)
312 }
313}
314
315abstract sealed class Dir(val x: Int, val y: Int) extends Pair[Int]
316case object North extends Dir( 0, -1)
317case object South extends Dir( 0, 1)
318case object East extends Dir( 1, 0)
319case object West extends Dir(-1, 0)
320case object Nothing extends Dir(0, 0)
321
322
323
324
325
326
327
328
329
330
331
332package snake
333import introprog.BlockGame
334
335abstract class SnakeGame(title: String) extends BlockGame(
336 title, dim = (50, 30), blockSize = 15, background = Colors.Background,
337 framesPerSecond = 50, messageAreaHeight = 3
338) {
339 var entities: Vector[Entity] = Vector.empty //Vector(new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))
340
341 var players: Vector[Player] = Vector.empty
342 /**
343 *
344 * Vector(
345 * Player("P1", "a", "s", "d", "w", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
346 * Player("P2", "j", "k", "l", "i", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))
347 * )
348 * ska egentligen stå Vector.empty på players
349 **/
350
351 sealed trait State
352 case object Starting extends State
353 case object Playing extends State
354 case object GameOver extends State
355 case object Quitting extends State
356
357 var state: State = Starting
358
359 def enterStartingState(): Unit = {
360 pixelWindow.clear() //VARFÖR INTE BLOCKGAMES.CLEARWINDOW?
361 println("Tryck <SPACE> för att starta")
362 state = Starting
363 } // rensa, meddela "tryck space för start"
364
365 def enterPlayingState(): Unit = {
366 pixelWindow.clear()
367 //entities.foreach(_.update)
368 entities.foreach(_.draw)
369 //rita ut alla enheter, kontrollera!!!!!!!!!!!!!)
370 state = Playing
371 } // rensa, rita alla entiteter
372
373 def enterGameOverState(): Unit = {
374 println("Game Over")
375 state = GameOver
376 } // meddela "game over"
377
378 def enterQuittingState(): Unit = {
379 println("Goodbye!")
380 pixelWindow.hide()
381 state = Quitting
382 }
383//dim här under är hårdkodat? men den givna koden var också det?
384 def randomFreePos(): Pos = ??? /*{
385 var posCheck = Pos.random(dim = Dim(50,30))
386 while(pixelWindow.getPixel(posCheck.x, posCheck.y) != java.awt.Color.black) { //tar för lång tid, blir ej 50 fps, testa this
387 posCheck = Pos.random(dim = Dim(50, 30))
388 }
389 posCheck
390 } */
391
392 // dra slump-pos tills ledig plats, används av frukt, ta hjälp av pair uppgift g
393
394 override def onKeyDown(key: String): Unit = {
395 println(s"""key "$key" pressed""")
396 state match {
397 case Starting => if (key == " ") enterPlayingState() //om man trycker på SPACE kommer man till Playing state under
398 case Playing => players.foreach(_.handleKey(key)) //ändrar om direction för Player
399 case GameOver =>
400 if (key == " ") enterPlayingState()
401 else if(key == "Escape") enterQuittingState()
402 case _ =>
403 }
404 }
405
406 override def onClose(): Unit = enterQuittingState()
407
408 def isGameOver(): Boolean // abstrakt metod, implementeras i subklass
409
410 override def gameLoopAction(): Unit = {//denna metoden kallas varje loop i gameLoop
411 entities.foreach(_.update)
412 entities.foreach(_.draw)
413 //enterPlayingState
414 //entities.foreach(_.update)
415 //entities.foreach(_.erase)
416 //entities.foreach(_.draw)
417 //pixelWindow.clear()
418 /*entities.foreach(_.draw) //rita ut alla enheter, kontrollera!!!!!!!!!!!!!
419 entities.foreach(_.update) */
420 }
421
422 def startGameLoop(): Unit = {
423 pixelWindow.show() // möjliggör omstart även om fönstret stängts...
424 enterStartingState()
425 entities.foreach(_.reset)
426 gameLoop(stopWhen = state == Quitting)
427 }
428
429 def play(playerNames: String*): Unit // abstrakt, implementeras i subklass
430}
431package snake
432import introprog.BlockGame
433
434abstract class SnakeGame(title: String) extends BlockGame(
435 title, dim = (50, 30), blockSize = 15, background = Colors.Background,
436 framesPerSecond = 50, messageAreaHeight = 3
437) {
438 var entities: Vector[Entity] = Vector.empty //Vector(new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))
439
440 var players: Vector[Player] = Vector.empty
441 /* Vector(Player("P1", "a", "s", "d", "w", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
442 Player("P2", "j", "k", "l", "i", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)))
443*///ska egentligen stå Vector.empty på players
444 sealed trait State
445 case object Starting extends State
446 case object Playing extends State
447 case object GameOver extends State
448 case object Quitting extends State
449
450 var state: State = Starting
451
452 def enterStartingState(): Unit = {
453 pixelWindow.clear() //VARFÖR INTE BLOCKGAMES.CLEARWINDOW?
454 println("Tryck <SPACE> för att starta")
455 state = Starting
456 } // rensa, meddela "tryck space för start"
457
458 def enterPlayingState(): Unit = {
459 pixelWindow.clear()
460 //entities.foreach(_.update)
461 entities.foreach(_.draw)
462 //rita ut alla enheter, kontrollera!!!!!!!!!!!!!)
463 state = Playing
464 } // rensa, rita alla entiteter
465
466 def enterGameOverState(): Unit = {
467 println("Game Over")
468 state = GameOver
469 } // meddela "game over"
470
471 def enterQuittingState(): Unit = {
472 println("Goodbye!")
473 pixelWindow.hide()
474 state = Quitting
475 }
476//dim här under är hårdkodat? men den givna koden var också det?
477 def randomFreePos(): Pos = ??? /*{
478 var posCheck = Pos.random(dim = Dim(50,30))
479 while(pixelWindow.getPixel(posCheck.x, posCheck.y) != java.awt.Color.black) { //tar för lång tid, blir ej 50 fps, testa this
480 posCheck = Pos.random(dim = Dim(50, 30))
481 }
482 posCheck
483 } */
484
485 // dra slump-pos tills ledig plats, används av frukt, ta hjälp av pair uppgift g
486
487 override def onKeyDown(key: String): Unit = {
488 println(s"""key "$key" pressed""")
489 state match {
490 case Starting => if (key == " ") enterPlayingState() //om man trycker på SPACE kommer man till Playing state under
491 case Playing => players.foreach(_.handleKey(key)) //ändrar om direction för Player
492 case GameOver =>
493 if (key == " ") enterPlayingState()
494 else if(key == "Escape") enterQuittingState()
495 case _ =>
496 }
497 }
498
499 override def onClose(): Unit = enterQuittingState()
500
501 def isGameOver(): Boolean // abstrakt metod, implementeras i subklass
502
503 override def gameLoopAction(): Unit = {//denna metoden kallas varje loop i gameLoop
504 entities.foreach(_.update)
505 entities.foreach(_.draw)
506 //enterPlayingState
507 //entities.foreach(_.update)
508 //entities.foreach(_.erase)
509 //entities.foreach(_.draw)
510 //pixelWindow.clear()
511 /*entities.foreach(_.draw) //rita ut alla enheter, kontrollera!!!!!!!!!!!!!
512 entities.foreach(_.update) */
513 }
514
515 def startGameLoop(): Unit = {
516 pixelWindow.show() // möjliggör omstart även om fönstret stängts...
517 enterStartingState()
518 entities.foreach(_.reset)
519 gameLoop(stopWhen = state == Quitting)
520 }
521
522 def play(playerNames: String*): Unit // abstrakt, implementeras i subklass
523}
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543package snake
544
545class Apple(
546 val initPos: Pos,
547 val color: java.awt.Color,
548 val game: SnakeGame
549)
550 extends CanTeleport {
551 var pos1 = initPos
552 override def teleportAfterSteps: Int = 20
553
554 def draw = {
555 game.drawBlock(pos1.x, pos1.y, Colors.Apple)
556 pos1 = game.randomFreePos()
557 }
558
559 def erase(): Unit = game.drawBlock(initPos.x, initPos.y, game.background)
560 //finns eraseBlock i blockGAME API
561
562 def isOccupyingBlockAt(p: Pos): Boolean = ???
563}
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580package snake
581
582class TwoPlayerGame extends SnakeGame(title = "Hej") { // ska ärva SnakeGame
583 override def isGameOver(): Boolean = false
584 /**
585* var players: Vector[Player] = Vector(
586* Player("P1", "a", "s", "d", "w", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
587* Player("P2", "j", "k", "l", "i", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))
588* )
589*
590* Vector(Player(...), Player(...)
591*
592* Vector(Player("P1", "a", "s", "d", "w", Snake(Pos(10, 10, Dim(50,30)), Dir(0,1), java.awt.Color.white, java.awt.Color.white, SnakeGame("hej"))))
593*/
594
595 players = Vector(Player("P1", "A", "S", "D", "W", new Snake(Pos(10, 10, Dim(50,30)), Nothing, Colors.DarkGreen, Colors.Green, this)),
596 Player("P2", "J", "K", "L", "I", new Snake(Pos(20, 10, Dim(50,30)), Nothing, Colors.DarkBlue, Colors.Blue, this)))
597
598
599 val apples: Vector[Apple] = Vector(new Apple(Pos(20, 20, Dim(50,30)), Colors.Apple, this))
600
601 entities = Vector(players(0).snake, players(1).snake, apples(0))
602 // ormar och ev. äpple, bananer etc
603
604 override def play(playerNames: String*): Unit = {
605 println(playerNames) // ska överskugga play i SnakeGame
606 startGameLoop
607
608 }
609
610}
611
612
613
614// v0.4
615package snake
616
617class Snake (
618 val initPos: Pos,
619 val initDir: Dir,
620 val headColor: java.awt.Color,
621 val tailColor: java.awt.Color,
622 val game: SnakeGame
623) extends CanMove {
624 var dir: Dir = initDir
625
626 val initBody: List[Pos] = List(initPos + initDir, initPos)
627
628 val body: scala.collection.mutable.Buffer[Pos] = initBody.toBuffer
629
630 val initTailSize: Int = 10 // välj själv vad som är lagom svårt
631
632 // var nbrOfStepsSinceReset = 0
633 // val growEvery = 10
634 // val startGrowingAfter = 400
635 // var nbrOfApples = 0
636
637 def reset(): Unit = {
638 //funkar inte
639 dir = initDir
640 body.clear
641 for (ib <- initBody) body += ib
642 for (p <- 1 to initTailSize){
643 body += body.last - initDir
644 }
645 } // återställ starttillstånd, ge rätt svanslängd
646
647 def grow(): Unit = {
648 body.append(body.last - East) //test, byt ut riktning
649 } // väx i rätt riktning med extra svansposition
650
651 def shrink(): Unit = if (body.size > 2) body -= body.last // krymp svansen om kroppslängden är större än 2
652
653 def isOccupyingBlockAt(p: Pos): Boolean = body.contains(p) // kolla om p finns i kroppen
654
655 def isHeadCollision(other: Snake): Boolean = body.head == other.body.head // kolla om huvudena krockar
656 def isTailCollision(other: Snake): Boolean = other.body.tail.contains(body.head) // mitt huvud i annans svans
657
658 def move(): Unit = {
659 println(body.toString)
660 body.prepend(body.head + dir)
661 shrink()
662 } // väx och krymp enl. regler; action om äter frukt
663
664 def draw(): Unit = {
665 game.drawBlock(body.head.x, body.head.y, headColor) // rita huvud
666 for (p <- body.tail){
667 game.drawBlock(p.x, p.y, tailColor)
668 }
669 erase()
670 }
671
672 // byt mot eraseBlock
673 def erase(): Unit = game.drawBlock(body.last.x, body.last.y, game.background)
674
675 override def toString = // bra vid println-debugging
676 body.map(p => (p.x, p.y)).mkString(">:)", "~", s" going $dir")
677}
678
679
680
681
682package snake
683
684class Apple(
685 val initPos: Pos,
686 val color: java.awt.Color,
687 val game: SnakeGame
688)
689 extends CanTeleport {
690
691 override def teleportAfterSteps: Int = ???
692
693 def draw = {
694 var randomPos = game.randomFreePos()
695 game.drawBlock(randomPos.x, randomPos.y, Colors.Apple)
696 }
697
698 def erase = ???
699
700 def isOccupyingBlockAt(p: Pos): Boolean = ???
701}
702
703package snake
704
705class TwoPlayerGame extends SnakeGame(title = "Hej") { // ska ärva SnakeGame
706 override def isGameOver(): Boolean = false
707 /*var players: Vector[Player] = Vector(Player("P1", "a", "s", "d", "w", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
708 Player("P2", "j", "k", "l", "i", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))) //Vector(Player(...), Player(...)//Lägg till Players här.
709 *///Vector(Player("P1", "a", "s", "d", "w", Snake(Pos(10, 10, Dim(50,30)), Dir(0,1), java.awt.Color.white, java.awt.Color.white, SnakeGame("hej"))))
710
711 players = Vector(Player("P1", "A", "S", "D", "W", new Snake(Pos(10, 10, Dim(50,30)), Nothing, Colors.DarkGreen, Colors.Green, this)),
712 Player("P2", "J", "K", "L", "I", new Snake(Pos(20, 10, Dim(50,30)), Nothing, Colors.DarkBlue, Colors.Blue, this)))
713
714 entities = Vector(players(0).snake, players(1).snake)
715 // ormar och ev. äpple, bananer etc
716
717 override def play(playerNames: String*): Unit = {
718 println(playerNames) // ska överskugga play i SnakeGame
719 startGameLoop
720
721 }
722
723
724
725
726
727
728
729
730
731
732package snake
733
734case class Player(
735 name: String,
736 left: String, down: String, right: String, up: String, // control keys
737 snake: Snake
738){
739 def handleKey(key: String): Unit = { // mutate snake dir if control key
740 key.toUpperCase match {
741 case `left` if(snake.dir != East) => snake.dir = West
742 case `right` if(snake.dir != West) => snake.dir = East
743 case `down` if(snake.dir != North) => snake.dir = South
744 case `up` if(snake.dir != South) => snake.dir = North
745 case _ =>
746 }
747 }
748}
749
750
751
752package snake
753
754class TwoPlayerGame extends SnakeGame(title = "Hej") { // ska ärva SnakeGame
755 override def isGameOver(): Boolean = false
756 /**
757 * var players: Vector[Player] = Vector(Player("P1", "a", "s", "d", "w", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
758 * Player("P2", "j", "k", "l", "i", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))) //Vector(Player(...), Player(...)
759 *
760 * Vector(Player("P1", "a", "s", "d", "w", Snake(Pos(10, 10, Dim(50,30)), Dir(0,1), java.awt.Color.white, java.awt.Color.white, SnakeGame("hej"))))
761 */
762 players =
763 Vector(
764 Player("P1", "A", "S", "D", "W", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
765 Player("P2", "J", "K", "L", "I", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))
766 )
767
768
769 entities = Vector(players(0).snake, players(1).snake)
770 // ormar och ev. äpple, bananer etc
771
772 override def play(playerNames: String*): Unit = {
773 println(playerNames) // ska överskugga play i SnakeGame
774 startGameLoop
775
776 }
777
778
779
780}
781
782
783
784package snake
785import introprog.BlockGame
786
787abstract class SnakeGame(title: String) extends BlockGame(
788 title, dim = (50, 30), blockSize = 15, background = Colors.Background,
789 framesPerSecond = 50, messageAreaHeight = 3
790) {
791 var entities: Vector[Entity] = Vector.empty //Vector(new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))
792
793 var players: Vector[Player] = Vector.empty
794 /* Vector(Player("P1", "a", "s", "d", "w", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
795 Player("P2", "j", "k", "l", "i", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)))
796*///ska egentligen stå Vector.empty på players
797 sealed trait State
798 case object Starting extends State
799 case object Playing extends State
800 case object GameOver extends State
801 case object Quitting extends State
802
803 var state: State = Starting
804
805 def enterStartingState(): Unit = {
806 pixelWindow.clear() //VARFÖR INTE BLOCKGAMES.CLEARWINDOW?
807 println("Tryck <SPACE> för att starta")
808 state = Starting
809 } // rensa, meddela "tryck space för start"
810
811 def enterPlayingState(): Unit = {
812 pixelWindow.clear()
813 //entities.foreach(_.update)
814 entities.foreach(_.draw)
815 //rita ut alla enheter, kontrollera!!!!!!!!!!!!!)
816 state = Playing
817 } // rensa, rita alla entiteter
818
819 def enterGameOverState(): Unit = {
820 println("Game Over")
821 state = GameOver
822 } // meddela "game over"
823
824 def enterQuittingState(): Unit = {
825 println("Goodbye!")
826 pixelWindow.hide()
827 state = Quitting
828 }
829//dim här under är hårdkodat? men den givna koden var också det?
830 def randomFreePos(): Pos = ??? /*{
831 var posCheck = Pos.random(dim = Dim(50,30))
832 while(pixelWindow.getPixel(posCheck.x, posCheck.y) != java.awt.Color.black) { //tar för lång tid, blir ej 50 fps, testa this
833 posCheck = Pos.random(dim = Dim(50, 30))
834 }
835 posCheck
836 } */
837
838 // dra slump-pos tills ledig plats, används av frukt, ta hjälp av pair uppgift g
839
840 override def onKeyDown(key: String): Unit = {
841 println(s"""key "$key" pressed""")
842 state match {
843 case Starting => if (key == " ") enterPlayingState() //om man trycker på SPACE kommer man till Playing state under
844 case Playing => println("bajs"); players.foreach(_.handleKey(key)) //ändrar om direction för Player
845 case GameOver =>
846 if (key == " ") enterPlayingState()
847 else if(key == "Escape") enterQuittingState()
848 case _ =>
849 }
850 }
851
852 override def onClose(): Unit = enterQuittingState()
853
854 def isGameOver(): Boolean // abstrakt metod, implementeras i subklass
855
856 override def gameLoopAction(): Unit = {//denna metoden kallas varje loop i gameLoop
857 entities.foreach(_.update)
858 entities.foreach(_.draw)
859 //enterPlayingState
860 //entities.foreach(_.update)
861 //entities.foreach(_.erase)
862 //entities.foreach(_.draw)
863 //pixelWindow.clear()
864 /*entities.foreach(_.draw) //rita ut alla enheter, kontrollera!!!!!!!!!!!!!
865 entities.foreach(_.update) */
866 }
867
868 def startGameLoop(): Unit = {
869 pixelWindow.show() // möjliggör omstart även om fönstret stängts...
870 println("hej")
871 enterStartingState()
872 println("hej111")
873 entities.foreach(_.reset)
874 gameLoop(stopWhen = state == Quitting)
875 }
876
877 def play(playerNames: String*): Unit // abstrakt, implementeras i subklass
878}
879
880
881
882
883
884// v0.4
885
886package snake
887
888class Snake (
889 val initPos: Pos,
890 val initDir: Dir,
891 val headColor: java.awt.Color,
892 val tailColor: java.awt.Color,
893 val game: SnakeGame
894) extends CanMove {
895 var dir: Dir = initDir
896
897 val initBody: List[Pos] = List(initPos + initDir, initPos)
898
899 val body: scala.collection.mutable.Buffer[Pos] = initBody.toBuffer
900
901 val initTailSize: Int = 10 // välj själv vad som är lagom svårt
902
903 // var nbrOfStepsSinceReset = 0
904 // val growEvery = 10
905 // val startGrowingAfter = 400
906 // var nbrOfApples = 0
907
908 def reset(): Unit = {
909 //funkar inte
910 dir = initDir
911 body.clear
912 for (ib <- initBody) body += ib
913 for (p <- 1 to initTailSize){
914 body += body.last - initDir
915 }
916 } // återställ starttillstånd, ge rätt svanslängd
917
918 def grow(): Unit = {
919 body.append(body.last - East) //test, byt ut riktning
920 } // väx i rätt riktning med extra svansposition
921
922 def shrink(): Unit = if (body.size > 2) body -= body.last // krymp svansen om kroppslängden är större än 2
923
924 def isOccupyingBlockAt(p: Pos): Boolean = body.contains(p) // kolla om p finns i kroppen
925
926 def isHeadCollision(other: Snake): Boolean = body.head == other.body.head // kolla om huvudena krockar
927 def isTailCollision(other: Snake): Boolean = other.body.tail.contains(body.head) // mitt huvud i annans svans
928
929 def move(): Unit = {
930 println(body.toString)
931 body.prepend(body.head + dir)
932 shrink()
933 } // väx och krymp enl. regler; action om äter frukt
934
935 def draw(): Unit = {
936 game.drawBlock(body.head.x, body.head.y, headColor) // rita huvud
937 for (p <- body.tail){
938 game.drawBlock(p.x, p.y, tailColor)
939 }
940 erase()
941 }
942
943 def erase(): Unit = game.drawBlock(body.last.x, body.last.y, game.background)
944
945 override def toString = // bra vid println-debugging
946 body.map(p => (p.x, p.y)).mkString(">:)", "~", s" going $dir")
947}
948
949
950
951
952package snake
953import introprog.BlockGame
954
955abstract class SnakeGame(title: String) extends BlockGame(
956 title, dim = (50, 30), blockSize = 15, background = Colors.Background,
957 framesPerSecond = 50, messageAreaHeight = 3
958) {
959 var entities: Vector[Entity] = Vector.empty //Vector(new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))
960
961 var players: Vector[Player] = Vector.empty
962 /* Vector(Player("P1", "a", "s", "d", "w", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
963 Player("P2", "j", "k", "l", "i", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)))
964*///ska egentligen stå Vector.empty på players
965 sealed trait State
966 case object Starting extends State
967 case object Playing extends State
968 case object GameOver extends State
969 case object Quitting extends State
970
971 var state: State = Starting
972
973 def enterStartingState(): Unit = {
974 pixelWindow.clear() //VARFÖR INTE BLOCKGAMES.CLEARWINDOW?
975 println("Tryck <SPACE> för att starta")
976 state = Starting
977 } // rensa, meddela "tryck space för start"
978
979 def enterPlayingState(): Unit = {
980 pixelWindow.clear()
981 //entities.foreach(_.update)
982 entities.foreach(_.draw)
983 //rita ut alla enheter, kontrollera!!!!!!!!!!!!!)
984 state = Playing
985 } // rensa, rita alla entiteter
986
987 def enterGameOverState(): Unit = {
988 println("Game Over")
989 state = GameOver
990 } // meddela "game over"
991
992 def enterQuittingState(): Unit = {
993 println("Goodbye!")
994 pixelWindow.hide()
995 state = Quitting
996 }
997//dim här under är hårdkodat? men den givna koden var också det?
998 def randomFreePos(): Pos = ??? /*{
999 var posCheck = Pos.random(dim = Dim(50,30))
1000 while(pixelWindow.getPixel(posCheck.x, posCheck.y) != java.awt.Color.black) { //tar för lång tid, blir ej 50 fps, testa this
1001 posCheck = Pos.random(dim = Dim(50, 30))
1002 }
1003 posCheck
1004 } */
1005
1006 // dra slump-pos tills ledig plats, används av frukt, ta hjälp av pair uppgift g
1007
1008 override def onKeyDown(key: String): Unit = {
1009 println(s"""key "$key" pressed""")
1010 state match {
1011 case Starting => if (key == " ") enterPlayingState() //om man trycker på SPACE kommer man till Playing state under
1012 case Playing => println("bajs"); players.foreach(_.handleKey(key)) //ändrar om direction för Player
1013 case GameOver =>
1014 if (key == " ") enterPlayingState()
1015 else if(key == "Escape") enterQuittingState()
1016 case _ =>
1017 }
1018 }
1019
1020 override def onClose(): Unit = enterQuittingState()
1021
1022 def isGameOver(): Boolean // abstrakt metod, implementeras i subklass
1023
1024 override def gameLoopAction(): Unit = {//denna metoden kallas varje loop i gameLoop
1025 entities.foreach(_.update)
1026 entities.foreach(_.draw)
1027 //enterPlayingState
1028 //entities.foreach(_.update)
1029 //entities.foreach(_.erase)
1030 //entities.foreach(_.draw)
1031 //pixelWindow.clear()
1032 /*entities.foreach(_.draw) //rita ut alla enheter, kontrollera!!!!!!!!!!!!!
1033 entities.foreach(_.update) */
1034 }
1035
1036 def startGameLoop(): Unit = {
1037 pixelWindow.show() // möjliggör omstart även om fönstret stängts...
1038 println("hej")
1039 enterStartingState()
1040 println("hej111")
1041 gameLoop(stopWhen = state == Quitting)
1042 }
1043
1044 def play(playerNames: String*): Unit // abstrakt, implementeras i subklass
1045}
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069package snake
1070
1071class TwoPlayerGame extends SnakeGame(title = "Hej") { // ska ärva SnakeGame
1072 override def isGameOver(): Boolean = false
1073 /*var players: Vector[Player] = Vector(Player("P1", "a", "s", "d", "w", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
1074 Player("P2", "j", "k", "l", "i", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))) //Vector(Player(...), Player(...)//Lägg till Players här.
1075 *///Vector(Player("P1", "a", "s", "d", "w", Snake(Pos(10, 10, Dim(50,30)), Dir(0,1), java.awt.Color.white, java.awt.Color.white, SnakeGame("hej"))))
1076
1077 players = Vector(Player("P1", "A", "S", "D", "W", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
1078 Player("P2", "J", "K", "L", "I", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)))
1079
1080 entities = Vector(players(0).snake, players(1).snake)
1081 // ormar och ev. äpple, bananer etc
1082
1083 override def play(playerNames: String*): Unit = {
1084 println(playerNames) // ska överskugga play i SnakeGame
1085 startGameLoop
1086
1087 }
1088
1089
1090
1091}
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101package snake
1102import introprog.BlockGame
1103
1104abstract class SnakeGame(title: String) extends BlockGame(
1105 title, dim = (50, 30), blockSize = 15, background = Colors.Background,
1106 framesPerSecond = 50, messageAreaHeight = 3
1107) {
1108 var entities: Vector[Entity] = Vector.empty //Vector(new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))
1109
1110 var players: Vector[Player] = Vector.empty
1111 /* Vector(Player("P1", "a", "s", "d", "w", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
1112 Player("P2", "j", "k", "l", "i", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)))
1113*///ska egentligen stå Vector.empty på players
1114 sealed trait State
1115 case object Starting extends State
1116 case object Playing extends State
1117 case object GameOver extends State
1118 case object Quitting extends State
1119
1120 var state: State = Starting
1121
1122 def enterStartingState(): Unit = {
1123 pixelWindow.clear() //VARFÖR INTE BLOCKGAMES.CLEARWINDOW?
1124 println("Tryck <SPACE> för att starta")
1125 state = Starting
1126 } // rensa, meddela "tryck space för start"
1127
1128 def enterPlayingState(): Unit = {
1129 pixelWindow.clear()
1130 state = Playing
1131 } // rensa, rita alla entiteter
1132
1133 def enterGameOverState(): Unit = {
1134 println("Game Over")
1135 state = GameOver
1136 } // meddela "game over"
1137
1138 def enterQuittingState(): Unit = {
1139 println("Goodbye!")
1140 pixelWindow.hide()
1141 state = Quitting
1142 }
1143//dim här under är hårdkodat? men den givna koden var också det?
1144 def randomFreePos(): Pos = {
1145 var posCheck = Pos.random(dim = Dim(50,30))
1146 while(pixelWindow.getPixel(posCheck.x, posCheck.y) != java.awt.Color.black) { //tar för lång tid, blir ej 50 fps, testa this
1147 posCheck = Pos.random(dim = Dim(50, 30))
1148 }
1149 posCheck
1150 }
1151
1152 // dra slump-pos tills ledig plats, används av frukt, ta hjälp av pair uppgift g
1153
1154 override def onKeyDown(key: String): Unit = {
1155 println(s"""key "$key" pressed""")
1156 state match {
1157 case Starting => if (key == " ") enterPlayingState() //om man trycker på SPACE kommer man till Playing state under
1158 case Playing => players.foreach(_.handleKey(key)) //ändrar om direction för Player
1159 case GameOver =>
1160 if (key == " ") enterPlayingState()
1161 else if(key == "Escape") enterQuittingState()
1162 case _ =>
1163 }
1164 }
1165
1166 override def onClose(): Unit = enterQuittingState()
1167
1168 def isGameOver(): Boolean // abstrakt metod, implementeras i subklass
1169
1170 override def gameLoopAction(): Unit = {//denna metoden kallas varje loop i gameLoop
1171 pixelWindow.clear
1172 entities.foreach(_.draw) //rita ut alla enheter, kontrollera!!!!!!!!!!!!!
1173 entities.foreach(_.update)
1174 }
1175
1176 def startGameLoop(): Unit = {
1177 pixelWindow.show() // möjliggör omstart även om fönstret stängts...
1178 enterStartingState()
1179 gameLoop(stopWhen = state == Quitting)
1180 }
1181
1182 def play(playerNames: String*): Unit // abstrakt, implementeras i subklass
1183}
1184
1185
1186// v0.2
1187
1188package snake
1189
1190class Snake (
1191 val initPos: Pos,
1192 val initDir: Dir,
1193 val headColor: java.awt.Color,
1194 val tailColor: java.awt.Color,
1195 val game: SnakeGame
1196) extends CanMove {
1197 var dir: Dir = initDir
1198
1199 val initBody: List[Pos] = List(initPos + initDir, initPos)
1200
1201 val body: scala.collection.mutable.Buffer[Pos] = initBody.toBuffer
1202
1203 val initTailSize: Int = 10 // välj själv vad som är lagom svårt
1204
1205 // var nbrOfStepsSinceReset = 0
1206 // val growEvery = 10
1207 // val startGrowingAfter = 400
1208 // var nbrOfApples = 0
1209
1210 def reset(): Unit = {
1211 for (p <- 1 to initTailSize){
1212 ???
1213 }
1214 } // återställ starttillstånd, ge rätt svanslängd
1215
1216 def grow(): Unit = {
1217 body.append(body.last - East) //test, byt ut riktning
1218 } // väx i rätt riktning med extra svansposition
1219
1220 def shrink(): Unit = if (body.size > 2) body -= body.last // krymp svansen om kroppslängden är större än 2
1221
1222 def isOccupyingBlockAt(p: Pos): Boolean = body.contains(p) // kolla om p finns i kroppen
1223
1224 def isHeadCollision(other: Snake): Boolean = body.head == other.body.head // kolla om huvudena krockar
1225 def isTailCollision(other: Snake): Boolean = other.body.tail.contains(body.head) // mitt huvud i annans svans
1226
1227 def move(): Unit = {
1228 body.prepend(body.head + dir)
1229 shrink()
1230 } // väx och krymp enl. regler; action om äter frukt
1231
1232 def draw(): Unit = {
1233 game.drawBlock(body.head.x, body.head.y, headColor) // rita huvud
1234 for (p <- body.tail){
1235 game.drawBlock(p.x, p.y, tailColor)
1236 }
1237 }
1238
1239 def erase(): Unit = game.drawBlock(body.last.x, body.last.y, game.background)
1240
1241 override def toString = // bra vid println-debugging
1242 body.map(p => (p.x, p.y)).mkString(">:)", "~", s" going $dir")
1243}
1244
1245
1246package snake
1247import introprog.BlockGame
1248
1249abstract class SnakeGame(title: String) extends BlockGame(
1250 title, dim = (50, 30), blockSize = 15, background = Colors.Background,
1251 framesPerSecond = 50, messageAreaHeight = 3
1252) {
1253 var entities: Vector[Entity] = Vector.empty //Vector(new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))
1254
1255 var players: Vector[Player] = Vector(Player("P1", "a", "s", "d", "w", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
1256 Player("P2", "j", "k", "l", "i", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)))
1257//ska egentligen stå Vector.empty på players
1258 sealed trait State
1259 case object Starting extends State
1260 case object Playing extends State
1261 case object GameOver extends State
1262 case object Quitting extends State
1263
1264 var state: State = Starting
1265
1266 def enterStartingState(): Unit = {
1267 pixelWindow.clear() //VARFÖR INTE BLOCKGAMES.CLEARWINDOW?
1268 println("Tryck <SPACE> för att starta")
1269 state = Starting
1270 } // rensa, meddela "tryck space för start"
1271
1272 def enterPlayingState(): Unit = {
1273 pixelWindow.clear()
1274 entities.foreach(_.draw) //rita ut alla enheter, kontrollera!!!!!!!!!!!!!
1275 state = Playing
1276 } // rensa, rita alla entiteter
1277
1278 def enterGameOverState(): Unit = {
1279 println("Game Over")
1280 state = GameOver
1281 } // meddela "game over"
1282
1283 def enterQuittingState(): Unit = {
1284 println("Goodbye!")
1285 pixelWindow.hide()
1286 state = Quitting
1287 }
1288//dim här under är hårdkodat? men den givna koden var också det?
1289 def randomFreePos(): Pos = {
1290 var posCheck = Pos.random(dim = Dim(50,30))
1291 while(pixelWindow.getPixel(posCheck.x, posCheck.y) != java.awt.Color.black) { //tar för lång tid, blir ej 50 fps, testa this
1292 posCheck = Pos.random(dim = Dim(50, 30))
1293 }
1294 posCheck
1295 }
1296
1297 // dra slump-pos tills ledig plats, används av frukt, ta hjälp av pair uppgift g
1298
1299 override def onKeyDown(key: String): Unit = {
1300 println(s"""key "$key" pressed""")
1301 state match {
1302 case Starting => if (key == " ") enterPlayingState() //om man trycker på SPACE kommer man till Playing state under
1303 case Playing => players.foreach(_.handleKey(key)) //ändrar om direction för Player
1304 case GameOver =>
1305 if (key == " ") enterPlayingState()
1306 else if(key == "Escape") enterQuittingState()
1307 case _ =>
1308 }
1309 }
1310
1311 override def onClose(): Unit = enterQuittingState()
1312
1313 def isGameOver(): Boolean // abstrakt metod, implementeras i subklass
1314
1315 override def gameLoopAction(): Unit = {//denna metoden kallas varje loop i gameLoop
1316 ()
1317 }
1318
1319 def startGameLoop(): Unit = {
1320 pixelWindow.show() // möjliggör omstart även om fönstret stängts...
1321 enterStartingState()
1322 gameLoop(stopWhen = state == Quitting)
1323 }
1324
1325 def play(playerNames: String*): Unit // abstrakt, implementeras i subklass
1326}
1327
1328
1329package snake
1330
1331class TwoPlayerGame extends SnakeGame(title = "Hej") { // ska ärva SnakeGame
1332 override def isGameOver(): Boolean = false
1333 /*var players: Vector[Player] = Vector(Player("P1", "a", "s", "d", "w", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
1334 Player("P2", "j", "k", "l", "i", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))) //Vector(Player(...), Player(...)//Lägg till Players här.
1335 *///Vector(Player("P1", "a", "s", "d", "w", Snake(Pos(10, 10, Dim(50,30)), Dir(0,1), java.awt.Color.white, java.awt.Color.white, SnakeGame("hej"))))
1336
1337 players = Vector(Player("P1", "a", "s", "d", "w", new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)),
1338 Player("P2", "j", "k", "l", "i", new Snake(Pos(20, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this)))
1339
1340 entities = Vector(new Snake(Pos(10, 10, Dim(50,30)), North, java.awt.Color.white, java.awt.Color.white, this))
1341
1342 // ormar och ev. äpple, bananer etc
1343
1344 override def play(playerNames: String*): Unit = {
1345 println(playerNames) // ska överskugga play i SnakeGame
1346 startGameLoop
1347
1348 }
1349
1350
1351
1352}