patri9ck / durak / #5

Committed 16 Jan 2025 01:26PM UTC coverage: 39.958% (-4.1%) from 44.107%

Build # #5

Build Type

push

travis-pro

Committed by

LaurinEngelen

Commit Message

Merge branch 'main' into improved-gui

# Conflicts:
#	README.md
#	src/main/scala/view/gui/Gui.scala

Coverage Stats

78 of 83 new or added lines in 14 files covered. (93.98%)

302 existing lines in 7 files now uncovered.

378 of 946 relevant lines covered (39.96%)

0.4 hits per line

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

69.23

/src/main/scala/controller/base/BaseController.scala

package controller.base

import com.google.inject.{Inject, Singleton}
import controller.Controller
import controller.base.command.*
import model.*
import model.io.FileIo
import model.status.{Status, StatusBuilder}
import util.{Observable, UndoManager}

import scala.annotation.tailrec
import scala.util.Random

@Singleton
class BaseController @Inject()(val fileIo: FileIo) extends Controller {

  private val undoManager = UndoManager()
  var status: Status = Status()

  def drawFromStack(statusBuilder: StatusBuilder): StatusBuilder = {
    val start = statusBuilder.getPassed.orElse(statusBuilder.byTurn(Turn.FirstlyAttacking)).map(statusBuilder.getPlayers.indexOf).get

    var updatedStack = statusBuilder.getStack
    var updatedPlayers = statusBuilder.getPlayers

    for (step <- statusBuilder.getPlayers.indices) {
      val index = (start - step + statusBuilder.getPlayers.size) % statusBuilder.getPlayers.size
      val player = statusBuilder.getPlayers(index)
      val amount = statusBuilder.getAmount - player.cards.length

      if (player.turn != Turn.Watching && amount > 0) {
        val (draw, remaining) = updatedStack.splitAt(amount)

        updatedStack = remaining
        updatedPlayers = updatedPlayers.updated(index, player.copy(cards = player.cards ++ draw))
      }
    }

    statusBuilder
      .setStack(updatedStack)
      .setPlayers(updatedPlayers)
      .removePassed()
  }

  def hasFinished(finished: Player, statusBuilder: StatusBuilder): Boolean = {
    if (finished.turn == Turn.Finished) {
      return true
    }

    if (finished.turn == Turn.FirstlyAttacking || finished.turn == Turn.SecondlyAttacking) {
      return statusBuilder.getStack.isEmpty && finished.cards.isEmpty
    }

    if (finished.turn == Turn.Defending) {
      return statusBuilder.getStack.isEmpty && statusBuilder.getUndefended.isEmpty && finished.cards.isEmpty
    }

    false
  }

  def finish(finished: Player, statusBuilder: StatusBuilder): StatusBuilder = {
    val updated = finished.copy(turn = Turn.Finished)

    var updatedStatusBuilder = statusBuilder.setPlayers(updatePlayers(statusBuilder.getPlayers, finished, updated))

    if (finished.turn == Turn.Defending) {
      updatedStatusBuilder = statusBuilder
        .setPlayers(chooseNextAttacking(updatedStatusBuilder.getPlayers, updated))
        .resetRound
    } else if (finished.turn == Turn.FirstlyAttacking && statusBuilder.byTurn(Turn.SecondlyAttacking).isEmpty || finished.turn == Turn.SecondlyAttacking) {
      updatedStatusBuilder = statusBuilder.setTurn(Turn.Defending)
    } else {
      updatedStatusBuilder = statusBuilder.setTurn(Turn.SecondlyAttacking)
    }

    updatedStatusBuilder
  }

  def chooseNextAttacking(players: List[Player], previous: Player): List[Player] =
    chooseAttacking(players, (players.indexOf(previous) - 1 + players.size) % players.size)

  def chooseAttacking(players: List[Player], index: Int): List[Player] = {
    players.zipWithIndex.map { case (player, idx) =>
      if (player.turn == Turn.Finished) {
        player
      } else {
        @tailrec
        def findPreviousActive(currentIndex: Int, steps: Int): Int = {
          if (steps == 0) currentIndex
          else {
            val prevIndex = (currentIndex - 1 + players.length) % players.length
            if (players(prevIndex).turn == Turn.Finished)
              findPreviousActive(prevIndex, steps)
            else
              findPreviousActive(prevIndex, steps - 1)
          }
        }

        val firstlyAttackingIndex = index
        val defendingIndex = findPreviousActive(firstlyAttackingIndex, 1)
        val secondlyAttackingIndex = findPreviousActive(defendingIndex, 1)

        if (idx == firstlyAttackingIndex) {
          player.copy(turn = Turn.FirstlyAttacking)
        } else if (idx == defendingIndex) {
          player.copy(turn = Turn.Defending)
        } else if (idx == secondlyAttackingIndex) {
          player.copy(turn = Turn.SecondlyAttacking)
        } else {
          player.copy(turn = Turn.Watching)
        }
      }
    }
  }

  def updatePlayers(players: List[Player], old: Player, updated: Player): List[Player] = {
    players.map { player =>
      if (old == player) {
        updated
      } else {
        player
      }
    }
  }

  override def initialize(amount: Int, names: List[String]): Unit = {
    initialize(amount, names, Random.shuffle(names).head)
  }

  override def initialize(amount: Int, names: List[String], attacking: String): Unit = {
    undoManager.doStep(InitializeCommand(this, amount, names, attacking))

    notifySubscribers()
  }

  override def deny(): Unit = {
    undoManager.doStep(DenyCommand(this))

    notifySubscribers()
  }

  override def pickUp(): Unit = {
    undoManager.doStep(PickUpCommand(this))

    notifySubscribers()
  }

  override def attack(card: Card): Unit = {
    undoManager.doStep(AttackCommand(this, card))

    notifySubscribers()
  }

  override def canAttack(card: Card): Boolean = {
    status.defended.isEmpty && status.undefended.isEmpty
      || status.used.exists(_.rank == card.rank)
      || status.defended.exists(_.rank == card.rank)
      || status.undefended.exists(_.rank == card.rank)
  }

  override def defend(used: Card, undefended: Card): Unit = {
    undoManager.doStep(DefendCommand(this, used, undefended))

    notifySubscribers()
  }

  override def canDefend(used: Card, undefended: Card): Boolean = {
    if (used.beats(undefended)) {
      return true
    }

    if (used.suit == status.trump.get.suit) {
      return undefended.suit != status.trump.get.suit
    }

    false
  }

  override def current: Option[Player] = byTurn(status.turn)

  override def byTurn(turn: Turn): Option[Player] = {
    status.players.find(_.turn == turn)
  }

  override def undo(): Unit = {
    undoManager.undoStep()

    notifySubscribers()
  }

  override def redo(): Unit = {
    undoManager.redoStep()

    notifySubscribers()
  }

  override def load(): Unit = {
    undoManager.doStep(LoadCommand(this, fileIo))

    notifySubscribers()
  }


  override def save(): Unit = {
    undoManager.doStep(SaveCommand(this, fileIo))

    notifySubscribers()
  }

  override def isOver: Boolean = status.players.count(_.turn != Turn.Finished) == 1

  override def unbind(): Unit = {
    fileIo.unbind()
  }
}

1	package controller.base
2
3	import com.google.inject.{Inject, Singleton}
4	import controller.Controller
5	import controller.base.command.*
6	import model.*
7	import model.io.FileIo
8	import model.status.{Status, StatusBuilder}
9	import util.{Observable, UndoManager}
10
11	import scala.annotation.tailrec
12	import scala.util.Random
13
14	@Singleton
15	class BaseController @Inject()(val fileIo: FileIo) extends Controller {
16
17	private val undoManager = UndoManager()	1✔
18	var status: Status = Status()	1✔
19
20	def drawFromStack(statusBuilder: StatusBuilder): StatusBuilder = {	1✔
21	val start = statusBuilder.getPassed.orElse(statusBuilder.byTurn(Turn.FirstlyAttacking)).map(statusBuilder.getPlayers.indexOf).get	1✔
22
23	var updatedStack = statusBuilder.getStack	1✔
24	var updatedPlayers = statusBuilder.getPlayers	1✔
25
26	for (step <- statusBuilder.getPlayers.indices) {	1✔
27	val index = (start - step + statusBuilder.getPlayers.size) % statusBuilder.getPlayers.size	1✔
28	val player = statusBuilder.getPlayers(index)	1✔
29	val amount = statusBuilder.getAmount - player.cards.length	1✔
30
31	if (player.turn != Turn.Watching && amount > 0) {	1✔
32	val (draw, remaining) = updatedStack.splitAt(amount)	1✔
33
34	updatedStack = remaining
35	updatedPlayers = updatedPlayers.updated(index, player.copy(cards = player.cards ++ draw))	1✔
36	}	1✔
37	}
38
39	statusBuilder
40	.setStack(updatedStack)	1✔
41	.setPlayers(updatedPlayers)	1✔
42	.removePassed()	1✔
43	}
44
45	def hasFinished(finished: Player, statusBuilder: StatusBuilder): Boolean = {	1✔
46	if (finished.turn == Turn.Finished) {	1✔
47	return true
48	}	1✔
49
50	if (finished.turn == Turn.FirstlyAttacking \|\| finished.turn == Turn.SecondlyAttacking) {	1✔
51	return statusBuilder.getStack.isEmpty && finished.cards.isEmpty	1✔
52	}	1✔
53
54	if (finished.turn == Turn.Defending) {	1✔
55	return statusBuilder.getStack.isEmpty && statusBuilder.getUndefended.isEmpty && finished.cards.isEmpty	1✔
56	}	1✔
57
58	false
59	}
60
61	def finish(finished: Player, statusBuilder: StatusBuilder): StatusBuilder = {	1✔
62	val updated = finished.copy(turn = Turn.Finished)
63
64	var updatedStatusBuilder = statusBuilder.setPlayers(updatePlayers(statusBuilder.getPlayers, finished, updated))	1✔
65
66	if (finished.turn == Turn.Defending) {	1✔
67	updatedStatusBuilder = statusBuilder
68	.setPlayers(chooseNextAttacking(updatedStatusBuilder.getPlayers, updated))	1✔
69	.resetRound	1✔
70	} else if (finished.turn == Turn.FirstlyAttacking && statusBuilder.byTurn(Turn.SecondlyAttacking).isEmpty \|\| finished.turn == Turn.SecondlyAttacking) {	1✔
71	updatedStatusBuilder = statusBuilder.setTurn(Turn.Defending)	1✔
72	} else {	1✔
73	updatedStatusBuilder = statusBuilder.setTurn(Turn.SecondlyAttacking)	1✔
74	}
75
76	updatedStatusBuilder
77	}
78
79	def chooseNextAttacking(players: List[Player], previous: Player): List[Player] =	1✔
80	chooseAttacking(players, (players.indexOf(previous) - 1 + players.size) % players.size)	1✔
81
82	def chooseAttacking(players: List[Player], index: Int): List[Player] = {	1✔
83	players.zipWithIndex.map { case (player, idx) =>	1✔
84	if (player.turn == Turn.Finished) {	1✔
85	player
86	} else {	1✔
87	@tailrec
88	def findPreviousActive(currentIndex: Int, steps: Int): Int = {	1✔
89	if (steps == 0) currentIndex	1✔
90	else {	1✔
91	val prevIndex = (currentIndex - 1 + players.length) % players.length	1✔
92	if (players(prevIndex).turn == Turn.Finished)	1✔
93	findPreviousActive(prevIndex, steps)	1✔
94	else
95	findPreviousActive(prevIndex, steps - 1)	1✔
96	}
97	}
98
99	val firstlyAttackingIndex = index
100	val defendingIndex = findPreviousActive(firstlyAttackingIndex, 1)	1✔
101	val secondlyAttackingIndex = findPreviousActive(defendingIndex, 1)	1✔
102
103	if (idx == firstlyAttackingIndex) {	1✔
104	player.copy(turn = Turn.FirstlyAttacking)
105	} else if (idx == defendingIndex) {	1✔
106	player.copy(turn = Turn.Defending)
107	} else if (idx == secondlyAttackingIndex) {	1✔
108	player.copy(turn = Turn.SecondlyAttacking)
109	} else {	1✔
110	player.copy(turn = Turn.Watching)
111	}
112	}
113	}
114	}
115
116	def updatePlayers(players: List[Player], old: Player, updated: Player): List[Player] = {	1✔
117	players.map { player =>	1✔
118	if (old == player) {	1✔
119	updated
120	} else {	1✔
121	player
122	}
123	}
124	}
125
UNCOV 126	override def initialize(amount: Int, names: List[String]): Unit = {	×
UNCOV 127	initialize(amount, names, Random.shuffle(names).head)	×
128	}
129
130	override def initialize(amount: Int, names: List[String], attacking: String): Unit = {	×
131	undoManager.doStep(InitializeCommand(this, amount, names, attacking))	×
132
UNCOV 133	notifySubscribers()	×
134	}
135
UNCOV 136	override def deny(): Unit = {	×
137	undoManager.doStep(DenyCommand(this))	×
138
UNCOV 139	notifySubscribers()	×
140	}
141
UNCOV 142	override def pickUp(): Unit = {	×
143	undoManager.doStep(PickUpCommand(this))	×
144
UNCOV 145	notifySubscribers()	×
146	}
147
UNCOV 148	override def attack(card: Card): Unit = {	×
149	undoManager.doStep(AttackCommand(this, card))	×
150
UNCOV 151	notifySubscribers()	×
152	}
153
154	override def canAttack(card: Card): Boolean = {	1✔
155	status.defended.isEmpty && status.undefended.isEmpty	1✔
156	\|\| status.used.exists(_.rank == card.rank)	1✔
157	\|\| status.defended.exists(_.rank == card.rank)	1✔
158	\|\| status.undefended.exists(_.rank == card.rank)	1✔
159	}
160
UNCOV 161	override def defend(used: Card, undefended: Card): Unit = {	×
UNCOV 162	undoManager.doStep(DefendCommand(this, used, undefended))	×
163
UNCOV 164	notifySubscribers()	×
165	}
166
167	override def canDefend(used: Card, undefended: Card): Boolean = {	1✔
168	if (used.beats(undefended)) {	1✔
169	return true
170	}	1✔
171
172	if (used.suit == status.trump.get.suit) {	1✔
173	return undefended.suit != status.trump.get.suit	1✔
174	}	1✔
175
176	false
177	}
178
179	override def current: Option[Player] = byTurn(status.turn)	1✔
180
181	override def byTurn(turn: Turn): Option[Player] = {	1✔
182	status.players.find(_.turn == turn)	1✔
183	}
184
UNCOV 185	override def undo(): Unit = {	×
UNCOV 186	undoManager.undoStep()	×
187
UNCOV 188	notifySubscribers()	×
189	}
190
UNCOV 191	override def redo(): Unit = {	×
192	undoManager.redoStep()	×
193
UNCOV 194	notifySubscribers()	×
195	}
196
UNCOV 197	override def load(): Unit = {	×
198	undoManager.doStep(LoadCommand(this, fileIo))	×
199
UNCOV 200	notifySubscribers()	×
201	}
202
203
204	override def save(): Unit = {	×
UNCOV 205	undoManager.doStep(SaveCommand(this, fileIo))	×
206
UNCOV 207	notifySubscribers()	×
208	}
209
NEW 210	override def isOver: Boolean = status.players.count(_.turn != Turn.Finished) == 1	×
211
212	override def unbind(): Unit = {	×
213	fileIo.unbind()	×
214	}
215	}

patri9ck / durak / #5

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