14116909189

Committed 27 Mar 2025 09:19PM UTC coverage: 55.292% (+12.4%) from 42.857%

Build # 14116909189

Build Type

Pull #17

github

Committed by

web-flow

Commit Message

Merge b8bae2ec8 into cc233430d

Pull Request Pull Request #17: Se 10 components

Run Details

117 of 221 branches covered (52.94%)

Branch coverage included in aggregate %.

156 of 188 new or added lines in 14 files covered. (82.98%)

245 existing lines in 8 files now uncovered.

630 of 1130 relevant lines covered (55.75%)

0.56 hits per line

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

96.67

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

package controller.controllerComponent

import model.gameComponent.{GameInterface, GameState}
import util.Event.invalidCommand
import util.{Event, Observable, Observer}

case class Controller(var game: GameInterface) extends ControllerInterface with Observable {

  override def getGame: GameInterface = game

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

  override def startGame(): Unit = {
    if ((game.getState == GameState.Initialized || game.getState == GameState.Evaluated) && game.getPlayers.nonEmpty) {
      game = game.startGame
      notifyObservers(Event.Start)
    } 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)
      }
    } else {
      notifyObservers(Event.invalidCommand)
    }
  }

  override def leavePlayer(): Unit = {
    if(game.getPlayers.nonEmpty) {
        game = game.leavePlayer()
        notifyObservers(Event.leavePlayer)
    } 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)
    } else {
      notifyObservers(Event.invalidCommand)
    }
  }

  override def standNextPlayer(): Unit = {
    if (game.getState == GameState.Started) {
      game = game.standPlayer
      notifyObservers(Event.standNextPlayer)
    } 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)
    } 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)
        } else {
          notifyObservers(Event.invalidBet)
        }
      } catch {
        case _: NumberFormatException => notifyObservers(Event.invalidCommand)
      }
    } else {
      notifyObservers(Event.invalidCommand)
    }
  }

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

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

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

globuli94 / blackjack / 14116909189

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