PlutoDev/Doppelkopf-Stats-Frontend
3
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Refactoring score calculation logic

Browse Source
This commit is contained in:
Patrick Müller 2022-09-14 21:58:31 +02:00
parent 051657ef65
commit 753e490c29
Signed by: Paddy
GPG Key ID: 37ABC11275CAABCE
5 changed files with 139 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/app/components/add-game/add-game.component.html
View File

@ -28,19 +28,19 @@
<table class="point-entry">
<tr *ngIf="this.actualPlayers[0]">
<td><p>{{this.actualPlayers[0].firstName}}</p></td>
<td><input type="number" [(ngModel)]="this.actualPlayers[0].finalCardScore"/></td>
<td><input type="number" [(ngModel)]="this.actualPlayers[0].finalCardScore" (change)="this.calculateCurrentScores()"/></td>
</tr>
<tr *ngIf="this.actualPlayers[1]">
<td><p>{{this.actualPlayers[1].firstName}}</p></td>
<td><input type="number" [(ngModel)]="this.actualPlayers[1].finalCardScore"/></td>
<td><input type="number" [(ngModel)]="this.actualPlayers[1].finalCardScore" (change)="this.calculateCurrentScores()"/></td>
</tr>
<tr *ngIf="this.actualPlayers[2]">
<td><p>{{this.actualPlayers[2].firstName}}</p></td>
<td><input type="number" [(ngModel)]="this.actualPlayers[2].finalCardScore"/></td>
<td><input type="number" [(ngModel)]="this.actualPlayers[2].finalCardScore" (change)="this.calculateCurrentScores()"/></td>
</tr>
<tr *ngIf="this.actualPlayers[3]">
<td><p>{{this.actualPlayers[3].firstName}}</p></td>
<td><input type="number" [(ngModel)]="this.actualPlayers[3].finalCardScore"/></td>
<td><input type="number" [(ngModel)]="this.actualPlayers[3].finalCardScore" (change)="this.calculateCurrentScores()"/></td>
</tr>
</table>
<p id="score-warn" *ngIf="calculatePointSum() !== 240">Total score doesn't add up ({{getScoreDifferenceText()}})</p>
@ -55,7 +55,7 @@
</div>
<div id="scores">
<p class="team-{{player.team}}" *ngFor="let player of actualPlayers">
{{player.firstName}}: {{calculateCurrentScore(player)}}
{{player.firstName}}: {{player.gamePoints}}
</p>
</div>
</div>

146
src/app/components/add-game/add-game.component.ts
View File

@ -31,31 +31,41 @@ export class AddGameComponent implements OnInit {
firebonkId: 1,
uuid: 'abc-def-ghi-j',
firstName: 'Patrick',
team: Team.CONTRA
team: Team.CONTRA,
gamePoints: 0,
finalCardScore: 0
});
this.potentialPlayers.push({
firebonkId: 2,
uuid: 'abc-def-ghi-k',
firstName: 'Julian',
team: Team.CONTRA
team: Team.CONTRA,
gamePoints: 0,
finalCardScore: 0
});
this.potentialPlayers.push({
firebonkId: 3,
uuid: 'abc-def-ghi-l',
firstName: 'Yannick',
team: Team.CONTRA
team: Team.CONTRA,
gamePoints: 0,
finalCardScore: 0
});
this.potentialPlayers.push({
firebonkId: 4,
uuid: 'abc-def-ghi-m',
firstName: 'Janina',
team: Team.CONTRA
team: Team.CONTRA,
gamePoints: 0,
finalCardScore: 0
});
this.potentialPlayers.push({
firebonkId: 5,
uuid: 'abc-def-ghi-n',
firstName: 'Moritz',
team: Team.CONTRA
team: Team.CONTRA,
gamePoints: 0,
finalCardScore: 0
});
this.actualPlayers.push(...this.potentialPlayers.slice(0, 4));
@ -65,6 +75,10 @@ export class AddGameComponent implements OnInit {
* Switches the entry mask UI to the next page
*/
switchToNextPage(): void {
if (this.currentPage >= 4) {
this.calculateCurrentScores();
}
this.currentPage++;
}
@ -262,10 +276,22 @@ export class AddGameComponent implements OnInit {
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;
}
/**
* ______
* /_ __/__ ____ _____ ___ _____
@ -351,35 +377,63 @@ export class AddGameComponent implements OnInit {
*/
/**
* Calculates the game points for the given player
* @param player The player to calculate points for
* Calculates the game points for all players
*/
calculateCurrentScore(player: Player): number {
calculateCurrentScores(): void {
let gameScore: number = 0;
let teamScore = this.getTeamScore(player);
let winningTeamScore = this.getWinningTeamAndScore().score;
let winningTeam = this.getWinningTeamAndScore().team;
console.log(winningTeamScore);
console.log(winningTeam);
// Won? If so, by how much?
if (teamScore > 210) {
gameScore += 4;
} else if (teamScore > 180) {
// We are going to calculate the points for the winning team and then set all players points accordingly
gameScore = 1; // 1 Point for Winning
// Won by how much?
if (winningTeamScore > 210) {
gameScore += 3;
} else if (teamScore > 150) {
} else if (winningTeamScore > 180) {
gameScore += 2;
} else if (teamScore > 120) {
} else if (winningTeamScore > 150) {
gameScore += 1;
} else if (teamScore < 30) {
gameScore -= 4;
} else if (teamScore < 60) {
gameScore -= 3;
} else if (teamScore < 90) {
gameScore -= 2;
} else {
gameScore -= 1;
}
// TODO Announcements etc
// Announcements
if (winningTeam === Team.RE) {
if (this.checkAnnouncementActive(announcements.Announcement.RE_NO_NINETY) && winningTeamScore > 150) {
gameScore += 1;
}
if (this.checkAnnouncementActive(announcements.Announcement.RE_NO_SIXTY) && winningTeamScore > 180) {
gameScore += 1;
}
if (this.checkAnnouncementActive(announcements.Announcement.RE_NO_THIRTY) && winningTeamScore > 210) {
gameScore += 1;
}
}
if (winningTeam === Team.CONTRA) {
if (this.checkAnnouncementActive(announcements.Announcement.CONTRA_NO_NINETY) && winningTeamScore > 150) {
gameScore += 1;
}
if (this.checkAnnouncementActive(announcements.Announcement.CONTRA_NO_SIXTY) && winningTeamScore > 180) {
gameScore += 1;
}
if (this.checkAnnouncementActive(announcements.Announcement.CONTRA_NO_THIRTY) && winningTeamScore > 210) {
gameScore += 1;
}
}
return gameScore;
// Double Score in case of announcement
if (winningTeam === Team.RE && this.checkAnnouncementActive(announcements.Announcement.RE)) {
gameScore *= 2;
}
if (winningTeam === Team.CONTRA && this.checkAnnouncementActive(announcements.Announcement.CONTRA)) {
gameScore *= 2;
}
// TODO: Check for announcements that have not been fulfilled!
this.setGameScores(gameScore, winningTeam);
}
/**
@ -397,4 +451,46 @@ export class AddGameComponent implements OnInit {
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) {
for (let player of this.actualPlayers) {
if (player.team === winningTeam) {
player.gamePoints = score;
} else {
player.gamePoints = -score;
}
}
}
}

7
src/app/models/doppelkopf/enums/announcement.ts
View File

@ -28,8 +28,7 @@ export function getAllAnnouncementValues(): Announcement[] {
/**
* Checks if the selected announcements are a valid set of announcements.
* E.g.: If RE_NO_NINETY is newly selected, RE also has to be selected
* @param alreadySelected
* @param newSelected
* @param selectedAnnouncements The list of selected announcements
*/
export function checkValidity(selectedAnnouncements: Announcement[]): boolean {
// First check all "RE" Announcements
@ -70,6 +69,10 @@ export function checkValidity(selectedAnnouncements: Announcement[]): boolean {
return true
}
/**
* Returns the names of the two highest announcements from the given list, one for RE and one for CONTRA if applicable
* @param selectedAnnouncements The list of announcements to check
*/
export function returnTwoHighestAnnouncements(selectedAnnouncements: Announcement[]): string {
let finalString: string = '';

2
src/app/models/doppelkopf/game.ts
View File

@ -5,8 +5,6 @@ import {Solo} from './enums/solo';
export interface Game {
gameId: number;
players: Player[];
foxesCaught: number;
announcements: Announcement[];
solo?: Solo;
againstTheElders: boolean;
}

5
src/app/models/doppelkopf/player.ts
View File

@ -4,9 +4,10 @@ export interface Player {
firebonkId: number;
uuid: string;
firstName: string;
finalCardScore?: number;
gamePoints?: number;
finalCardScore: number;
gamePoints: number;
hadMarriage?: boolean;
hadTrumpHandoff?: boolean;
team?: Team;
foxesCaught?: number;
}