Remove timestamp arg from AddMatch

Author: DistroByte

main.go

@@ -81,15 +81,15 @@ func NewLeague() *League {
 	}
 }
 
-func (l *League) AddMatch(date time.Time, results ...*MatchResult) ([]MatchDiff, error) {
+func (l *League) AddMatch(results []*MatchResult) ([]MatchDiff, error) {
 	if len(l.Players) == 0 {
 		return nil, ErrNoPlayers
 	}
 
 	populatedResults := make([]*MatchResult, 0, len(results))
 	matchDiff := make([]MatchDiff, 0, len(results))
 
-	// ensure all drivers are registered and flesh out the results with ELOs
+	// ensure all players are registered and flesh out the results with ELOs
 	for _, result := range results {
 		found := false
 		for _, player := range l.Players {
@@ -125,7 +125,7 @@ func (l *League) AddMatch(date time.Time, results ...*MatchResult) ([]MatchDiff,
 
 		// loop over every other result
 		for opponentPlayer, opponentResult := range populatedResults {
-			// skip comparing the driver to themselves
+			// skip comparing the player to themselves
 			if player == opponentPlayer {
 				continue
 			}
@@ -136,35 +136,36 @@ func (l *League) AddMatch(date time.Time, results ...*MatchResult) ([]MatchDiff,
 			// calculate the expected score
 			var S float64
 
-			// if the driver finished higher than the other driver
+			// if the player finished higher than the other player
 			if curPosition < opponentPosition {
 				S = 1.0
+			} else if curPosition == opponentPosition {
+				S = 0.5
 			} else {
 				S = 0.0
 			}
 
 			// calculate the expected score
 			E := 1.0 / (1.0 + math.Pow(10, float64(opponentELO-curELO)/400))
 
-			// update the driver's ELO change
+			// update the player's ELO change
 			result.Player.ELOChange += int(math.Round(float64(kValue) * (S - E)))
 		}
 
-		// update the driver's ELO
+		// update the player's ELO
 		result.Player.ELO += result.Player.ELOChange
 		matchDiff = append(matchDiff, MatchDiff{
 			Player: result.Player,
 			Diff:   result.Player.ELOChange,
 		})
 	}
 
-	// update the drivers' ELOs
+	// update the players' ELOs
 	for _, result := range populatedResults {
 		for _, player := range l.Players {
 			if player.Name == result.Player.Name {
 				player.ELO = result.Player.ELO
-
-				player.Stats.MatchesPlayed += 1
+				player.Stats.MatchesPlayed++
 				if result.Position == 1 {
 					player.Stats.MatchesWon++
 				}
@@ -256,7 +257,14 @@ func (l *League) RemovePlayer(name string) error {
 func (l *League) ResetPlayers() {
 	for _, p := range l.Players {
 		p.ELO = InitialELO
-		p.Stats = &PlayerStats{}
+		p.ELOChange = 0
+		p.Stats = &PlayerStats{
+			Last5Finish:         []int{},
+			MatchesPlayed:       0,
+			MatchesWon:          0,
+			AllTimeAveragePlace: 0,
+			PeakELO:             InitialELO,
+		}
 	}
 }
 
@@ -295,7 +303,7 @@ func (l *League) GenerateGraph() (string, error) {
 		return "", ErrNoPlayers
 	}
 
-	// sort the drivers by ELO
+	// sort the players by ELO
 	for i := 0; i < len(l.Players); i++ {
 		for j := i + 1; j < len(l.Players); j++ {
 			if l.Players[i].ELO < l.Players[j].ELO {
@@ -329,13 +337,13 @@ func (l *League) GenerateGraph() (string, error) {
 
 		var firstRaceIndex int = -1
 
-		// loop over every race
+		// loop over every match
 		for i, event := range l.Matches {
 
 			// loop over every result
 			for _, result := range event.Results {
 
-				// if the result is for the driver we're plotting
+				// if the result is for the player we're plotting
 				if result.Player != nil && result.Player.Name == player.Name {
 
 					// and this is the first time we've seen them
@@ -344,16 +352,15 @@ func (l *League) GenerateGraph() (string, error) {
 						xys[i].X = float64(i)
 						xys[i].Y = float64(InitialELO)
 						labels[i] = strconv.Itoa(InitialELO)
-						// and remember the index
 						firstRaceIndex = i
 					}
 
-					// add the ELO for the driver for the current race
+					// add the ELO for the player for the current race
 					xys[i+1].X = float64(i + 1)
 					xys[i+1].Y = float64(result.Player.ELO)
 					break
 				} else {
-					// if we haven't seen the driver yet, just copy the last value
+					// if we haven't seen the player yet, just copy the last value
 					xys[i+1].X = float64(i)
 					xys[i+1].Y = xys[i].Y
 				}

main_test.go

@@ -1,8 +1,8 @@
 package multielo_test
 
 import (
+	"fmt"
 	"testing"
-	"time"
 
 	"github.com/distrobyte/multielo"
 	"github.com/stretchr/testify/assert"
@@ -236,7 +236,7 @@ func TestMatch_AddMatch(t *testing.T) {
 			{Player: player4, Position: 4},
 		}
 
-		matchDiff, err := l.AddMatch(time.Now(), results...)
+		matchDiff, err := l.AddMatch(results)
 		if err != nil {
 			t.Error(err)
 		}
@@ -312,7 +312,7 @@ func TestMatch_AddMatch(t *testing.T) {
 			{Player: nil, Position: 3},
 		}
 
-		_, err = l.AddMatch(time.Now(), results...)
+		_, err = l.AddMatch(results)
 		if err.Error() != "nil player found. not recording match" {
 			t.Error(err)
 		}
@@ -321,7 +321,7 @@ func TestMatch_AddMatch(t *testing.T) {
 	t.Run("AddMatchLeagueNil", func(t *testing.T) {
 		l := multielo.NewLeague()
 
-		_, err := l.AddMatch(time.Now())
+		_, err := l.AddMatch([]*multielo.MatchResult{})
 		if err != multielo.ErrNoPlayers {
 			t.Error(err)
 		}
@@ -386,7 +386,7 @@ func TestLeague_GetMatches(t *testing.T) {
 		{Player: player2, Position: 2},
 	}
 
-	_, err = l.AddMatch(time.Now(), results...)
+	_, err = l.AddMatch(results)
 	assert.NoError(t, err)
 
 	matches := l.GetMatches()
@@ -426,39 +426,59 @@ func TestLeague_GenerateGraph(t *testing.T) {
 	err = l.AddPlayer("player2")
 	assert.NoError(t, err)
 
-	player1, err := l.GetPlayer("player1")
+	_, err = l.GetPlayer("player1")
 	assert.NoError(t, err)
-	player2, err := l.GetPlayer("player2")
+	_, err = l.GetPlayer("player2")
 	assert.NoError(t, err)
 
-	results := []*multielo.MatchResult{
-		{Player: player1, Position: 1},
-		{Player: player2, Position: 2},
+	var results1 []*multielo.MatchResult
+	for i := 0; i < 2; i++ {
+		results1 = append(results1, &multielo.MatchResult{
+			Player:   &multielo.Player{Name: fmt.Sprintf("player%v", i+1)},
+			Position: i + 1,
+		})
 	}
 
-	_, err = l.AddMatch(time.Now(), results...)
+	_, err = l.AddMatch(results1)
 	assert.NoError(t, err)
 
-	graphPath, err := l.GenerateGraph()
 	assert.NoError(t, err)
-	assert.Equal(t, "elo.png", graphPath)
 
 	err = l.AddPlayer("player3")
 	assert.NoError(t, err)
 
-	player3, err := l.GetPlayer("player3")
+	_, err = l.GetPlayer("player3")
 	assert.NoError(t, err)
 
-	results = []*multielo.MatchResult{
-		{Player: player1, Position: 1},
-		{Player: player2, Position: 2},
-		{Player: player3, Position: 3},
+	var results2 []*multielo.MatchResult
+	for i := 0; i < 3; i++ {
+		results2 = append(results2, &multielo.MatchResult{
+			Player:   &multielo.Player{Name: fmt.Sprintf("player%v", i+1)},
+			Position: i + 1,
+		})
 	}
 
-	_, err = l.AddMatch(time.Now(), results...)
+	_, err = l.AddMatch(results2)
 	assert.NoError(t, err)
 
-	graphPath, err = l.GenerateGraph()
+	err = l.AddPlayer("player4")
+	assert.NoError(t, err)
+
+	_, err = l.GetPlayer("player4")
+	assert.NoError(t, err)
+
+	var results3 []*multielo.MatchResult
+	for i := 0; i < 3; i++ {
+		results3 = append(results3, &multielo.MatchResult{
+			Player:   &multielo.Player{Name: fmt.Sprintf("player%v", i+1)},
+			Position: i + 1,
+		})
+	}
+
+	_, err = l.AddMatch(results3)
+	assert.NoError(t, err)
+
+	graphPath, err := l.GenerateGraph()
 	assert.NoError(t, err)
 	assert.Equal(t, "elo.png", graphPath)
 }