scorecard-4p: added the new 4p version

site/scorecard-4p/scripts/models.js

@@ -0,0 +1,158 @@
+export class ScoreEntry {
+    constructor(score, total) {
+    this.score = score;
+    this.total = total;
+    }
+};
+
+export class Scorecard {
+  
+  constructor() {
+    this.reset();
+  }
+  
+  reset() {
+    this._player1Scores = [];
+    this._player2Scores = [];
+    this._player3Scores = [];
+    this._player4Scores = [];
+  }
+  
+  addPlayer1Score(newScore) {
+    this._addScore(this._player1Scores, newScore);
+  }
+  
+  removeLastPlayer1Score() {
+    this._player1Scores.pop();    
+  }
+  
+  addPlayer2Score(newScore) {
+    this._addScore(this._player2Scores, newScore);
+  }
+  
+  removeLastPlayer2Score() {
+    this._player2Scores.pop();
+  }
+
+  addPlayer3Score(newScore) {
+    this._addScore(this._player3Scores, newScore);
+  }
+
+  removeLastPlayer3Score() {
+    this._player3Scores.pop();
+  }
+
+  addPlayer4Score(newScore) {
+    this._addScore(this._player4Scores, newScore);
+  }
+
+  removeLastPlayer4Score() {
+    this._player4Scores.pop();
+  }
+  
+  _addScore(playerScores, newScore) {
+    let lastEntry;
+    if (playerScores.length === 0) {
+      lastEntry = new ScoreEntry(0, 0, 0, false, false);
+    } else {
+      lastEntry = playerScores[playerScores.length - 1];
+    }
+    
+    let newEntry = this._newEntryFromPrevious(newScore, lastEntry);
+    
+    playerScores.push(newEntry);
+  }
+  
+  length() {
+    return Math.max(this._player1Scores.length, this._player2Scores.length,
+                    this._player3Scores.length, this._player4Scores.length);
+  }
+  
+  pairs() {
+    let pairs = [];
+
+    for (let i = 0; i < this.length(); i++) {
+      pairs.push({
+        p1: (i < this._player1Scores.length ? this._player1Scores[i] : null),
+        p2: (i < this._player2Scores.length ? this._player2Scores[i] : null),
+        p3: (i < this._player3Scores.length ? this._player3Scores[i] : null),
+        p4: (i < this._player4Scores.length ? this._player4Scores[i] : null),
+      })
+    }
+
+    return pairs;
+  }
+
+  _newEntryFromPrevious(score, previousScoreEntry) {
+    if (previousScoreEntry === null) {
+      return new ScoreEntry(score, score, (score === 0 ? 1 : 0));
+    }
+    
+    let newTotal = previousScoreEntry.total + score;    
+    return new ScoreEntry(score, newTotal);
+  }
+  
+  toJson() {
+    return {
+      "version": 1,
+      "p1": { "scores": this._player1Scores.map(p => p.score) },
+      "p2": { "scores": this._player2Scores.map(p => p.score) },
+      "p3": { "scores": this._player3Scores.map(p => p.score) },
+      "p4": { "scores": this._player4Scores.map(p => p.score) },
+    };
+  }
+  
+  static fromJson(o) {
+    let scorecard = new Scorecard();
+    o["p1"]["scores"].forEach(x => scorecard.addPlayer1Score(x));
+    o["p2"]["scores"].forEach(x => scorecard.addPlayer2Score(x));
+    if (o["p3"]) o["p3"]["scores"].forEach(x => scorecard.addPlayer3Score(x));
+    if (o["p4"]) o["p4"]["scores"].forEach(x => scorecard.addPlayer4Score(x));
+    return scorecard;
+  }
+}
+
+class StoreDAO {
+  
+  constructor(localStorage) {
+    this._localStorage = localStorage;
+  }
+  
+  save(scoreCard) {
+    this._localStorage.setItem('generic-scorecard', JSON.stringify(scoreCard.toJson()));
+  }
+  
+  loadOrCreate() {
+    try {
+      console.log("Loading scorecard");
+      let scoreCardJson = this._localStorage.getItem('generic-scorecard');
+      if (scoreCardJson !== null) {
+        return Scorecard.fromJson(JSON.parse(scoreCardJson));
+      }
+    } catch (e) {
+      console.log(`Could not restore game: ${e}`);
+    }
+    
+    return new Scorecard();
+  }
+  
+  clear() {
+    this._localStorage.removeItem('generic-scorecard');
+  }
+}
+
+class DummyStoreDAO {
+  save(scoreCard) { }
+  loadOrCreate() {
+    return new Scorecard();
+  }
+  clear() { }
+}
+
+export function getStoreDAO() {
+  if (!!window.localStorage) {
+    return new StoreDAO(window.localStorage);
+  } else {
+    return new DummyStoreDAO();
+  }
+}