655 lines
18 KiB
TypeScript
655 lines
18 KiB
TypeScript
import {Component, OnInit} from '@angular/core';
|
|
import {Player} from '../../models/doppelkopf/player';
|
|
import * as announcements from '../../models/doppelkopf/enums/announcement';
|
|
import * as solos from '../../models/doppelkopf/enums/solo';
|
|
import {Team} from '../../models/doppelkopf/enums/team';
|
|
|
|
@Component({
|
|
selector: 'app-add-game',
|
|
templateUrl: './add-game.component.html',
|
|
styleUrls: ['./add-game.component.scss']
|
|
})
|
|
export class AddGameComponent implements OnInit {
|
|
potentialPlayers: Player[] = [];
|
|
actualPlayers: Player[] = [];
|
|
|
|
selectedAnnouncements: announcements.Announcement[] = [];
|
|
soloPlayed?: solos.Solo;
|
|
|
|
currentPage: number = 0;
|
|
|
|
constructor() {
|
|
this.generateDemoData();
|
|
}
|
|
|
|
ngOnInit(): void {
|
|
}
|
|
|
|
/**
|
|
* Generates demo data to test the UI
|
|
*/
|
|
generateDemoData() {
|
|
this.potentialPlayers.push({
|
|
firebonkId: 1,
|
|
uuid: 'abc-def-ghi-j',
|
|
firstName: 'Patrick',
|
|
team: Team.CONTRA,
|
|
gamePoints: 0,
|
|
finalCardScore: 0,
|
|
// foxesCaught: 1,
|
|
// wonLastTrickWithCharlie: true
|
|
});
|
|
this.potentialPlayers.push({
|
|
firebonkId: 2,
|
|
uuid: 'abc-def-ghi-k',
|
|
firstName: 'Julian',
|
|
team: Team.CONTRA,
|
|
gamePoints: 0,
|
|
finalCardScore: 0
|
|
});
|
|
this.potentialPlayers.push({
|
|
firebonkId: 3,
|
|
uuid: 'abc-def-ghi-l',
|
|
firstName: 'Yannick',
|
|
team: Team.CONTRA,
|
|
gamePoints: 0,
|
|
finalCardScore: 0
|
|
});
|
|
this.potentialPlayers.push({
|
|
firebonkId: 4,
|
|
uuid: 'abc-def-ghi-m',
|
|
firstName: 'Janina',
|
|
team: Team.CONTRA,
|
|
gamePoints: 0,
|
|
finalCardScore: 0
|
|
});
|
|
this.potentialPlayers.push({
|
|
firebonkId: 5,
|
|
uuid: 'abc-def-ghi-n',
|
|
firstName: 'Moritz',
|
|
team: Team.CONTRA,
|
|
gamePoints: 0,
|
|
finalCardScore: 0
|
|
});
|
|
|
|
this.actualPlayers.push(...this.potentialPlayers.slice(0, 4));
|
|
}
|
|
|
|
/**
|
|
* Switches the entry mask UI to the next page
|
|
*/
|
|
switchToNextPage(): void {
|
|
if (this.currentPage >= 4) {
|
|
this.calculateCurrentScores();
|
|
}
|
|
|
|
if(this.currentPage === 3 && !this.checkIfSolo()) {
|
|
// If we don't play a solo, we can skip the solo page
|
|
this.currentPage++;
|
|
}
|
|
|
|
this.currentPage++;
|
|
}
|
|
|
|
/**
|
|
* ____ __
|
|
* / __ \/ /___ ___ _____ __________
|
|
* / /_/ / / __ `/ / / / _ \/ ___/ ___/
|
|
* / ____/ / /_/ / /_/ / __/ / (__ )
|
|
* /_/ /_/\__,_/\__, /\___/_/ /____/
|
|
* /____/
|
|
*/
|
|
|
|
/**
|
|
* Toggles if the given player is should be an active player for the current game
|
|
* @param player The player to toggle the activity for
|
|
*/
|
|
togglePlayer(player: Player): void {
|
|
let index = this.actualPlayers.indexOf(player);
|
|
if (index !== -1) {
|
|
this.actualPlayers.splice(index, 1);
|
|
} else {
|
|
this.actualPlayers.push(player);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks, if the given player is currently marked as active for this game
|
|
* @param player The player to check the activity status for
|
|
* @returns boolean If the player is active
|
|
*/
|
|
isPlayerActive(player: Player): boolean {
|
|
return this.actualPlayers.indexOf(player) !== -1;
|
|
}
|
|
|
|
/**
|
|
* Returns, if the amount of currently active players is greater or less than 4
|
|
*/
|
|
not4Players() {
|
|
return this.actualPlayers.length !== 4;
|
|
}
|
|
|
|
/**
|
|
* Returns the names of the active players as a comma-separated string
|
|
*/
|
|
getPlayerNamesAsString(): string {
|
|
let playerNames = '';
|
|
for (let player of this.actualPlayers) {
|
|
playerNames += player.firstName + ', ';
|
|
}
|
|
// Remove last ", "
|
|
return playerNames.substring(0, playerNames.length - 2);
|
|
}
|
|
|
|
/**
|
|
* ___ __
|
|
* / | ____ ____ ____ __ ______ ________ ____ ___ ___ ____ / /______
|
|
* / /| | / __ \/ __ \/ __ \/ / / / __ \/ ___/ _ \/ __ `__ \/ _ \/ __ \/ __/ ___/
|
|
* / ___ |/ / / / / / / /_/ / /_/ / / / / /__/ __/ / / / / / __/ / / / /_(__ )
|
|
* /_/ |_/_/ /_/_/ /_/\____/\__,_/_/ /_/\___/\___/_/ /_/ /_/\___/_/ /_/\__/____/
|
|
*/
|
|
|
|
/**
|
|
* Toggles the activity status for the given announcement and also activates / deactivates other announcements
|
|
* to conform to the rules.
|
|
* @param announcement The announcement to toggle activity for
|
|
*/
|
|
toggleAnnouncement(announcement: announcements.Announcement): void {
|
|
let index = this.selectedAnnouncements.indexOf(announcement);
|
|
if (index !== -1) {
|
|
this.selectedAnnouncements.splice(index, 1);
|
|
this.deactivateLowerAnnouncements(announcement);
|
|
} else {
|
|
this.selectedAnnouncements.push(announcement);
|
|
this.activateHigherAnnouncements(announcement);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deactivates all lower announcements. E.g.: When RE is deactivated, RE_NO_NINETY and all lower also get deactivated
|
|
* @param announcement The announcement that has been deactivated
|
|
*/
|
|
deactivateLowerAnnouncements(announcement: announcements.Announcement) {
|
|
// First for RE
|
|
switch (announcement) {
|
|
case announcements.Announcement.RE:
|
|
this.deactivateAnnouncement(announcements.Announcement.RE_NO_NINETY);
|
|
this.deactivateAnnouncement(announcements.Announcement.RE_NO_SIXTY);
|
|
this.deactivateAnnouncement(announcements.Announcement.RE_NO_THIRTY);
|
|
break;
|
|
case announcements.Announcement.RE_NO_NINETY:
|
|
this.deactivateAnnouncement(announcements.Announcement.RE_NO_SIXTY);
|
|
this.deactivateAnnouncement(announcements.Announcement.RE_NO_THIRTY);
|
|
break;
|
|
case announcements.Announcement.RE_NO_SIXTY:
|
|
this.deactivateAnnouncement(announcements.Announcement.RE_NO_THIRTY);
|
|
break;
|
|
}
|
|
|
|
// Now for CONTRA
|
|
switch (announcement) {
|
|
case announcements.Announcement.CONTRA:
|
|
this.deactivateAnnouncement(announcements.Announcement.CONTRA_NO_NINETY);
|
|
this.deactivateAnnouncement(announcements.Announcement.CONTRA_NO_SIXTY);
|
|
this.deactivateAnnouncement(announcements.Announcement.CONTRA_NO_THIRTY);
|
|
break;
|
|
case announcements.Announcement.CONTRA_NO_NINETY:
|
|
this.deactivateAnnouncement(announcements.Announcement.CONTRA_NO_SIXTY);
|
|
this.deactivateAnnouncement(announcements.Announcement.CONTRA_NO_THIRTY);
|
|
break;
|
|
case announcements.Announcement.CONTRA_NO_SIXTY:
|
|
this.deactivateAnnouncement(announcements.Announcement.CONTRA_NO_THIRTY);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deactivates the given announcement if it is active
|
|
* @param announcement The announcement to deactivate
|
|
*/
|
|
deactivateAnnouncement(announcement: announcements.Announcement) {
|
|
let index = this.selectedAnnouncements.indexOf(announcement);
|
|
if (index !== -1) {
|
|
this.selectedAnnouncements.splice(index, 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Activates all higher announcements. E.g.: When RE_NO_NINETY is activated, RE also gets activated
|
|
* @param announcement The announcement that has been activated
|
|
*/
|
|
activateHigherAnnouncements(announcement: announcements.Announcement) {
|
|
// First for RE
|
|
switch (announcement) {
|
|
case announcements.Announcement.RE_NO_THIRTY:
|
|
this.activateAnnouncement(announcements.Announcement.RE_NO_SIXTY);
|
|
this.activateAnnouncement(announcements.Announcement.RE_NO_NINETY);
|
|
this.activateAnnouncement(announcements.Announcement.RE);
|
|
break;
|
|
case announcements.Announcement.RE_NO_SIXTY:
|
|
this.activateAnnouncement(announcements.Announcement.RE_NO_NINETY);
|
|
this.activateAnnouncement(announcements.Announcement.RE);
|
|
break;
|
|
case announcements.Announcement.RE_NO_NINETY:
|
|
this.activateAnnouncement(announcements.Announcement.RE);
|
|
break;
|
|
}
|
|
|
|
// Now for CONTRA
|
|
switch (announcement) {
|
|
case announcements.Announcement.CONTRA_NO_THIRTY:
|
|
this.activateAnnouncement(announcements.Announcement.CONTRA_NO_SIXTY);
|
|
this.activateAnnouncement(announcements.Announcement.CONTRA_NO_NINETY);
|
|
this.activateAnnouncement(announcements.Announcement.CONTRA);
|
|
break;
|
|
case announcements.Announcement.CONTRA_NO_SIXTY:
|
|
this.activateAnnouncement(announcements.Announcement.CONTRA_NO_NINETY);
|
|
this.activateAnnouncement(announcements.Announcement.CONTRA);
|
|
break;
|
|
case announcements.Announcement.CONTRA_NO_NINETY:
|
|
this.activateAnnouncement(announcements.Announcement.CONTRA);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Activates the given announcement if it is inactive
|
|
* @param announcement The announcement to activate
|
|
*/
|
|
activateAnnouncement(announcement: announcements.Announcement) {
|
|
let index = this.selectedAnnouncements.indexOf(announcement);
|
|
if (index === -1) {
|
|
this.selectedAnnouncements.push(announcement);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if the given announcement is already marked as selected
|
|
* @param announcement The announcement to check the status for
|
|
*/
|
|
isAnnouncementActive(announcement: announcements.Announcement): boolean {
|
|
return this.selectedAnnouncements.indexOf(announcement) !== -1;
|
|
}
|
|
|
|
/**
|
|
* Returns a list of all possible announcements
|
|
*/
|
|
getAllPossibleAnnouncements(): announcements.Announcement[] {
|
|
return announcements.getAllAnnouncementValues();
|
|
}
|
|
|
|
/**
|
|
* Checks, if the currently selected announcements are a valid set of announcements
|
|
*/
|
|
checkAnnouncementsValid(): boolean {
|
|
return announcements.checkValidity(this.selectedAnnouncements);
|
|
}
|
|
|
|
/**
|
|
* Returns the two highest announcements for this game (one for RE, one for CONTRA, if applicable)
|
|
*/
|
|
getHighestAnnouncements(): string {
|
|
return announcements.returnTwoHighestAnnouncements(this.selectedAnnouncements);
|
|
}
|
|
|
|
/**
|
|
* Checks if the given announcement has been selected
|
|
* @param announcement The announcement to check
|
|
*/
|
|
checkAnnouncementActive(announcement: announcements.Announcement): boolean {
|
|
let index = this.selectedAnnouncements.indexOf(announcement);
|
|
return index !== -1;
|
|
}
|
|
|
|
/**
|
|
* ______
|
|
* /_ __/__ ____ _____ ___ _____
|
|
* / / / _ \/ __ `/ __ `__ \/ ___/
|
|
* / / / __/ /_/ / / / / / (__ )
|
|
* /_/ \___/\__,_/_/ /_/ /_/____/
|
|
*/
|
|
|
|
/**
|
|
* Toggles the players team
|
|
* @param player The player to toggle the team for
|
|
*/
|
|
toggleElderPlayer(player: Player): void {
|
|
if (player.team === Team.RE) {
|
|
player.team = Team.CONTRA;
|
|
} else {
|
|
player.team = Team.RE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if the player is an elder
|
|
* @param player The player to check
|
|
*/
|
|
isPlayerElder(player: Player): boolean {
|
|
return player.team === Team.RE;
|
|
}
|
|
|
|
/**
|
|
* Checks if the current team assignment is valid
|
|
*/
|
|
checkValidTeamAssignment(): boolean {
|
|
let numberOfElderPlayers: number = 0;
|
|
for (let player of this.actualPlayers) {
|
|
if (player.team === Team.RE) {
|
|
numberOfElderPlayers++;
|
|
}
|
|
}
|
|
|
|
return !(numberOfElderPlayers !== 1 && numberOfElderPlayers !== 2);
|
|
}
|
|
|
|
/**
|
|
* _____
|
|
* / ___/_________ ________ _____
|
|
* \__ \/ ___/ __ \/ ___/ _ \/ ___/
|
|
* ___/ / /__/ /_/ / / / __(__ )
|
|
* /____/\___/\____/_/ \___/____/
|
|
*/
|
|
|
|
/**
|
|
* Checks if the sum of all points is exactly 240
|
|
*/
|
|
calculatePointSum(): number {
|
|
let totalScore: number = 0;
|
|
for (let player of this.actualPlayers) {
|
|
totalScore += player.finalCardScore ?? 0;
|
|
}
|
|
|
|
return totalScore;
|
|
}
|
|
|
|
/**
|
|
* Generates a string that explains if the total point sum is too low / too high
|
|
*/
|
|
getScoreDifferenceText(): string {
|
|
let difference = this.calculatePointSum() - 240;
|
|
|
|
if (difference > 0) {
|
|
return difference + ' more than expected';
|
|
} else {
|
|
difference *= -1;
|
|
return difference + ' less than expected';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ______ _____
|
|
* / ____/___ _____ ___ ___ / ___/_________ ________
|
|
* / / __/ __ `/ __ `__ \/ _ \ \__ \/ ___/ __ \/ ___/ _ \
|
|
* / /_/ / /_/ / / / / / / __/ ___/ / /__/ /_/ / / / __/
|
|
* \____/\__,_/_/ /_/ /_/\___/ /____/\___/\____/_/ \___/
|
|
*/
|
|
|
|
/**
|
|
* Calculates the game points for all players
|
|
*/
|
|
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();
|
|
|
|
// We are going to calculate the points for the winning team and then set all players points accordingly
|
|
|
|
if (unfulfilledAnnouncementPoints === 0) {
|
|
gameScore += this.calculateNormalScore(winningTeamScore, winningTeam);
|
|
} else {
|
|
gameScore += unfulfilledAnnouncementPoints;
|
|
winningTeam = winningTeam === Team.RE ? Team.CONTRA : Team.RE;
|
|
}
|
|
|
|
// Double Score in case of announcement
|
|
if (this.checkAnnouncementActive(announcements.Announcement.RE)) {
|
|
gameScore *= 2;
|
|
}
|
|
if (this.checkAnnouncementActive(announcements.Announcement.CONTRA)) {
|
|
gameScore *= 2;
|
|
}
|
|
|
|
// Bonus points
|
|
if (!isSoloPlay) {
|
|
gameScore += this.getFinalFoxPoints(winningTeam);
|
|
gameScore += this.getCharliePoints(winningTeam);
|
|
}
|
|
|
|
this.setGameScores(gameScore, winningTeam, isSoloPlay);
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
|
|
// Won by how much?
|
|
if (winningTeamScore > 210) {
|
|
gameScore += 3;
|
|
} else if (winningTeamScore > 180) {
|
|
gameScore += 2;
|
|
} else if (winningTeamScore > 150) {
|
|
gameScore += 1;
|
|
}
|
|
|
|
// Announcements
|
|
if (winningTeam === Team.RE) {
|
|
if (this.checkAnnouncementActive(announcements.Announcement.RE_NO_NINETY) && winningTeamScore > 150) {
|
|
gameScore++;
|
|
}
|
|
if (this.checkAnnouncementActive(announcements.Announcement.RE_NO_SIXTY) && winningTeamScore > 180) {
|
|
gameScore++;
|
|
}
|
|
if (this.checkAnnouncementActive(announcements.Announcement.RE_NO_THIRTY) && winningTeamScore > 210) {
|
|
gameScore++;
|
|
}
|
|
}
|
|
if (winningTeam === Team.CONTRA) {
|
|
if (this.checkAnnouncementActive(announcements.Announcement.CONTRA_NO_NINETY) && winningTeamScore > 150) {
|
|
gameScore++;
|
|
}
|
|
if (this.checkAnnouncementActive(announcements.Announcement.CONTRA_NO_SIXTY) && winningTeamScore > 180) {
|
|
gameScore++;
|
|
}
|
|
if (this.checkAnnouncementActive(announcements.Announcement.CONTRA_NO_THIRTY) && winningTeamScore > 210) {
|
|
gameScore++;
|
|
}
|
|
}
|
|
|
|
return gameScore;
|
|
}
|
|
|
|
/**
|
|
* Calculates the team card score of the given players team
|
|
* @param player The player to calculate the teams points for
|
|
*/
|
|
getTeamScore(player: Player): number {
|
|
let totalTeamScore: number = player.finalCardScore ?? 0;
|
|
|
|
for (let otherPlayer of this.actualPlayers) {
|
|
if (otherPlayer !== player && otherPlayer.team === player.team) {
|
|
totalTeamScore += otherPlayer.finalCardScore ?? 0;
|
|
}
|
|
}
|
|
|
|
return totalTeamScore;
|
|
}
|
|
|
|
/**
|
|
* Calculates which team won and returns the Team Name and the achieved score
|
|
*/
|
|
getWinningTeamAndScore(): { team: Team, score: number } {
|
|
let elderPoints: number = 0;
|
|
let otherPoints: number = 0;
|
|
|
|
for (let player of this.actualPlayers) {
|
|
if (player.team === Team.RE) {
|
|
elderPoints += player.finalCardScore ?? 0;
|
|
} else {
|
|
otherPoints += player.finalCardScore ?? 0;
|
|
}
|
|
}
|
|
|
|
if (elderPoints > otherPoints) {
|
|
return {
|
|
team: Team.RE,
|
|
score: elderPoints
|
|
};
|
|
}
|
|
return {
|
|
team: Team.CONTRA,
|
|
score: otherPoints
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Sets the game scores for all players
|
|
* @param score The score to set
|
|
* @param winningTeam The team that won
|
|
*/
|
|
setGameScores(score: number, winningTeam: Team, isSolo: boolean) {
|
|
for (let player of this.actualPlayers) {
|
|
if (player.team === winningTeam) {
|
|
if(isSolo) {
|
|
player.gamePoints = score * 3;
|
|
} else {
|
|
player.gamePoints = score;
|
|
}
|
|
} else {
|
|
player.gamePoints = -score;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculates the points that each team got by catching foxes
|
|
*/
|
|
calculateFoxPoints(): { re: number, contra: number } {
|
|
let reFoxesCaught: number = 0;
|
|
let contraFoxesCaught: number = 0;
|
|
|
|
for (let player of this.actualPlayers) {
|
|
if (player.team === Team.RE) {
|
|
reFoxesCaught += player.foxesCaught ?? 0;
|
|
} else {
|
|
contraFoxesCaught += player.foxesCaught ?? 0;
|
|
}
|
|
}
|
|
|
|
return {
|
|
re: reFoxesCaught,
|
|
contra: contraFoxesCaught
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Calculates the final fox points for the winning team
|
|
* @param winningTeam The winning team
|
|
*/
|
|
getFinalFoxPoints(winningTeam: Team): number {
|
|
let finalPoints = 0;
|
|
|
|
if (winningTeam === Team.RE) {
|
|
finalPoints += this.calculateFoxPoints().re;
|
|
finalPoints -= this.calculateFoxPoints().contra;
|
|
} else {
|
|
finalPoints += this.calculateFoxPoints().contra;
|
|
finalPoints -= this.calculateFoxPoints().re;
|
|
}
|
|
|
|
return finalPoints;
|
|
}
|
|
|
|
/**
|
|
* Returns the extra points for a when a charlie made the final trick.
|
|
* If the winning team played the charlie, they get one point. If the losing team played the charlie, the winning team loses one point.
|
|
* @param winningTeam The winning team
|
|
*/
|
|
getCharliePoints(winningTeam: Team): number {
|
|
for (let player of this.actualPlayers) {
|
|
if (player.wonLastTrickWithCharlie) {
|
|
return player.team === winningTeam ? 1 : -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* @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;
|
|
|
|
if (normalWinningTeam === Team.RE) {
|
|
if (this.checkAnnouncementActive(announcements.Announcement.RE_NO_NINETY) && normalWinningTeamScore < 151) {
|
|
gamePoints++;
|
|
}
|
|
if (this.checkAnnouncementActive(announcements.Announcement.RE_NO_SIXTY) && normalWinningTeamScore < 181) {
|
|
gamePoints++;
|
|
}
|
|
if (this.checkAnnouncementActive(announcements.Announcement.RE_NO_THIRTY) && normalWinningTeamScore < 211) {
|
|
gamePoints++;
|
|
}
|
|
}
|
|
if (normalWinningTeam === Team.CONTRA) {
|
|
if (this.checkAnnouncementActive(announcements.Announcement.CONTRA_NO_NINETY) && normalWinningTeamScore < 151) {
|
|
gamePoints++;
|
|
}
|
|
if (this.checkAnnouncementActive(announcements.Announcement.CONTRA_NO_SIXTY) && normalWinningTeamScore < 181) {
|
|
gamePoints++;
|
|
}
|
|
if (this.checkAnnouncementActive(announcements.Announcement.CONTRA_NO_THIRTY) && normalWinningTeamScore < 211) {
|
|
gamePoints++;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
isSoloActive(solo: solos.Solo): boolean {
|
|
return this.soloPlayed === solo;
|
|
}
|
|
|
|
getAllPossibleSolos(): solos.Solo[] {
|
|
return solos.getAllSoloValues();
|
|
}
|
|
|
|
toggleSolo(solo: solos.Solo): void {
|
|
this.soloPlayed = solo;
|
|
}
|
|
}
|