14160288863

Committed 30 Mar 2025 09:50PM UTC coverage: 66.212% (+10.6%) from 55.621%

Build # 14160288863

Build Type

Pull #21

github

Committed by

web-flow

Commit Message

Merge b44f1188e into 54ebcb63e

Pull Request Pull Request #21: Se 12 file io

Run Details

164 of 272 branches covered (60.29%)

Branch coverage included in aggregate %.

217 of 231 new or added lines in 11 files covered. (93.94%)

206 existing lines in 8 files now uncovered.

1000 of 1486 relevant lines covered (67.29%)

0.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.0

/src/main/scala/controller/controllerComponent/Controller.scala

package controller.controllerComponent

import com.google.inject.Inject
import model.gameComponent.{GameInterface, GameState}
import util.Event.*
import util.fileIOComponent.FileIOInterface
import util.{Event, Observable, Observer}
import util.fileIOComponent.JSON.FileIOJSON

case class Controller @Inject (var game: GameInterface, fileIO: FileIOInterface) extends ControllerInterface with Observable {

  override def getGame: GameInterface = game

  override def saveGame(): Unit = {
    fileIO.save(game)
    notifyObservers(Event.save)
  }

  override def loadGame(): Unit = {
    game = fileIO.load()
    notifyObservers(Event.load)
  }

  override def initializeGame(): Unit = {
    game = game.initialize
    notifyObservers(Event.start)
    saveGame()
  }

  override def startGame(): Unit = {
    if ((game.getState == GameState.Initialized || game.getState == GameState.Evaluated) && game.getPlayers.nonEmpty) {
      game = game.startGame
      notifyObservers(Event.start)
      saveGame()
    } else {
      notifyObservers(Event.invalidCommand)
    }
  }

  override def addPlayer(name: String): Unit = {
    if (game.getState == GameState.Initialized || game.getState == GameState.Evaluated) {
      if(game.getPlayers.exists(_.getName == name)) {
        notifyObservers(Event.errPlayerNameExists)
      } else {
        game = game.createPlayer(name)
        notifyObservers(Event.addPlayer)
        saveGame()
      }
    } else {
      notifyObservers(Event.invalidCommand)
    }

  }

  override def leavePlayer(): Unit = {
    if(game.getPlayers.nonEmpty) {
        game = game.leavePlayer()
        notifyObservers(Event.leavePlayer)
        saveGame()
    } else {
      notifyObservers(invalidCommand)
    }
  }

  override def hitNextPlayer(): Unit = {
    val player = game.getPlayers(game.getIndex)
    if (player.getHand.canHit && game.getState == GameState.Started) {
      game = game.hitPlayer
      notifyObservers(Event.hitNextPlayer)
      saveGame()
    } else {
      notifyObservers(Event.invalidCommand)
    }

  }

  override def standNextPlayer(): Unit = {
    if (game.getState == GameState.Started) {
      game = game.standPlayer
      notifyObservers(Event.standNextPlayer)
      saveGame()
    } else {
      notifyObservers(Event.invalidCommand)
    }

  }

  override def doubleDown(): Unit = {
    val player = game.getPlayers(game.getIndex)

    if (game.getState == GameState.Started && player.getHand.canDoubleDown && player.getBet <= player.getMoney) {
      game = game.doubleDownPlayer
      notifyObservers(Event.doubleDown)
      saveGame()
    } else {
      notifyObservers(Event.invalidBet)
    }
  }

  override def bet(amount: String): Unit = {
    if (game.getState == GameState.Betting) {
      try {
        if (game.isValidBet(amount.toInt) && amount.toInt > 0) {
          game = game.betPlayer(amount.toInt)
          notifyObservers(Event.bet)
          saveGame()
        } else {
          notifyObservers(Event.invalidBet)
        }
      } catch {
        case _: NumberFormatException => notifyObservers(Event.invalidCommand)
      }
    } else {
      notifyObservers(Event.invalidCommand)
    }
  }

  override def exit(): Unit = {
    saveGame()
    sys.exit(0)
  }

  override def toString: String = {
    game.toString
  }
}

1	package controller.controllerComponent
2
3	import com.google.inject.Inject
4	import model.gameComponent.{GameInterface, GameState}
5	import util.Event.*
6	import util.fileIOComponent.FileIOInterface
7	import util.{Event, Observable, Observer}
8	import util.fileIOComponent.JSON.FileIOJSON
9
10	case class Controller @Inject (var game: GameInterface, fileIO: FileIOInterface) extends ControllerInterface with Observable {
11
12	override def getGame: GameInterface = game	1✔
13
14	override def saveGame(): Unit = {	1✔
15	fileIO.save(game)	1✔
16	notifyObservers(Event.save)	1✔
17	}
18
19	override def loadGame(): Unit = {	1✔
20	game = fileIO.load()	1✔
21	notifyObservers(Event.load)	1✔
22	}
23
24	override def initializeGame(): Unit = {	1✔
25	game = game.initialize	1✔
26	notifyObservers(Event.start)	1✔
27	saveGame()	1✔
28	}
29
30	override def startGame(): Unit = {	1✔
31	if ((game.getState == GameState.Initialized \|\| game.getState == GameState.Evaluated) && game.getPlayers.nonEmpty) {	1✔
32	game = game.startGame	1✔
33	notifyObservers(Event.start)	1✔
34	saveGame()	1✔
35	} else {	1✔
36	notifyObservers(Event.invalidCommand)	1✔
37	}
38	}
39
40	override def addPlayer(name: String): Unit = {	1✔
41	if (game.getState == GameState.Initialized \|\| game.getState == GameState.Evaluated) {	1✔
42	if(game.getPlayers.exists(_.getName == name)) {	1✔
43	notifyObservers(Event.errPlayerNameExists)	1✔
44	} else {	1✔
45	game = game.createPlayer(name)	1✔
46	notifyObservers(Event.addPlayer)	1✔
47	saveGame()	1✔
48	}
49	} else {	1✔
50	notifyObservers(Event.invalidCommand)	1✔
51	}
52
53	}
54
55	override def leavePlayer(): Unit = {	1✔
56	if(game.getPlayers.nonEmpty) {	1✔
57	game = game.leavePlayer()	1✔
58	notifyObservers(Event.leavePlayer)	1✔
59	saveGame()	1✔
60	} else {	1✔
61	notifyObservers(invalidCommand)	1✔
62	}
63	}
64
65	override def hitNextPlayer(): Unit = {	1✔
66	val player = game.getPlayers(game.getIndex)	1✔
67	if (player.getHand.canHit && game.getState == GameState.Started) {	1✔
68	game = game.hitPlayer	1✔
69	notifyObservers(Event.hitNextPlayer)	1✔
70	saveGame()	1✔
71	} else {	1✔
72	notifyObservers(Event.invalidCommand)	1✔
73	}
74
75	}
76
77	override def standNextPlayer(): Unit = {	1✔
78	if (game.getState == GameState.Started) {	1✔
79	game = game.standPlayer	1✔
80	notifyObservers(Event.standNextPlayer)	1✔
81	saveGame()	1✔
82	} else {	1✔
83	notifyObservers(Event.invalidCommand)	1✔
84	}
85
86	}
87
88	override def doubleDown(): Unit = {	1✔
89	val player = game.getPlayers(game.getIndex)	1✔
90
91	if (game.getState == GameState.Started && player.getHand.canDoubleDown && player.getBet <= player.getMoney) {	1✔
92	game = game.doubleDownPlayer	1✔
93	notifyObservers(Event.doubleDown)	1✔
94	saveGame()	1✔
95	} else {	1✔
96	notifyObservers(Event.invalidBet)	1✔
97	}
98	}
99
100	override def bet(amount: String): Unit = {	1✔
101	if (game.getState == GameState.Betting) {	1✔
102	try {	1✔
103	if (game.isValidBet(amount.toInt) && amount.toInt > 0) {	1✔
104	game = game.betPlayer(amount.toInt)	1✔
105	notifyObservers(Event.bet)	1✔
106	saveGame()	1✔
107	} else {	1✔
108	notifyObservers(Event.invalidBet)	1✔
109	}
110	} catch {
111	case _: NumberFormatException => notifyObservers(Event.invalidCommand)	1✔
112	}
113	} else {	1✔
114	notifyObservers(Event.invalidCommand)	1✔
115	}
116	}
117
118	override def exit(): Unit = {	×
NEW 119	saveGame()	×
UNCOV 120	sys.exit(0)	×
121	}
122
123	override def toString: String = {	1✔
124	game.toString	1✔
125	}
126	}

globuli94 / blackjack / 14160288863

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous