feat: add the most scuffed players stats implementation, cba to do it any better

Author: DuckySoLucky

NotEnoughUpdates-REPO

@@ -0,0 +1,59 @@
+package constants
+
+import "skycrypt/src/models"
+
+var PLAYER_STATS = map[string]models.StatsInfo{
+	"health":                {"base": 100},
+	"defense":               {"base": 0},
+	"strength":              {"base": 0},
+	"speed":                 {"base": 100},
+	"critical_chance":       {"base": 30},
+	"critical_damage":       {"base": 50},
+	"intelligence":          {"base": 0},
+	"bonus_attack_speed":    {"base": 0},
+	"sea_creature_chance":   {"base": 20},
+	"magic_find":            {"base": 0},
+	"pet_luck":              {"base": 0},
+	"true_defense":          {"base": 0},
+	"ferocity":              {"base": 0},
+	"ability_damage":        {"base": 0},
+	"mining_speed":          {"base": 0},
+	"mining_fortune":        {"base": 0},
+	"farming_fortune":       {"base": 0},
+	"foraging_fortune":      {"base": 0},
+	"pristine":              {"base": 0},
+	"fishing_speed":         {"base": 0},
+	"health_regen":          {"base": 100},
+	"vitality":              {"base": 100},
+	"mending":               {"base": 100},
+	"combat_wisdom":         {"base": 0},
+	"mining_wisdom":         {"base": 0},
+	"farming_wisdom":        {"base": 0},
+	"foraging_wisdom":       {"base": 0},
+	"fishing_wisdom":        {"base": 0},
+	"enchanting_wisdom":     {"base": 0},
+	"alchemy_wisdom":        {"base": 0},
+	"carpentry_wisdom":      {"base": 0},
+	"runecrafting_wisdom":   {"base": 0},
+	"social_wisdom":         {"base": 0},
+	"mining_spread":         {"base": 0},
+	"gemstone_spread":       {"base": 0},
+	"ore_fortune":           {"base": 0},
+	"block_fortune":         {"base": 0},
+	"dwarven_metal_fortune": {"base": 0},
+	"gemstone_fortune":      {"base": 0},
+	"wheat_fortune":         {"base": 0},
+	"carrot_fortune":        {"base": 0},
+	"potato_fortune":        {"base": 0},
+	"pumpkin_fortune":       {"base": 0},
+	"melon_fortune":         {"base": 0},
+	"mushroom_fortune":      {"base": 0},
+	"cactus_fortune":        {"base": 0},
+	"sugar_cane_fortune":    {"base": 0},
+	"nether_wart_fortune":   {"base": 0},
+	"cocoa_beans_fortune":   {"base": 0},
+	"double_hook_chance":    {"base": 0},
+	"trophy_fish_chance":    {"base": 0},
+	"heat_resistance":       {"base": 0},
+	"fear":                  {"base": 0},
+}

src/constants/player_stats.go

@@ -0,0 +1,3 @@
+package models
+
+type StatsInfo map[string]int

src/models/player_stats.go

@@ -102,6 +102,8 @@ func SetupRoutes(app *fiber.App) {
 	api.Get("/stats/:uuid/:profileId", routes.StatsHandler)
 	api.Get("/stats/:uuid", routes.StatsHandler)
 
+	api.Get("/playerStats/:uuid/:profileId", routes.PlayerStatsHandler)
+
 	api.Get("/networth/:uuid/:profileId", routes.NetworthHandler)
 
 	api.Get("/gear/:uuid/:profileId", routes.GearHandler)

src/routes.go

@@ -25,16 +25,9 @@ func PetsHandler(c *fiber.Ctx) error {
 	userProfileValue := profile.Members[uuid]
 	userProfile := &userProfileValue
 
-	pets, err := stats.GetPets(userProfile, profile)
-	if err != nil {
-		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
-			"error": fmt.Sprintf("Failed to get pets: %v", err),
-		})
-	}
-
 	fmt.Printf("Returning /api/pets/%s in %s\n", profileId, time.Since(timeNow))
 
 	return c.JSON(fiber.Map{
-		"pets": pets,
+		"pets": stats.GetPets(userProfile, profile),
 	})
 }

src/routes/pets.go

@@ -0,0 +1,33 @@
+package routes
+
+import (
+	"fmt"
+	"skycrypt/src/api"
+	"skycrypt/src/stats"
+	"time"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+func PlayerStatsHandler(c *fiber.Ctx) error {
+	timeNow := time.Now()
+
+	uuid := c.Params("uuid")
+	profileId := c.Params("profileId")
+
+	profile, err := api.GetProfile(uuid, profileId)
+	if err != nil {
+		return c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
+			"error": fmt.Sprintf("Failed to get profile: %v", err),
+		})
+	}
+
+	userProfileValue := profile.Members[uuid]
+	userProfile := &userProfileValue
+
+	fmt.Printf("Returning /api/playerStats/%s in %s\n", profileId, time.Since(timeNow))
+
+	return c.JSON(fiber.Map{
+		"stats": stats.GetPlayerStats(userProfile, profile, profileId),
+	})
+}

src/routes/player_stats.go

@@ -427,8 +427,7 @@ func GetPetScore(pets []models.ProcessedPet) models.PetScore {
 	return output
 }
 
-func GetPets(userProfile *skycrypttypes.Member, profile *skycrypttypes.Profile) (models.OutputPets, error) {
-
+func GetPets(userProfile *skycrypttypes.Member, profile *skycrypttypes.Profile) models.OutputPets {
 	allPets := []skycrypttypes.Pet{}
 	allPets = append(allPets, userProfile.Pets.Pets...)
 	if userProfile.Rift.DeadCats.Montezuma.Rarity != "" {
@@ -463,5 +462,5 @@ func GetPets(userProfile *skycrypttypes.Member, profile *skycrypttypes.Profile)
 
 	output.MissingPets = stats.StripPets(getMissingPets(userProfile, pets, profile.GameMode))
 
-	return output, nil
+	return output
 }

src/stats/pets.go

@@ -0,0 +1,175 @@
+package stats
+
+import (
+	"fmt"
+	"maps"
+	"skycrypt/src/constants"
+	redis "skycrypt/src/db"
+	"skycrypt/src/models"
+	statsItems "skycrypt/src/stats/items"
+	statsLeveling "skycrypt/src/stats/leveling"
+
+	skycrypttypes "github.com/DuckySoLucky/SkyCrypt-Types"
+	jsoniter "github.com/json-iterator/go"
+)
+
+func GetPlayerStats(userProfile *skycrypttypes.Member, profile *skycrypttypes.Profile, profileId string) map[string]models.StatsInfo {
+	stats := map[string]models.StatsInfo{}
+	for statName, statInfo := range constants.PLAYER_STATS {
+		stats[statName] = models.StatsInfo{}
+		maps.Copy(stats[statName], statInfo)
+	}
+
+	items := getItems(userProfile, profileId)
+	processedItems := processItems(items)
+
+	accessoriesStats := GetAccessories(userProfile, items)
+	for statName, statValue := range accessoriesStats.Stats {
+		if _, exists := stats[statName]; !exists {
+			continue
+		}
+
+		stats[statName]["accessories"] += int(statValue)
+	}
+
+	armorStats := statsItems.GetStatsFromItems(processedItems["armor"])
+	for statName, statValue := range armorStats {
+		if _, exists := stats[statName]; !exists {
+			continue
+		}
+
+		stats[statName]["armor"] += int(statValue)
+	}
+
+	equipmentStats := statsItems.GetStatsFromItems(processedItems["equipment"])
+	for statName, statValue := range equipmentStats {
+		if _, exists := stats[statName]; !exists {
+			continue
+		}
+
+		stats[statName]["equipment"] += int(statValue)
+	}
+
+	skyblockLevel := GetSkyBlockLevel(userProfile)
+	if skyblockLevel.Level > 0 {
+		stats["health"]["skyblock_level"] = int(skyblockLevel.Level * 5)
+		stats["strength"]["skyblock_level"] = int(skyblockLevel.Level / 5)
+	}
+
+	slayerStats := GetSlayers(userProfile).Stats
+	for statName, statValue := range slayerStats {
+		if _, exists := stats[statName]; !exists {
+			continue
+		}
+
+		stats[statName]["slayers"] += int(statValue)
+	}
+
+	pets := GetPets(userProfile, &skycrypttypes.Profile{})
+	activePet := pets.Pets[0]
+	if !activePet.Active {
+		for i := range pets.Pets {
+			if !pets.Pets[i].Active {
+				continue
+			}
+
+			activePet = pets.Pets[i]
+			break
+		}
+	}
+
+	for statName, statValue := range activePet.Stats {
+		if _, exists := stats[statName]; !exists {
+			continue
+		}
+
+		stats[statName]["active_pet"] += int(statValue)
+	}
+
+	for statName, statValue := range pets.PetScore.Stats {
+		if _, exists := stats[statName]; !exists {
+			continue
+		}
+
+		stats[statName]["pet_score"] += int(statValue)
+	}
+
+	skills := GetSkills(userProfile, &skycrypttypes.Profile{}, &skycrypttypes.Player{})
+	for skillId, skillData := range skills.Skills {
+		statsBonus := constants.STATS_BONUS[fmt.Sprintf("skill_%s", skillId)]
+		if statsBonus == nil {
+			continue
+		}
+
+		skillStats := constants.GetBonusStat(skillData.Level, fmt.Sprintf("skill_%s", skillId), skillData.MaxLevel)
+		for statName, value := range skillStats {
+			if _, exists := stats[statName]; !exists {
+				continue
+			}
+
+			stats[statName]["skills"] += int(value)
+		}
+	}
+
+	catacombs := userProfile.Dungeons.DungeonTypes["catacombs"]
+	if catacombs.Experience > 0 {
+		dungeoneeringLevel := statsLeveling.GetLevelByXp(int(catacombs.Experience), &statsLeveling.ExtraSkillData{Type: "dungeoneering"})
+		skillStats := constants.GetBonusStat(dungeoneeringLevel.Level, "skill_dungeoneering", 50)
+		for statName, value := range skillStats {
+			if _, exists := stats[statName]; !exists {
+				continue
+			}
+
+			stats[statName]["dungeons"] += int(value)
+		}
+	}
+
+	bestiaryData := GetBestiary(userProfile)
+	if bestiaryData.Level > 0 {
+		stats["health"]["bestiary"] = int(bestiaryData.Level)
+	}
+
+	for statName, statInfo := range stats {
+		total := 0
+		for _, value := range statInfo {
+			total += value
+		}
+		stats[statName]["total"] = total
+	}
+
+	return stats
+}
+
+func getItems(userProfile *skycrypttypes.Member, profileId string) map[string][]skycrypttypes.Item {
+	var items map[string][]skycrypttypes.Item
+	cache, err := redis.Get(fmt.Sprintf("items:%s", profileId))
+	if err == nil && cache != "" {
+		var json = jsoniter.ConfigCompatibleWithStandardLibrary
+		err = json.Unmarshal([]byte(cache), &items)
+		if err != nil {
+			return map[string][]skycrypttypes.Item{}
+		}
+	} else {
+		items, err = GetItems(userProfile, profileId)
+		if err != nil {
+			return map[string][]skycrypttypes.Item{}
+		}
+	}
+
+	return items
+}
+
+func processItems(rawItems map[string][]skycrypttypes.Item) map[string][]models.ProcessedItem {
+	var processedItems = make(map[string][]models.ProcessedItem)
+	inventoryKeys := []string{"armor", "equipment", "wardrobe", "inventory", "enderchest", "backpack"}
+	for _, inventoryId := range inventoryKeys {
+		inventoryData := rawItems[inventoryId]
+		if len(inventoryData) == 0 {
+			continue
+		}
+
+		processedItems[inventoryId] = statsItems.ProcessItems(&inventoryData, inventoryId)
+	}
+
+	return processedItems
+}