updated replay outcome icons

Author: Cufee

.air.toml

@@ -7,9 +7,9 @@ send_interrupt = true
 stop_on_error = true
 
 [proxy]
-enabled = true
+enabled = false
 proxy_port = 8080
-app_port = 9092
+app_port = 3000
 
 [log]
 # Only show main log (silences watcher, build, runner)

cmd/discord/gateway/router.go

@@ -3,7 +3,6 @@ package replay
 import (
 	"fmt"
 	"image"
-	"image/color"
 	"math"
 
 	fetch "github.com/cufee/aftermath/internal/stats/fetch/v1/replay"
@@ -20,15 +19,17 @@ func newTitleBlock(replay replay.Cards, width float64) common.Block {
 	style.JustifyContent = common.JustifyContentSpaceBetween
 	style.Direction = common.DirectionHorizontal
 	style.AlignItems = common.AlignItemsCenter
-	style.PaddingX = playerCardPadding
+	style.PaddingX = playerCardPadding + hpBarWidth/2
+
+	allyIcon, enemyIcon := outcomeIcons(replay.Header.Outcome)
 
 	return common.NewBlocksContent(style,
-		outcomeIcon(replay.Header.Outcome),
+		allyIcon,
 		common.NewTextContent(common.Style{
 			Font:      common.FontLarge(),
 			FontColor: common.TextPrimary,
 		}, fmt.Sprintf("%s - %s", replay.Header.MapName, replay.Header.GameMode)),
-		common.NewEmptyContent(outcomeIconSize, outcomeIconSize))
+		enemyIcon)
 }
 
 func newPlayerCard(style common.Style, sizes map[prepare.Tag]float64, card replay.Card, player fetch.Player, ally, protagonist bool) common.Block {
@@ -109,21 +110,26 @@ func playerNameBlock(player fetch.Player, protagonist bool) common.Block {
 
 var outcomeIconCache image.Image
 
-func outcomeIcon(outcome fetch.Outcome) common.Block {
+func outcomeIcons(outcome fetch.Outcome) (common.Block, common.Block) {
 	if outcomeIconCache == nil {
 		flagIcon, _ := assets.GetLoadedImage("flag")
 		outcomeIconCache = imaging.Fit(flagIcon, int(outcomeIconSize), int(outcomeIconSize), imaging.Linear)
 	}
 
-	iconColor := color.NRGBA{255, 240, 0, 180}
+	allyIconColor := outcomeIconBgColorGreen
+	enemyIconColor := outcomeIconBgColorRed
 	if outcome == fetch.OutcomeVictory {
-		iconColor = color.NRGBA{46, 204, 113, 180}
+		allyIconColor = outcomeIconColorGreen
 	}
 	if outcome == fetch.OutcomeDefeat {
-		iconColor = color.NRGBA{242, 38, 19, 180}
+		enemyIconColor = outcomeIconColorRed
+	}
+	if outcome == fetch.OutcomeDraw {
+		allyIconColor = outcomeIconColorYellow
+		enemyIconColor = outcomeIconColorYellow
 	}
 
-	return common.NewImageContent(common.Style{BackgroundColor: iconColor}, outcomeIconCache)
+	return common.NewImageContent(common.Style{BackgroundColor: allyIconColor}, outcomeIconCache), common.NewImageContent(common.Style{BackgroundColor: enemyIconColor}, outcomeIconCache)
 }
 
 func playerWN8Icon(value frame.Value) common.Block {

internal/stats/render/replay/v1/blocks.go

@@ -17,7 +17,15 @@ var (
 	hpBarBgColorEnemies = color.NRGBA{R: 120, G: 80, B: 80, A: 120}
 
 	protagonistColor = color.NRGBA{255, 223, 0, 255}
-	outcomeIconSize  = 30.0
+
+	outcomeIconSize       = 30.0
+	outcomeIconColorRed   = color.NRGBA{R: 255, G: 120, B: 120, A: 255}
+	outcomeIconBgColorRed = color.NRGBA{R: 120, G: 80, B: 80, A: 120}
+
+	outcomeIconColorGreen   = color.NRGBA{R: 120, G: 255, B: 120, A: 255}
+	outcomeIconBgColorGreen = color.NRGBA{R: 80, G: 120, B: 80, A: 120}
+
+	outcomeIconColorYellow = color.NRGBA{255, 223, 0, 180}
 
 	playerWN8IconSize = 25.0
 	playerCardPadding = (80 - hpBarHeight) / 2

internal/stats/render/replay/v1/constants.go

@@ -155,51 +155,53 @@ func TestRenderReplay(t *testing.T) {
 
 	loadStaticAssets(static)
 
-	db, err := newDatabaseClientFromEnv()
-	is.NoErr(err)
-
+	db := tests.StaticTestingDatabase()
 	wg, _ := wargamingClientsFromEnv()
 
 	printer, err := localization.NewPrinterWithFallback("stats", language.English)
 	is.NoErr(err)
 
-	file, err := os.ReadFile("tests/replay_2.wotbreplay")
-	is.NoErr(err)
-
 	fetch, err := fetch.NewMultiSourceClient(wg, nil, db)
 	is.NoErr(err)
 
-	replay, err := fetch.Replay(context.Background(), bytes.NewReader(file), int64(len(file)))
-	is.NoErr(err)
+	replayFiles := []string{"replay_defeat.wotbreplay", "replay_victory.wotbreplay", "replay_draw.wotbreplay"}
+	for _, name := range replayFiles {
+		file, err := os.ReadFile("tests/" + name)
+		is.NoErr(err)
 
-	var vehicles []string
-	for _, player := range append(replay.Teams.Allies, replay.Teams.Enemies...) {
-		if id := player.VehicleID; !slices.Contains(vehicles, id) {
-			vehicles = append(vehicles, id)
+		replay, err := fetch.Replay(context.Background(), bytes.NewReader(file), int64(len(file)))
+		is.NoErr(err)
+
+		var vehicles []string
+		for _, player := range append(replay.Teams.Allies, replay.Teams.Enemies...) {
+			if id := player.VehicleID; !slices.Contains(vehicles, id) {
+				vehicles = append(vehicles, id)
+			}
 		}
-	}
 
-	glossary, err := db.GetVehicles(context.Background(), vehicles)
-	is.NoErr(err)
+		glossary, err := db.GetVehicles(context.Background(), vehicles)
+		is.NoErr(err)
 
-	gameModeNames, err := db.GetGameModeNames(context.Background(), replay.GameMode.String())
-	is.NoErr(err)
+		gameModeNames, err := db.GetGameModeNames(context.Background(), replay.GameMode.String())
+		is.NoErr(err)
 
-	bgImage := "static://bg-default"
+		bgImage := "static://bg-default"
 
-	{
-		cards, err := prepare.NewCards(replay, glossary, gameModeNames, common.WithPrinter(printer, language.English))
-		is.NoErr(err)
+		{
+			cards, err := prepare.NewCards(replay, glossary, gameModeNames, common.WithPrinter(printer, language.English))
+			is.NoErr(err)
 
-		image, err := render.CardsToImage(replay, cards, rc.WithBackgroundURL(bgImage), rc.WithPrinter(printer))
-		assert.NoError(t, err, "failed to render a replay image")
-		assert.NotNil(t, image, "image is nil")
+			image, err := render.CardsToImage(replay, cards, rc.WithBackgroundURL(bgImage), rc.WithPrinter(printer))
+			assert.NoError(t, err, "failed to render a replay image")
+			assert.NotNil(t, image, "image is nil")
 
-		f, err := os.Create("tmp/render_test_replay.png")
-		assert.NoError(t, err, "failed to create a file")
-		defer f.Close()
+			out := "tmp/render_test_" + name + ".png"
+			f, err := os.Create(out)
+			assert.NoError(t, err, "failed to create a file")
+			defer f.Close()
 
-		err = imaging.Save(image, "tmp/render_test_replay.png")
-		assert.NoError(t, err, "failed to encode a png image")
+			err = imaging.Save(image, out)
+			assert.NoError(t, err, "failed to encode a png image")
+		}
 	}
 }

render_test.go

@@ -276,7 +276,7 @@ func (c *staticTestingDatabase) CreateWidgetSettings(ctx context.Context, userID
 }
 
 func (c *staticTestingDatabase) GetGameModeNames(ctx context.Context, id string) (map[language.Tag]string, error) {
-	return nil, nil
+	return map[language.Tag]string{}, nil
 }
 func (c *staticTestingDatabase) UpsertGameModes(ctx context.Context, modes map[string]map[language.Tag]string) (map[string]error, error) {
 	return nil, nil