feat(ongeki): new technical rating display

Author: Sanheiii

src/app/sega/ongeki/model/OngekiEnums.ts

@@ -53,8 +53,6 @@ export enum BattleRank {
 }
 
 export enum TechnicalRank {
-  Invalid = -1,
-  Begin = 0,
   None = 0,
   D = 1,
   C = 2,
@@ -68,7 +66,6 @@ export enum TechnicalRank {
   SS = 10,
   SSS = 11,
   SSS1 = 12,
-  End = 13,
 }
 
 // The AttributeType send by client is + 1. So the value here is start from 1

src/app/sega/ongeki/model/OngekiProfile.ts

@@ -18,6 +18,8 @@ export interface DisplayOngekiProfile {
   medalCount: number;
   playerRating: number;
   highestRating: number;
+  newPlayerRating: number;
+  newHighestRating: number;
   battlePoint: number;
   bestBattlePoint: number;
   rankId: number;

src/app/sega/ongeki/model/PlayerNewRatingItem.ts

@@ -0,0 +1,21 @@
+import {OngekiMusic} from './OngekiMusic';
+
+export interface PlayerNewRatingItem {
+  musicId: number;
+  level: number;
+  techScoreMax: number;
+  platinumScoreMax: number;
+  platinumScoreStar: number;
+  isFullBell?: boolean;
+  isFullCombo?: boolean;
+  isAllBreak?: boolean;
+  clearMarkType?: ClearMarkType;
+  musicInfo?: OngekiMusic;
+}
+
+export enum ClearMarkType {
+  None,
+  FullCombo,
+  AllBreak,
+  AllBreakPlus
+}

src/app/sega/ongeki/model/PlayerRatingItem.ts

@@ -5,6 +5,8 @@ export interface PlayerRatingItem {
   musicId: number;
   level: number;
   value: number;
+  platinumScoreMax: number;
+  platinumScoreStar: number;
   musicInfo?: OngekiMusic;
   bossCardInfo?: OngekiCard;
 }

src/app/sega/ongeki/new-rating.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { NewRatingService } from './new-rating.service';
+
+describe('RatingService', () => {
+  let service: NewRatingService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(NewRatingService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

src/app/sega/ongeki/new-rating.service.ts

@@ -0,0 +1,192 @@
+import { Injectable } from '@angular/core';
+import {ClearMarkType, PlayerNewRatingItem} from './model/PlayerNewRatingItem';
+import {OngekiMusic} from './model/OngekiMusic';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class NewRatingService {
+
+  constructor() { }
+
+  public getTechnicalRankIDByScore(score: number): TechnicalRankID {
+    const entries = Array.from(technicalRankTable.entries());
+    entries.sort((a, b) => b[1] - a[1]);
+    const found = entries.find(([_, value]) => score >= value);
+    return found ? found[0] : TechnicalRankID.None;
+  }
+
+  public calcRate1000(ratingItem: PlayerNewRatingItem, type: NewRatingType): number {
+    if (!ratingItem.musicInfo) { return 0; }
+    else if (type === NewRatingType.Best) {
+      return this.calcTechnicalScoreRate1000(ratingItem);
+    }
+    else if (type === NewRatingType.New) {
+      const rate1000 = this.calcTechnicalScoreRate1000(ratingItem);
+      return Math.floor(rate1000 / 5) * 5;
+    }
+    else if (type === NewRatingType.Platinum) {
+      return this.calcPlatinumScoreRate1000(ratingItem);
+    }
+  }
+
+  calcTechnicalScoreRate1000(ratingItem: PlayerNewRatingItem) {
+    const score = ratingItem.techScoreMax;
+    const clearMarkType = ratingItem.clearMarkType;
+    const isFullBell = ratingItem.isFullBell;
+
+    const level1000 = this.getLevel1000(ratingItem.musicInfo, ratingItem.level);
+    let rate1000 = 0;
+
+    if (score <= rateTbl[0].score) {
+      rate1000 = Math.floor((level1000 + rateTbl[0].bonus1000) * (score - 500000) / (rateTbl[0].score - 500000));
+    } else {
+      for (let i = 1; i < rateTbl.length; i++) {
+        const nextRate = rateTbl[i];
+        if (score <= nextRate.score) {
+          const rate = rateTbl[i - 1];
+          const techScoreRank = this.getTechnicalRankIDByScore(score);
+          const clearMarkBonus = clearMarkRateTbl.get(clearMarkType) || 0;
+          const fullBellBonus = fullBellRateTbl.get(isFullBell) || 0;
+          let teckRankBonus = 0;
+
+          for (const rank of teckRankOrder) {
+            if (techScoreRank < rank) {
+              break;
+            }
+            teckRankBonus = teckRankRateTbl.get(rank) || 0;
+          }
+
+          let num4 = level1000 + rate.bonus1000;
+          const bonusDiff = nextRate.bonus1000 - rate.bonus1000;
+          const scoreDiff = score - rate.score;
+          const rateDiff = nextRate.score - rate.score;
+          num4 += Math.floor((bonusDiff * scoreDiff) / rateDiff);
+          rate1000 = num4 + clearMarkBonus + teckRankBonus + fullBellBonus;
+          break;
+        }
+      }
+    }
+
+    return Math.max(rate1000, 0);
+  }
+
+  calcPlatinumScoreRate1000(ratingItem: PlayerNewRatingItem): number {
+    const level = this.getLevel(ratingItem.musicInfo, ratingItem.level);
+    const platinumScoreStar = Math.min(ratingItem.platinumScoreStar, 5);
+    const rate1000 = platinumScoreStar * Math.pow(level, 2);
+
+    return Math.max(Math.floor(rate1000), 0);
+  }
+
+  getLevel1000(musicInfo: OngekiMusic, level: number) {
+    const level100 = this.getLevel100(musicInfo, level);
+    return level100 * 10;
+  }
+
+  getLevel100(musicInfo: OngekiMusic, level: number) {
+    if (!musicInfo) {
+      return null;
+    }
+    let levelData: string;
+    if (level === 0) {
+      levelData = musicInfo.level0;
+    } else if (level === 1) {
+      levelData = musicInfo.level1;
+    } else if (level === 2) {
+      levelData = musicInfo.level2;
+    } else if (level === 3) {
+      levelData = musicInfo.level3;
+    } else if (level === 10) {
+      levelData = musicInfo.level4;
+    }
+    const levelDatas = levelData.split(',');
+    if (levelDatas.length !== 2) {
+      return null;
+    }
+
+    return Math.floor(parseInt(levelDatas[0], 10) * 100 + parseInt(levelDatas[1], 10) + 0.5);
+  }
+
+  public getLevel(musicInfo: OngekiMusic, level: number) {
+    const level100 = this.getLevel100(musicInfo, level);
+    return level100 / 100;
+  }
+
+}
+
+export enum NewRatingType {
+  New, Best, Platinum
+}
+
+enum TechnicalRankID {
+  None,
+  D,
+  C,
+  B,
+  BB,
+  BBB,
+  A,
+  AA,
+  AAA,
+  S,
+  SS,
+  SSS,
+  SSS1
+}
+
+class RateTbl {
+  constructor(public score: number, public bonus1000: number) {
+  }
+}
+
+const rateTbl: RateTbl[] = [
+  new RateTbl(800000, -6000),
+  new RateTbl(900000, -4000),
+  new RateTbl(970000, 0),
+  new RateTbl(990000, 750),
+  new RateTbl(1000000, 1250),
+  new RateTbl(1007500, 1750),
+  new RateTbl(1010000, 2000)
+];
+
+const clearMarkRateTbl = new Map<ClearMarkType, number>([
+  [ClearMarkType.None, 0],
+  [ClearMarkType.FullCombo, 100],
+  [ClearMarkType.AllBreak, 300],
+  [ClearMarkType.AllBreakPlus, 350]
+]);
+
+const fullBellRateTbl = new Map<boolean, number>([
+  [false, 0],
+  [true, 50]
+]);
+
+const teckRankRateTbl = new Map<TechnicalRankID, number>([
+  [TechnicalRankID.S, 0],
+  [TechnicalRankID.SS, 100],
+  [TechnicalRankID.SSS, 200],
+  [TechnicalRankID.SSS1, 300]
+]);
+
+const technicalRankTable = new Map<TechnicalRankID, number>([
+  [TechnicalRankID.D, 0],
+  [TechnicalRankID.C, 500000],
+  [TechnicalRankID.B, 700000],
+  [TechnicalRankID.BB, 750000],
+  [TechnicalRankID.BBB, 800000],
+  [TechnicalRankID.A, 850000],
+  [TechnicalRankID.AA, 900000],
+  [TechnicalRankID.AAA, 940000],
+  [TechnicalRankID.S, 970000],
+  [TechnicalRankID.SS, 990000],
+  [TechnicalRankID.SSS, 1000000],
+  [TechnicalRankID.SSS1, 1007500]
+]);
+
+const teckRankOrder: TechnicalRankID[] = [
+  TechnicalRankID.S,
+  TechnicalRankID.SS,
+  TechnicalRankID.SSS,
+  TechnicalRankID.SSS1
+];

src/app/sega/ongeki/ongeki-battle-point/ongeki-battle-point.component.ts

@@ -64,6 +64,8 @@ export class OngekiBattlePointComponent implements OnInit {
               musicId: Number(value[0]),
               level: Number(value[1]),
               value: Number(value[2]),
+              platinumScoreMax: Number(value[3]),
+              platinumScoreStar: Number(value[4]),
             };
             this.dbService.getByID<OngekiMusic>('ongekiMusic', item.musicId).subscribe(
               x => {

src/app/sega/ongeki/ongeki-card/ongeki-card.component.html

@@ -40,7 +40,7 @@ <h1 class="page-heading">{{ 'Ongeki.Card.Title' | translate }}</h1>
 <ng-container *ngIf="currentDeck">
   <div class="deck-row row row-cols-3">
     <ng-container *ngFor="let item of currentDeck;let i = index">
-      <div class="col p-2">
+      <div class="col">
         <div class="cards-col">
           <app-ongeki-card-item
             (click)="open(selectCard)"

src/app/sega/ongeki/ongeki-rating/ongeki-rating.component.css

@@ -1,12 +1,23 @@
 .rating-card{
+  min-width: 180px;
 }
 .jacket{
   width: 5.6rem;
   aspect-ratio: 1;
 }
 
+.new-jacket{
+  width: 3.6rem;
+  aspect-ratio: 1;
+  border-top-left-radius: var(--bs-border-radius) !important;
+}
+@media (min-width:1400px){
+  .col-xxl-{
+    flex:0 0 auto;width:20%
+  }
+}
 .difficulty {
-  font-size: 12px;
+  font-size: 0.7em;
 }
 
 .difficulty-basic {
@@ -38,3 +49,16 @@
   border: 1px solid var(--bs-danger);
   color: var(--bs-danger);
 }
+
+.honor-badge {
+  aspect-ratio: 1;
+  width: 28px;
+}
+
+.honor{
+  height: 28px;
+}
+
+@media (max-width:400px){
+  .row-cols-xxs-1>*{flex:0 0 auto;width:100%}
+}