src/app/components/add-game/add-game.component.ts

@@ -34,8 +34,8 @@ export class AddGameComponent implements OnInit {
 			team: Team.CONTRA,
 			gamePoints: 0,
 			finalCardScore: 0,
-			// foxesCaught: 1,
-			// wonLastTrickWithCharlie: true
+			foxesCaught: 1,
+			wonLastTrickWithCharlie: true
 		});
 		this.potentialPlayers.push({
 			firebonkId: 2,
@@ -384,18 +384,17 @@ export class AddGameComponent implements OnInit {
 	calculateCurrentScores(): void {
 		let gameScore: number = 0;
 
-		let winningTeam = this.getWinningTeamAndScore().team;
 		let winningTeamScore = this.getWinningTeamAndScore().score;
-		let unfulfilledAnnouncementPoints = this.checkUnfulfilledAnnouncements(winningTeam, winningTeamScore);
-		let isSoloPlay = this.checkIfSolo();
+		let winningTeam = this.getWinningTeamAndScore().team;
+		let unfulfilledAnnouncements = this.checkUnfulfilledAnnouncements(winningTeam, winningTeamScore);
+		let isSoloPlay = false;
 
 		// We are going to calculate the points for the winning team and then set all players points accordingly
 
-		if (unfulfilledAnnouncementPoints === 0) {
+		if(!unfulfilledAnnouncements) {
 			gameScore += this.calculateNormalScore(winningTeamScore, winningTeam);
 		} else {
-			gameScore += unfulfilledAnnouncementPoints;
-			winningTeam = winningTeam === Team.RE ? Team.CONTRA : Team.RE;
+			// TODO method to calculate game score for unfulfilled announcements
 		}
 
 		// Double Score in case of announcement
@@ -412,15 +411,10 @@ export class AddGameComponent implements OnInit {
 			gameScore += this.getCharliePoints(winningTeam);
 		}
 
-		this.setGameScores(gameScore, winningTeam, isSoloPlay);
+		// TODO: Game score in case of a solo
+		this.setGameScores(gameScore, winningTeam);
 	}
 
-	/**
-	 * Calculate the score according to card points and announcements in case of a "normal" game, so without unfulfilled announcements
-	 * @param winningTeamScore
-	 * @param winningTeam
-	 * @private
-	 */
 	private calculateNormalScore(winningTeamScore: number, winningTeam: Team): number {
 		let gameScore = 1; // 1 Point for Winning
 
@@ -508,14 +502,10 @@ export class AddGameComponent implements OnInit {
 	 * @param score The score to set
 	 * @param winningTeam The team that won
 	 */
-	setGameScores(score: number, winningTeam: Team, isSolo: boolean) {
+	setGameScores(score: number, winningTeam: Team) {
 		for (let player of this.actualPlayers) {
 			if (player.team === winningTeam) {
-				if(isSolo) {
-					player.gamePoints = score * 3;
-				} else {
 				player.gamePoints = score;
-				}
 			} else {
 				player.gamePoints = -score;
 			}
@@ -576,60 +566,34 @@ export class AddGameComponent implements OnInit {
 	}
 
 	/**
-	 * Checks if the winning team has made announcements that have not been fulfilled.
-	 * If so, returns the points that the "losing" team gets for these unfulfilled announcements
+	 * Checks if the winning team has made announcements that have not been fulfilled
 	 * @param normalWinningTeam The team that would have won under normal circumstances
 	 * @param normalWinningTeamScore The card score of said team
 	 */
-	checkUnfulfilledAnnouncements(normalWinningTeam: Team, normalWinningTeamScore: number): number {
-		let gamePoints = 0;
-
+	checkUnfulfilledAnnouncements(normalWinningTeam: Team, normalWinningTeamScore: number): boolean {
 		if(normalWinningTeam === Team.RE) {
 			if(this.checkAnnouncementActive(announcements.Announcement.RE_NO_NINETY) && normalWinningTeamScore < 151) {
-				gamePoints++;
+				return true;
 			}
 			if(this.checkAnnouncementActive(announcements.Announcement.RE_NO_SIXTY) && normalWinningTeamScore < 181) {
-				gamePoints++;
+				return true;
 			}
 			if(this.checkAnnouncementActive(announcements.Announcement.RE_NO_THIRTY) && normalWinningTeamScore < 211) {
-				gamePoints++;
+				return true;
 			}
 		}
 		if(normalWinningTeam === Team.CONTRA) {
 			if(this.checkAnnouncementActive(announcements.Announcement.CONTRA_NO_NINETY) && normalWinningTeamScore < 151) {
-				gamePoints++;
+				return true;
 			}
 			if(this.checkAnnouncementActive(announcements.Announcement.CONTRA_NO_SIXTY) && normalWinningTeamScore < 181) {
-				gamePoints++;
+				return true;
 			}
 			if(this.checkAnnouncementActive(announcements.Announcement.CONTRA_NO_THIRTY) && normalWinningTeamScore < 211) {
-				gamePoints++;
+				return true;
 			}
 		}
 
-		return gamePoints;
-	}
-
-	/**
-	 *    _____       __
-	 *   / ___/____  / /___
-	 *   \__ \/ __ \/ / __ \
-	 *  ___/ / /_/ / / /_/ /
-	 * /____/\____/_/\____/
-	 */
-
-	/**
-	 * Checks, according to the assigned Teams, if this is a solo play
-	 */
-	checkIfSolo(): boolean {
-		let numberOfElders: number = 0;
-
-		for(let player of this.actualPlayers) {
-			if(player.team === Team.RE) {
-				numberOfElders++;
-			}
-		}
-
-		return numberOfElders === 1;
+		return false;
 	}
 }