bebe/bamort
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

renamed functions to *Old

Browse Source 
renamed all funktions to *Old where static methos of the old learning system are used
This commit is contained in:
Frank
2025-08-01 06:27:38 +02:00
parent f1f2b01248
commit d40eb44af5
18 changed files with 180 additions and 267 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/character/handlers.go
+38 -125
View File
@@ -144,7 +144,7 @@ func splitSkills(object []models.SkFertigkeit) ([]models.SkFertigkeit, []models.
//var categories map[string][]models.Fertigkeit
categories := make(map[string][]models.SkFertigkeit)
for _, skill := range object {
gsmsk := skill.GetGsm()
gsmsk := skill.GetSkillByName()
if gsmsk.Improvable {
category := "Unkategorisiert"
if gsmsk.ID != 0 && gsmsk.Category != "" {
@@ -163,7 +163,7 @@ func splitSkills(object []models.SkFertigkeit) ([]models.SkFertigkeit, []models.
return normSkills, innateSkills, categories
}
func GetLearnSkillCost(c *gin.Context) {
func GetLearnSkillCostOld(c *gin.Context) {
// Get the character ID from the request
charID := c.Param("id")
@@ -187,7 +187,7 @@ func GetLearnSkillCost(c *gin.Context) {
return
}
cost, err := gsmaster.CalculateSkillLearnCost(skill.Name, character.Typ)
cost, err := gsmaster.CalculateSkillLearnCostOld(skill.Name, character.Typ)
if err != nil {
respondWithError(c, http.StatusBadRequest, "error getting costs to learn skill: "+err.Error())
return
@@ -197,7 +197,7 @@ func GetLearnSkillCost(c *gin.Context) {
c.JSON(http.StatusOK, cost)
}
func GetLearnSpellCost(c *gin.Context) {
func GetLearnSpellCostOld(c *gin.Context) {
// Get the character ID from the request
charID := c.Param("id")
@@ -225,7 +225,7 @@ func GetLearnSpellCost(c *gin.Context) {
School: spell.Category,
}
cost, err := gsmaster.CalculateSpellLearnCost(spell.Name, character.Typ)
cost, err := gsmaster.CalculateSpellLearnCostOld(spell.Name, character.Typ)
if err != nil {
respondWithError(c, http.StatusBadRequest, "error getting costs to learn spell: "+err.Error())
return
@@ -236,94 +236,6 @@ func GetLearnSpellCost(c *gin.Context) {
c.JSON(http.StatusOK, sd)
}
/*
func GetSkillNextLevelCosts(c *gin.Context) {
// Get the character ID from the request
charID := c.Param("id")
// Load the character from the database
var character Char
if err := character.FirstID(charID); err != nil {
respondWithError(c, http.StatusInternalServerError, "Failed to retrieve character")
return
}
for int, skill := range character.Fertigkeiten {
lCost, err := gsmaster.CalculateSkillImprovementCost(skill.Name, character.Typ, skill.Fertigkeitswert)
if err != nil {
respondWithError(c, http.StatusBadRequest, "error getting costs to learn skill: "+err.Error())
return
}
character.Fertigkeiten[int].LearningCost = *lCost
}
// Load the skill from the request
var s models.Fertigkeit
if err := c.ShouldBindJSON(&s); err != nil {
respondWithError(c, http.StatusBadRequest, err.Error())
return
}
// Return the updated character
c.JSON(http.StatusOK, character.Fertigkeiten)
}
*/
/*
func GetSkillAllLevelCosts(c *gin.Context) {
// Get the character ID from the request
charID := c.Param("id")
// Load the character from the database
var character Char
if err := character.FirstID(charID); err != nil {
respondWithError(c, http.StatusInternalServerError, "Failed to retrieve character")
return
}
var s LearnRequestStruct
if err := c.ShouldBindJSON(&s); err != nil {
respondWithError(c, http.StatusBadRequest, err.Error())
return
}
if s.Name == "" {
respondWithError(c, http.StatusBadRequest, "no name given")
}
costArr := make([]gsmaster.LearnCost, 0)
notfound := true
for _, skill := range character.Fertigkeiten {
if skill.Name == s.Name {
for i := skill.Fertigkeitswert; i <= 20; i++ {
lCost, err := gsmaster.CalculateSkillImprovementCost(skill.Name, character.Typ, skill.Fertigkeitswert)
if err != nil {
respondWithError(c, http.StatusBadRequest, "error getting costs to learn skill: "+err.Error())
return
}
costArr = append(costArr, *lCost)
}
notfound = false
break
}
}
if notfound {
for _, skill := range character.Waffenfertigkeiten {
if skill.Name == s.Name {
for i := skill.Fertigkeitswert; i <= 20; i++ {
lCost, err := gsmaster.CalculateSkillImprovementCost(skill.Name, character.Typ, skill.Fertigkeitswert)
if err != nil {
respondWithError(c, http.StatusBadRequest, "error getting costs to learn skill: "+err.Error())
return
}
costArr = append(costArr, *lCost)
}
break
}
}
}
// Return the updated character
c.JSON(http.StatusOK, costArr)
}
*/
// ExperienceAndWealthResponse repräsentiert die Antwort für EP und Vermögen
type ExperienceAndWealthResponse struct {
ExperiencePoints int `json:"experience_points"`
@@ -376,6 +288,7 @@ type UpdateExperienceRequest struct {
}
// UpdateCharacterExperience aktualisiert die Erfahrungspunkte eines Charakters
// TODO Wenn EP verändert werden ändert sich auch ES
func UpdateCharacterExperience(c *gin.Context) {
id := c.Param("id")
var character models.Char
@@ -667,8 +580,8 @@ type LearnSpellRequest struct {
Notes string `json:"notes,omitempty"`
}
// calculateMultiLevelCosts berechnet die Kosten für mehrere Level-Verbesserungen mit gsmaster.GetLernCostNextLevel
func calculateMultiLevelCosts(character *models.Char, skillName string, currentLevel int, levelsToLearn []int, rewardType string, usePP, useGold int) (*models.LearnCost, error) {
// calculateMultiLevelCostsOld berechnet die Kosten für mehrere Level-Verbesserungen mit gsmaster.GetLernCostNextLevel
func calculateMultiLevelCostsOld(character *models.Char, skillName string, currentLevel int, levelsToLearn []int, rewardType string, usePP, useGold int) (*models.LearnCost, error) {
if len(levelsToLearn) == 0 {
return nil, fmt.Errorf("keine Level zum Lernen angegeben")
}
@@ -714,14 +627,14 @@ func calculateMultiLevelCosts(character *models.Char, skillName string, currentL
// Berechne Kosten für jedes Level
for _, targetLevel := range sortedLevels {
classAbr := getCharacterClass(character)
cat, difficulty, _ := gsmaster.FindBestCategoryForSkillLearning(skillName, classAbr)
classAbr := getCharacterClassOld(character)
cat, difficulty, _ := gsmaster.FindBestCategoryForSkillLearningOld(skillName, classAbr)
levelResult := gsmaster.SkillCostResultNew{
CharacterID: fmt.Sprintf("%d", character.ID),
CharacterClass: classAbr,
SkillName: skillName,
Category: cat,
Difficulty: gsmaster.GetSkillDifficulty(difficulty, skillName),
Difficulty: gsmaster.GetSkillDifficultyOld(difficulty, skillName),
TargetLevel: targetLevel,
}
@@ -731,7 +644,7 @@ func calculateMultiLevelCosts(character *models.Char, skillName string, currentL
tempRequest.UsePP = remainingPP
tempRequest.UseGold = remainingGold
err := gsmaster.GetLernCostNextLevel(&tempRequest, &levelResult, rewardTypePtr, targetLevel, character.Typ)
err := gsmaster.GetLernCostNextLevelOld(&tempRequest, &levelResult, rewardTypePtr, targetLevel, character.Typ)
if err != nil {
return nil, fmt.Errorf("fehler bei Level %d: %v", targetLevel, err)
}
@@ -758,16 +671,16 @@ func calculateMultiLevelCosts(character *models.Char, skillName string, currentL
return totalCost, nil
}
// getCharacterClass gibt die Charakterklassen-Abkürzung zurück
func getCharacterClass(character *models.Char) string {
// getCharacterClassOld gibt die Charakterklassen-Abkürzung zurück
func getCharacterClassOld(character *models.Char) string {
if len(character.Typ) > 3 {
return gsmaster.GetClassAbbreviation(character.Typ)
return gsmaster.GetClassAbbreviationOld(character.Typ)
}
return character.Typ
}
// LearnSkill lernt eine neue Fertigkeit und erstellt Audit-Log-Einträge
func LearnSkill(c *gin.Context) {
// LearnSkillOld lernt eine neue Fertigkeit und erstellt Audit-Log-Einträge
func LearnSkillOld(c *gin.Context) {
charID := c.Param("id")
var character models.Char
@@ -792,7 +705,7 @@ func LearnSkill(c *gin.Context) {
// Verwende Klassenabkürzung wenn der Typ länger als 3 Zeichen ist
var characterClass string
if len(character.Typ) > 3 {
characterClass = gsmaster.GetClassAbbreviation(character.Typ)
characterClass = gsmaster.GetClassAbbreviationOld(character.Typ)
} else {
characterClass = character.Typ
}
@@ -829,7 +742,7 @@ func LearnSkill(c *gin.Context) {
costResult.CharacterClass = characterClass
costResult.SkillName = request.Name
err = gsmaster.GetLernCostNextLevel(&tempRequest, &costResult, request.Reward, nextLevel, character.Rasse)
err = gsmaster.GetLernCostNextLevelOld(&tempRequest, &costResult, request.Reward, nextLevel, character.Rasse)
if err != nil {
respondWithError(c, http.StatusBadRequest, fmt.Sprintf("Fehler bei Level %d: %v", nextLevel, err))
return
@@ -972,8 +885,8 @@ func LearnSkill(c *gin.Context) {
c.JSON(http.StatusOK, response)
}
// ImproveSkill verbessert eine bestehende Fertigkeit und erstellt Audit-Log-Einträge
func ImproveSkill(c *gin.Context) {
// ImproveSkillOld verbessert eine bestehende Fertigkeit und erstellt Audit-Log-Einträge
func ImproveSkillOld(c *gin.Context) {
// Verwende gsmaster.LernCostRequest direkt
var request gsmaster.LernCostRequest
if err := c.ShouldBindJSON(&request); err != nil {
@@ -997,7 +910,7 @@ func ImproveSkill(c *gin.Context) {
// Verwende Klassenabkürzung wenn der Typ länger als 3 Zeichen ist
var characterClass string
if len(character.Typ) > 3 {
characterClass = gsmaster.GetClassAbbreviation(character.Typ)
characterClass = gsmaster.GetClassAbbreviationOld(character.Typ)
} else {
characterClass = character.Typ
}
@@ -1038,7 +951,7 @@ func ImproveSkill(c *gin.Context) {
costResult.CharacterClass = characterClass
costResult.SkillName = request.Name
err = gsmaster.GetLernCostNextLevel(&tempRequest, &costResult, request.Reward, nextLevel, character.Rasse)
err = gsmaster.GetLernCostNextLevelOld(&tempRequest, &costResult, request.Reward, nextLevel, character.Rasse)
if err != nil {
respondWithError(c, http.StatusBadRequest, fmt.Sprintf("Fehler bei Level %d: %v", nextLevel, err))
return
@@ -1195,8 +1108,8 @@ func ImproveSkill(c *gin.Context) {
c.JSON(http.StatusOK, response)
}
// LearnSpell lernt einen neuen Zauber und erstellt Audit-Log-Einträge
func LearnSpell(c *gin.Context) {
// LearnSpellOld lernt einen neuen Zauber und erstellt Audit-Log-Einträge
func LearnSpellOld(c *gin.Context) {
charID := c.Param("id")
var character models.Char
@@ -1218,7 +1131,7 @@ func LearnSpell(c *gin.Context) {
Action: "learn",
}
cost, _, _, err := calculateSingleCost(&character, &costRequest)
cost, _, _, err := calculateSingleCostOld(&character, &costRequest)
if err != nil {
respondWithError(c, http.StatusBadRequest, "Fehler bei der Kostenberechnung: "+err.Error())
return
@@ -1267,8 +1180,8 @@ func LearnSpell(c *gin.Context) {
})
}
// GetRewardTypes liefert verfügbare Belohnungsarten für ein bestimmtes Lernszenario
func GetRewardTypes(c *gin.Context) {
// GetRewardTypesOld liefert verfügbare Belohnungsarten für ein bestimmtes Lernszenario
func GetRewardTypesOld(c *gin.Context) {
characterID := c.Param("id")
learningType := c.Query("learning_type") // 'improve', 'learn', 'spell'
skillName := c.Query("skill_name")
@@ -1381,7 +1294,7 @@ func GetAvailableSkillsNewSystem(c *gin.Context) {
// Erstelle SkillCostResultNew
levelResult := gsmaster.SkillCostResultNew{
CharacterID: fmt.Sprintf("%d", character.ID),
CharacterClass: getCharacterClass(&character),
CharacterClass: getCharacterClassOld(&character),
SkillName: skill.Name,
TargetLevel: 1,
}
@@ -1390,7 +1303,7 @@ func GetAvailableSkillsNewSystem(c *gin.Context) {
remainingGold := request.UseGold
// Hole die vollständigen Skill-Informationen für die Kostenberechnung
skillLearningInfo, err := models.GetSkillCategoryAndDifficulty(skill.Name, getCharacterClass(&character))
skillLearningInfo, err := models.GetSkillCategoryAndDifficultyNew(skill.Name, getCharacterClassOld(&character))
if err != nil {
// Fallback für unbekannte Skills
skillLearningInfo = &models.SkillLearningInfo{
@@ -1445,7 +1358,7 @@ func GetAvailableSpellsNewSystem(c *gin.Context) {
return
}
charakteClass := getCharacterClass(&character)
charakteClass := getCharacterClassOld(&character)
// Hole alle verfügbaren Zauber aus der gsmaster Datenbank, aber filtere Placeholder aus
var allSpells []models.Spell
@@ -1535,8 +1448,8 @@ func GetAvailableSpellsNewSystem(c *gin.Context) {
})
}
// GetAvailableSkills gibt alle verfügbaren Fertigkeiten mit Lernkosten zurück
func GetAvailableSkills(c *gin.Context) {
// GetAvailableSkillsOld gibt alle verfügbaren Fertigkeiten mit Lernkosten zurück
func GetAvailableSkillsOld(c *gin.Context) {
characterID := c.Param("id")
rewardType := c.Query("reward_type")
@@ -1581,7 +1494,7 @@ func GetAvailableSkills(c *gin.Context) {
}
// Berechne Lernkosten mit GetLernCostNextLevel
epCost, goldCost := calculateSkillLearningCosts(skill, character, rewardType)
epCost, goldCost := calculateSkillLearningCostsOld(skill, character, rewardType)
skillInfo := gin.H{
"name": skill.Name,
@@ -1602,8 +1515,8 @@ func GetAvailableSkills(c *gin.Context) {
})
}
// calculateSkillLearningCosts berechnet die EP- und Goldkosten für das Lernen einer Fertigkeit mit GetLernCostNextLevel
func calculateSkillLearningCosts(skill models.Skill, character models.Char, rewardType string) (int, int) {
// calculateSkillLearningCostsOld berechnet die EP- und Goldkosten für das Lernen einer Fertigkeit mit GetLernCostNextLevel
func calculateSkillLearningCostsOld(skill models.Skill, character models.Char, rewardType string) (int, int) {
// Erstelle LernCostRequest für das Lernen (Level 0 -> 1)
var rewardTypePtr *string
if rewardType != "" && rewardType != "default" {
@@ -1625,7 +1538,7 @@ func calculateSkillLearningCosts(skill models.Skill, character models.Char, rewa
// Erstelle SkillCostResultNew
costResult := gsmaster.SkillCostResultNew{
CharacterID: fmt.Sprintf("%d", character.ID),
CharacterClass: getCharacterClass(&character),
CharacterClass: getCharacterClassOld(&character),
SkillName: skill.Name,
Category: skill.Category,
Difficulty: skill.Difficulty,
@@ -1633,7 +1546,7 @@ func calculateSkillLearningCosts(skill models.Skill, character models.Char, rewa
}
// Berechne Kosten mit GetLernCostNextLevel
err := gsmaster.GetLernCostNextLevel(&request, &costResult, rewardTypePtr, 1, character.Typ)
err := gsmaster.GetLernCostNextLevelOld(&request, &costResult, rewardTypePtr, 1, character.Typ)
if err != nil {
// Fallback zu Standard-Kosten bei Fehler
epCost := 100
backend/character/handlers_test.go
+3 -3
View File
@@ -94,7 +94,7 @@ func TestImproveSkillHandler(t *testing.T) {
c.Request = req
// Call the actual handler function
ImproveSkill(c)
ImproveSkillOld(c)
// Print the actual response to see what we get
t.Logf("Response Status: %d", w.Code)
@@ -204,7 +204,7 @@ func TestImproveSkillHandler(t *testing.T) {
c, _ := gin.CreateTestContext(w)
c.Request = req
ImproveSkill(c)
ImproveSkillOld(c)
assert.Equal(t, http.StatusBadRequest, w.Code, "Should return 400 for insufficient EP")
@@ -234,7 +234,7 @@ func TestImproveSkillHandler(t *testing.T) {
c, _ := gin.CreateTestContext(w)
c.Request = req
ImproveSkill(c)
ImproveSkillOld(c)
assert.Equal(t, http.StatusNotFound, w.Code, "Should return 404 for non-existent character")
backend/character/lerncost_handler.go
+21 -21
View File
@@ -85,7 +85,7 @@ func GetLernCost(c *gin.Context) {
// Verwende Klassenabkürzung wenn der Typ länger als 3 Zeichen ist
if len(character.Typ) > 3 {
costResult.CharacterClass = gsmaster.GetClassAbbreviation(character.Typ)
costResult.CharacterClass = gsmaster.GetClassAbbreviationOld(character.Typ)
} else {
costResult.CharacterClass = character.Typ
}
@@ -108,7 +108,7 @@ func GetLernCost(c *gin.Context) {
Difficulty: costResult.Difficulty,
TargetLevel: 1, // Lernkosten sind für das Erlernen der Fertigkeit (Level 1)
}
err := gsmaster.GetLernCostNextLevel(&request, &levelResult, request.Reward, 1, character.Typ)
err := gsmaster.GetLernCostNextLevelOld(&request, &levelResult, request.Reward, 1, character.Typ)
if err != nil {
respondWithError(c, http.StatusBadRequest, "Fehler bei der Kostenberechnung: "+err.Error())
return
@@ -125,7 +125,7 @@ func GetLernCost(c *gin.Context) {
Difficulty: costResult.Difficulty,
TargetLevel: i,
}
err := gsmaster.GetLernCostNextLevel(&request, &levelResult, request.Reward, i, character.Typ)
err := gsmaster.GetLernCostNextLevelOld(&request, &levelResult, request.Reward, i, character.Typ)
if err != nil {
respondWithError(c, http.StatusBadRequest, "Fehler bei der Kostenberechnung: "+err.Error())
return
@@ -220,7 +220,7 @@ func GetLernCostNewSystem(c *gin.Context) {
response = append(response, levelResult)
} else {
// Skill learning logic
skillInfo, err := models.GetSkillCategoryAndDifficulty(skillName, characterClass)
skillInfo, err := models.GetSkillCategoryAndDifficultyNew(skillName, characterClass)
if err != nil {
respondWithError(c, http.StatusBadRequest, fmt.Sprintf("Fertigkeit '%s' nicht gefunden oder nicht für Klasse '%s' verfügbar: %v", skillName, characterClass, err))
return
@@ -246,7 +246,7 @@ func GetLernCostNewSystem(c *gin.Context) {
} else {
// Für "improve" Aktion: berechne für jedes Level von current+1 bis 18
// Improvement only works on skills, not spells
skillInfo, err := models.GetSkillCategoryAndDifficulty(skillName, characterClass)
skillInfo, err := models.GetSkillCategoryAndDifficultyNew(skillName, characterClass)
if err != nil {
respondWithError(c, http.StatusBadRequest, fmt.Sprintf("Fertigkeit '%s' nicht gefunden oder nicht für Klasse '%s' verfügbar: %v", skillName, characterClass, err))
return
@@ -572,7 +572,7 @@ func GetSkillCost(c *gin.Context) {
}
// Single cost calculation
cost, originalCost, skillInfo, err := calculateSingleCost(&character, &request)
cost, originalCost, skillInfo, err := calculateSingleCostOld(&character, &request)
if err != nil {
respondWithError(c, http.StatusBadRequest, "Fehler bei der Kostenberechnung: "+err.Error())
return
@@ -581,7 +581,7 @@ func GetSkillCost(c *gin.Context) {
// Originalkosten berechnen (ohne PP-Reduktion)
originalRequest := request
originalRequest.UsePP = 0
_, _, _, err = calculateSingleCost(&character, &originalRequest)
_, _, _, err = calculateSingleCostOld(&character, &originalRequest)
if err != nil {
respondWithError(c, http.StatusBadRequest, "Fehler bei der ursprünglichen Kostenberechnung: "+err.Error())
return
@@ -678,32 +678,32 @@ func getCurrentSkillLevel(character *models.Char, skillName, skillType string) i
}
// Helper function to calculate single cost
func calculateSingleCost(character *models.Char, request *SkillCostRequest) (*models.LearnCost, *models.LearnCost, *skillInfo, error) {
func calculateSingleCostOld(character *models.Char, request *SkillCostRequest) (*models.LearnCost, *models.LearnCost, *skillInfo, error) {
var cost *models.LearnCost
var err error
var info skillInfo
switch {
case request.Action == "learn" && request.Type == "skill":
cost, err = gsmaster.CalculateDetailedSkillLearningCost(request.Name, character.Typ)
cost, err = gsmaster.CalculateDetailedSkillLearningCostOld(request.Name, character.Typ)
if err == nil {
info = getSkillInfo(request.Name, request.Type)
info = getSkillInfoOld(request.Name, request.Type)
}
case request.Action == "improve" && request.Type == "skill":
cost, err = gsmaster.CalculateDetailedSkillImprovementCost(request.Name, character.Typ, request.CurrentLevel)
cost, err = gsmaster.CalculateDetailedSkillImprovementCostOld(request.Name, character.Typ, request.CurrentLevel)
if err == nil {
info = getSkillInfo(request.Name, request.Type)
info = getSkillInfoOld(request.Name, request.Type)
}
case request.Action == "improve" && request.Type == "weapon":
cost, err = gsmaster.CalculateDetailedSkillImprovementCost(request.Name, character.Typ, request.CurrentLevel)
cost, err = gsmaster.CalculateDetailedSkillImprovementCostOld(request.Name, character.Typ, request.CurrentLevel)
if err == nil {
info = getSkillInfo(request.Name, request.Type)
info = getSkillInfoOld(request.Name, request.Type)
}
case request.Action == "learn" && request.Type == "spell":
cost, err = gsmaster.CalculateDetailedSpellLearningCost(request.Name, character.Typ)
cost, err = gsmaster.CalculateDetailedSpellLearningCostOld(request.Name, character.Typ)
if err == nil {
info = getSpellInfo(request.Name)
}
@@ -813,7 +813,7 @@ func calculateMultiLevelCost(character *models.Char, request *SkillCostRequest)
tempRequest.UsePP = 0
}
cost, originalCost, skillInfo, err := calculateSingleCost(character, &tempRequest)
cost, originalCost, skillInfo, err := calculateSingleCostOld(character, &tempRequest)
if err != nil {
continue
}
@@ -821,7 +821,7 @@ func calculateMultiLevelCost(character *models.Char, request *SkillCostRequest)
// Originalkosten berechnen (ohne PP)
originalRequest := tempRequest
originalRequest.UsePP = 0
_, _, _, _ = calculateSingleCost(character, &originalRequest)
_, _, _, _ = calculateSingleCostOld(character, &originalRequest)
// PP-Informationen sammeln (fertigkeitsspezifisch)
availablePP := getPPForSkill(character, request.Name)
@@ -908,7 +908,7 @@ type skillInfo struct {
Difficulty string
}
func getSkillInfo(skillName, skillType string) skillInfo {
func getSkillInfoOld(skillName, skillType string) skillInfo {
var skill models.Skill
if err := skill.First(skillName); err != nil {
return skillInfo{Category: "unknown", Difficulty: "unknown"}
@@ -920,12 +920,12 @@ func getSkillInfo(skillName, skillType string) skillInfo {
if category == "" {
// Standard-Kategorien basierend auf Skill-Namen
category = gsmaster.GetDefaultCategory(skillName)
category = gsmaster.GetDefaultCategoryOld(skillName)
}
if difficulty == "" {
// Standard-Schwierigkeit für verschiedene Skills
difficulty = gsmaster.GetDefaultDifficulty(skillName)
difficulty = gsmaster.GetDefaultDifficultyOld(skillName)
}
return skillInfo{Category: category, Difficulty: difficulty}
@@ -1039,7 +1039,7 @@ func applyPPReduction(request *SkillCostRequest, cost *models.LearnCost, availab
func CalcSkillLearnCost(req *gsmaster.LernCostRequest, skillCostInfo *gsmaster.SkillCostResultNew) error {
// Fallback-Werte für Skills ohne definierte Kategorie/Schwierigkeit
result, err := gsmaster.CalculateSkillLearningCosts(skillCostInfo.CharacterClass, skillCostInfo.Category, skillCostInfo.Difficulty)
result, err := gsmaster.CalculateSkillLearningCostsOld(skillCostInfo.CharacterClass, skillCostInfo.Category, skillCostInfo.Difficulty)
if err != nil {
return err
}
backend/character/lerncost_handler_test.go
+8 -8
View File
@@ -258,27 +258,27 @@ func TestHelperFunctions(t *testing.T) {
func TestGSMasterIntegration(t *testing.T) {
t.Run("GetDefaultCategory integration", func(t *testing.T) {
// Test that we can access the exported function from gsmaster
category := gsmaster.GetDefaultCategory("Menschenkenntnis")
category := gsmaster.GetDefaultCategoryOld("Menschenkenntnis")
assert.Equal(t, "Sozial", category, "Should return correct category for Menschenkenntnis")
category = gsmaster.GetDefaultCategory("Stichwaffen")
category = gsmaster.GetDefaultCategoryOld("Stichwaffen")
assert.Equal(t, "Waffen", category, "Should return correct category for Stichwaffen")
// Test fallback for unknown skill
category = gsmaster.GetDefaultCategory("NonExistentSkill")
category = gsmaster.GetDefaultCategoryOld("NonExistentSkill")
assert.Equal(t, "Alltag", category, "Should return default category for unknown skill")
})
t.Run("GetDefaultDifficulty integration", func(t *testing.T) {
// Test that we can access the exported function from gsmaster
difficulty := gsmaster.GetDefaultDifficulty("Menschenkenntnis")
difficulty := gsmaster.GetDefaultDifficultyOld("Menschenkenntnis")
assert.Equal(t, "schwer", difficulty, "Should return correct difficulty for Menschenkenntnis")
difficulty = gsmaster.GetDefaultDifficulty("Stichwaffen")
difficulty = gsmaster.GetDefaultDifficultyOld("Stichwaffen")
assert.Equal(t, "leicht", difficulty, "Should return correct difficulty for Stichwaffen")
// Test fallback for unknown skill
difficulty = gsmaster.GetDefaultDifficulty("NonExistentSkill")
difficulty = gsmaster.GetDefaultDifficultyOld("NonExistentSkill")
assert.Equal(t, "normal", difficulty, "Should return default difficulty for unknown skill")
})
@@ -319,8 +319,8 @@ func TestGSMasterIntegration(t *testing.T) {
skillName := "Menschenkenntnis"
// Get skill info using exported functions
category := gsmaster.GetDefaultCategory(skillName)
difficulty := gsmaster.GetDefaultDifficulty(skillName)
category := gsmaster.GetDefaultCategoryOld(skillName)
difficulty := gsmaster.GetDefaultDifficultyOld(skillName)
assert.Equal(t, "Sozial", category, "Should get correct category from gsmaster")
assert.Equal(t, "schwer", difficulty, "Should get correct difficulty from gsmaster")
backend/character/routes.go
+5 -5
View File
@@ -24,19 +24,19 @@ func RegisterRoutes(r *gin.RouterGroup) {
// im Frontend wir nur noch der neue Endpunkt benutzt
//charGrp.POST("/lerncost", GetLernCost) // alter Hauptendpunkt für alle Kostenberechnungen (verwendet lerningCostsData)
charGrp.POST("/lerncost-new", GetLernCostNewSystem) // neuer Hauptendpunkt für alle Kostenberechnungen (verwendet neue Datenbank)
charGrp.POST("/improve-skill", ImproveSkill) // Fertigkeit verbessern
charGrp.POST("/improve-skill", ImproveSkillOld) // Fertigkeit verbessern
// Lernen und Verbessern (mit automatischem Audit-Log)
charGrp.POST("/:id/learn-skill", LearnSkill) // Fertigkeit lernen
charGrp.POST("/:id/learn-spell", LearnSpell) // Zauber lernen
charGrp.POST("/:id/learn-skill", LearnSkillOld) // Fertigkeit lernen
charGrp.POST("/:id/learn-spell", LearnSpellOld) // Zauber lernen
// Fertigkeiten-Information
charGrp.GET("/:id/available-skills", GetAvailableSkills) // Verfügbare Fertigkeiten mit Kosten (bereits gelernte ausgeschlossen)
charGrp.GET("/:id/available-skills", GetAvailableSkillsOld) // Verfügbare Fertigkeiten mit Kosten (bereits gelernte ausgeschlossen)
charGrp.POST("/available-skills-new", GetAvailableSkillsNewSystem) // Verfügbare Fertigkeiten mit Kosten (bereits gelernte ausgeschlossen)
charGrp.POST("/available-spells-new", GetAvailableSpellsNewSystem) // Verfügbare Zauber mit Kosten (bereits gelernte ausgeschlossen)
// Belohnungsarten für verschiedene Lernszenarien
charGrp.GET("/:id/reward-types", GetRewardTypes) // Verfügbare Belohnungsarten je nach Kontext
charGrp.GET("/:id/reward-types", GetRewardTypesOld) // Verfügbare Belohnungsarten je nach Kontext
// Praxispunkte-Verwaltung
charGrp.GET("/:id/practice-points", GetPracticePoints)
backend/character/skill_api_test.go
+4 -4
View File
@@ -52,7 +52,7 @@ func TestGetAvailableSkills(t *testing.T) {
fmt.Printf("Character EP: %d, Gold: %d\n", testChar.Erfahrungsschatz.EP, testChar.Vermoegen.Goldstücke)
// Call the handler function
GetAvailableSkills(c)
GetAvailableSkillsOld(c)
// Print the response for debugging
fmt.Printf("Response Status: %d\n", w.Code)
@@ -145,7 +145,7 @@ func TestGetAvailableSkills(t *testing.T) {
fmt.Printf("Test: Get available skills for character ID %s (noGold reward)\n", characterID)
// Call the handler function
GetAvailableSkills(c)
GetAvailableSkillsOld(c)
// Print the response for debugging
fmt.Printf("Response Status: %d\n", w.Code)
@@ -193,7 +193,7 @@ func TestGetAvailableSkills(t *testing.T) {
c.Request = req
c.Params = []gin.Param{{Key: "id", Value: "99999"}}
GetAvailableSkills(c)
GetAvailableSkillsOld(c)
// Should return 404
assert.Equal(t, http.StatusNotFound, w.Code, "Status code should be 404 Not Found")
@@ -225,7 +225,7 @@ func TestGetAvailableSkills(t *testing.T) {
c.Request = req
c.Params = []gin.Param{{Key: "id", Value: characterID}}
GetAvailableSkills(c)
GetAvailableSkillsOld(c)
assert.Equal(t, http.StatusOK, w.Code, "Status code should be 200 OK")
backend/character/skill_learning_dialog_test.go
+3 -3
View File
@@ -34,7 +34,7 @@ func TestSkillLearningDialogWorkflow(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.learningType+"_"+tc.skillName, func(t *testing.T) {
router := gin.New()
router.GET("/api/characters/:id/reward-types", GetRewardTypes)
router.GET("/api/characters/:id/reward-types", GetRewardTypesOld)
url := "/api/characters/1/reward-types?learning_type=" + tc.learningType +
"&skill_name=" + tc.skillName + "&skill_type=" + tc.skillType
@@ -209,7 +209,7 @@ func TestSkillLearningDialogAuth(t *testing.T) {
c.Abort()
})
router.GET("/api/characters/:id/reward-types", GetRewardTypes)
router.GET("/api/characters/:id/reward-types", GetRewardTypesOld)
req, _ := http.NewRequest("GET", "/api/characters/1/reward-types", nil)
w := httptest.NewRecorder()
@@ -262,7 +262,7 @@ func TestRewardTypeVariations(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
router := gin.New()
router.GET("/api/characters/:id/reward-types", GetRewardTypes)
router.GET("/api/characters/:id/reward-types", GetRewardTypesOld)
url := "/api/characters/1/reward-types?learning_type=" + tc.learningType +
"&skill_type=" + tc.skillType + "&skill_name=TestSkill"
backend/character/skill_update_test.go
+2 -2
View File
@@ -124,7 +124,7 @@ func TestImproveSkillUpdatesLevel(t *testing.T) {
c.Request = req
// Call the actual handler function
ImproveSkill(c)
ImproveSkillOld(c)
// Print the actual response to see what we get
t.Logf("Response Status: %d", w.Code)
@@ -180,7 +180,7 @@ func TestImproveSkillUpdatesLevel(t *testing.T) {
c.Params = gin.Params{gin.Param{Key: "id", Value: "20"}}
// Call the actual handler function
LearnSkill(c)
LearnSkillOld(c)
// Check if we got a successful response
assert.Equal(t, http.StatusOK, w.Code, "Status code should be 200 OK")
backend/gsmaster/beidhändiger_kampf_test.go
+4 -4
View File
@@ -11,7 +11,7 @@ func TestBeidhändigerKampfFürPS(t *testing.T) {
// Testfall für das Erlernen von "Beidhändiger Kampf" durch einen Priester Streiter (PS)
t.Run("Lernkosten für Beidhändiger Kampf als PS", func(t *testing.T) {
// Verwende exportierte Funktion zum Berechnen der Lernkosten
result, err := CalculateDetailedSkillLearningCost("Beidhändiger Kampf", "PS")
result, err := CalculateDetailedSkillLearningCostOld("Beidhändiger Kampf", "PS")
assert.NoError(t, err, "Es sollte keinen Fehler beim Berechnen der Lernkosten geben")
assert.True(t, result.LE > 0, "LE-Kosten sollten größer als 0 sein")
@@ -31,7 +31,7 @@ func TestBeidhändigerKampfFürPS(t *testing.T) {
// von Stufe 5 auf 6
t.Run("Verbesserungskosten für Beidhändiger Kampf als PS von 5 auf 6", func(t *testing.T) {
// Verwende exportierte Funktion zum Berechnen der Verbesserungskosten
result, err := CalculateDetailedSkillImprovementCost("Beidhändiger Kampf", "PS", 5)
result, err := CalculateDetailedSkillImprovementCostOld("Beidhändiger Kampf", "PS", 5)
assert.NoError(t, err, "Es sollte keinen Fehler beim Berechnen der Verbesserungskosten geben")
assert.True(t, result.LE > 0, "LE-Kosten sollten größer als 0 sein")
@@ -51,7 +51,7 @@ func TestBeidhändigerKampfFürPS(t *testing.T) {
// von Stufe 6 auf 7
t.Run("Verbesserungskosten für Beidhändiger Kampf als PS von 6 auf 7", func(t *testing.T) {
// Verwende exportierte Funktion zum Berechnen der Verbesserungskosten
result, err := CalculateDetailedSkillImprovementCost("Beidhändiger Kampf", "PS", 6)
result, err := CalculateDetailedSkillImprovementCostOld("Beidhändiger Kampf", "PS", 6)
assert.NoError(t, err, "Es sollte keinen Fehler beim Berechnen der Verbesserungskosten geben")
assert.True(t, result.LE > 0, "LE-Kosten sollten größer als 0 sein")
@@ -71,7 +71,7 @@ func TestBeidhändigerKampfFürPS(t *testing.T) {
// von Stufe 7 auf 8
t.Run("Verbesserungskosten für Beidhändiger Kampf als PS von 7 auf 8", func(t *testing.T) {
// Verwende exportierte Funktion zum Berechnen der Verbesserungskosten
result, err := CalculateDetailedSkillImprovementCost("Beidhändiger Kampf", "PS", 7)
result, err := CalculateDetailedSkillImprovementCostOld("Beidhändiger Kampf", "PS", 7)
assert.NoError(t, err, "Es sollte keinen Fehler beim Berechnen der Verbesserungskosten geben")
assert.True(t, result.LE > 0, "LE-Kosten sollten größer als 0 sein")
backend/gsmaster/learning_costs.go
+31 -31
View File
@@ -322,15 +322,15 @@ func GetLearningCosts() *LearningCostsTable {
return learningCosts
}
// CalculateSkillLearningCosts berechnet die Kosten für das Lernen einer Fertigkeit
func CalculateSkillLearningCosts(characterClass, category, difficulty string) (*SkillCostResult, error) {
// CalculateSkillLearningCostsOld berechnet die Kosten für das Lernen einer Fertigkeit
func CalculateSkillLearningCostsOld(characterClass, category, difficulty string) (*SkillCostResult, error) {
//Überprüfe ob die tabelle vorhanden ist in der die EP-Kosten pro LE for die einzelnen Kategorien für jede Charakterklasse definiert sind
if learningCosts.EPPerTE == nil {
return nil, errors.New("keine EP-per-TE-Definition gefunden")
}
// Konvertiere Vollnamen der Charakterklasse zu Abkürzungen falls nötig
classKey := GetClassAbbreviation(characterClass)
classKey := GetClassAbbreviationOld(characterClass)
// Hole die EP-Kosten pro TE für die angegebene Charakterklasse
classData, exists := learningCosts.EPPerTE[classKey]
@@ -373,14 +373,14 @@ func CalculateSkillLearningCosts(characterClass, category, difficulty string) (*
}, nil
}
// CalculateSpellLearningCosts berechnet die Kosten für das Lernen eines Zaubers
func CalculateSpellLearningCosts(characterClass, spellSchool string, leNeeded int) (*SkillCostResult, error) {
// CalculateSpellLearningCostsOld berechnet die Kosten für das Lernen eines Zaubers
func CalculateSpellLearningCostsOld(characterClass, spellSchool string, leNeeded int) (*SkillCostResult, error) {
if learningCosts.SpellEPPerLE == nil {
return nil, errors.New("keine Zauber-EP-Definition gefunden")
}
// Konvertiere Vollnamen zu Abkürzungen falls nötig
classKey := GetClassAbbreviation(characterClass)
classKey := GetClassAbbreviationOld(characterClass)
classData, exists := learningCosts.SpellEPPerLE[classKey]
if !exists {
@@ -438,13 +438,13 @@ type SkillCostResultNew struct {
Details map[string]interface{} `json:"details"`
}
// CalculateDetailedSkillLearningCost berechnet die Kosten für das Lernen einer Fertigkeit mit Details
func CalculateDetailedSkillLearningCost(skillName, characterClass string) (*models.LearnCost, error) {
// CalculateDetailedSkillLearningCostOld berechnet die Kosten für das Lernen einer Fertigkeit mit Details
func CalculateDetailedSkillLearningCostOld(skillName, characterClass string) (*models.LearnCost, error) {
// Fallback-Werte für Skills ohne definierte Kategorie/Schwierigkeit
category := GetDefaultCategory(skillName)
difficulty := GetDefaultDifficulty(skillName)
category := GetDefaultCategoryOld(skillName)
difficulty := GetDefaultDifficultyOld(skillName)
result, err := CalculateSkillLearningCosts(characterClass, category, difficulty)
result, err := CalculateSkillLearningCostsOld(characterClass, category, difficulty)
if err != nil {
return nil, err
}
@@ -458,15 +458,15 @@ func CalculateDetailedSkillLearningCost(skillName, characterClass string) (*mode
}, nil
}
// CalculateDetailedSkillImprovementCost berechnet die Kosten für die Verbesserung einer Fertigkeit
func CalculateDetailedSkillImprovementCost(skillName, characterClass string, currentLevel int) (*models.LearnCost, error) {
// CalculateDetailedSkillImprovementCostOld berechnet die Kosten für die Verbesserung einer Fertigkeit
func CalculateDetailedSkillImprovementCostOld(skillName, characterClass string, currentLevel int) (*models.LearnCost, error) {
// Fallback-Werte für Skills ohne definierte Kategorie/Schwierigkeit
category := GetDefaultCategory(skillName)
difficulty := GetDefaultDifficulty(skillName)
category := GetDefaultCategoryOld(skillName)
difficulty := GetDefaultDifficultyOld(skillName)
// Verwende die Lernkosten als Basis für Verbesserungen
// In einer vollständigen Implementierung würden hier die ImprovementCost-Tabellen verwendet
baseCost, err := CalculateSkillLearningCosts(characterClass, category, difficulty)
baseCost, err := CalculateSkillLearningCostsOld(characterClass, category, difficulty)
if err != nil {
return nil, err
}
@@ -490,15 +490,15 @@ func CalculateDetailedSkillImprovementCost(skillName, characterClass string, cur
}, nil
}
// CalculateDetailedSpellLearningCost berechnet die Kosten für das Lernen eines Zaubers
func CalculateDetailedSpellLearningCost(spellName, characterClass string) (*models.LearnCost, error) {
// CalculateDetailedSpellLearningCostOld berechnet die Kosten für das Lernen eines Zaubers
func CalculateDetailedSpellLearningCostOld(spellName, characterClass string) (*models.LearnCost, error) {
// Standard-Zauberschule bestimmen
spellSchool := getDefaultSpellSchool(spellName)
spellSchool := getDefaultSpellSchoolOld(spellName)
// Standard LE für Zauber
standardLE := 4
result, err := CalculateSpellLearningCosts(characterClass, spellSchool, standardLE)
result, err := CalculateSpellLearningCostsOld(characterClass, spellSchool, standardLE)
if err != nil {
return nil, err
}
@@ -624,8 +624,8 @@ func GetAvailableSkillCategories(skillName string) []SkillCategoryOption {
}
// Fallback: verwende Standard-Mapping (erste gefundene Kategorie)
category := GetDefaultCategory(skillName)
difficulty := GetDefaultDifficulty(skillName)
category := GetDefaultCategoryOld(skillName)
difficulty := GetDefaultDifficultyOld(skillName)
// Bestimme LE basierend auf Schwierigkeit
le := 2 // Standard
@@ -645,8 +645,8 @@ func GetAvailableSkillCategories(skillName string) []SkillCategoryOption {
}
}
// GetDefaultCategory gibt die erste (bevorzugte) Kategorie für eine Fertigkeit zurück
func GetDefaultCategory(skillName string) string {
// GetDefaultCategoryOld gibt die erste (bevorzugte) Kategorie für eine Fertigkeit zurück
func GetDefaultCategoryOld(skillName string) string {
// WICHTIG: Wir verwenden bewusst die erste gefundene Kategorie als Standard.
// Für das Lernen ist es unerheblich, aber später wird es für andere Dinge wichtig werden.
// Die Reihenfolge der Kategorien ist nach Wichtigkeit/Häufigkeit sortiert.
@@ -711,11 +711,11 @@ func GetDefaultCategory(skillName string) string {
func GetDifficulty(skillName string, category string) string {
// aktuell nur ein Wrapper das die Stantruktur noch keine Fettigkeiten in mehreren Kategorien enthält
return GetDefaultDifficulty(skillName)
return GetDefaultDifficultyOld(skillName)
}
// GetDefaultDifficulty gibt die erste (bevorzugte) Schwierigkeit für eine Fertigkeit zurück
func GetDefaultDifficulty(skillName string) string {
// GetDefaultDifficultyOld gibt die erste (bevorzugte) Schwierigkeit für eine Fertigkeit zurück
func GetDefaultDifficultyOld(skillName string) string {
// WICHTIG: Korrespondiert mit getDefaultCategory() - verwendet die Schwierigkeit
// der ersten (bevorzugten) Kategorie für konsistente Ergebnisse.
// Schwierigkeitszuordnung basierend auf dem Fertigkeitsnamen und Lerntabellen.md
@@ -791,8 +791,8 @@ func GetDefaultDifficulty(skillName string) string {
return "normal"
}
// getDefaultSpellSchool gibt eine Standard-Zauberschule für einen Zauber zurück
func getDefaultSpellSchool(spellName string) string {
// getDefaultSpellSchoolOld gibt eine Standard-Zauberschule für einen Zauber zurück
func getDefaultSpellSchoolOld(spellName string) string {
// Vereinfachte Zuordnung von Zauber zu Schulen
spellSchoolMap := map[string]string{
"Licht": "Erschaffen",
@@ -815,8 +815,8 @@ func getDefaultSpellSchool(spellName string) string {
return "Verändern"
}
// GetClassAbbreviation konvertiert Charakterklassen-Vollnamen zu Abkürzungen
func GetClassAbbreviation(characterClass string) string {
// GetClassAbbreviationOld konvertiert Charakterklassen-Vollnamen zu Abkürzungen
func GetClassAbbreviationOld(characterClass string) string {
// Mapping von Vollnamen zu Abkürzungen
classMap := map[string]string{
// Abenteurer-Klassen
backend/gsmaster/lernkosten_maps.go
+23 -23
View File
@@ -491,7 +491,7 @@ var learningCostsData = &LearningCostsTable2{
},
}
func GetSkillCategory(skillName string) string {
func GetSkillCategoryOld(skillName string) string {
for category, difficulties := range learningCostsData.ImprovementCost {
for _, data := range difficulties {
@@ -503,7 +503,7 @@ func GetSkillCategory(skillName string) string {
return "Unbekannt"
}
func GetSkillDifficulty(category string, skillName string) string {
func GetSkillDifficultyOld(category string, skillName string) string {
// Wenn eine Kategorie angegeben ist, suche nur in dieser Kategorie
if category != "" {
difficulties, ok := learningCostsData.ImprovementCost[category]
@@ -541,8 +541,8 @@ func contains(slice []string, item string) bool {
//### End of Helper functions ###
// GetSpellInfo returns the school and level of a spell from the database
func GetSpellInfo(spellName string) (string, int, error) {
// GetSpellInfoNew returns the school and level of a spell from the database
func GetSpellInfoNew(spellName string) (string, int, error) {
// Create a Spell instance to search in the database
var spell models.Spell
@@ -555,16 +555,16 @@ func GetSpellInfo(spellName string) (string, int, error) {
return spell.Category, spell.Stufe, nil
}
// GetSpecialization returns the specialization school for a character (placeholder)
// GetSpecializationOld returns the specialization school for a character (placeholder)
// This should be implemented to get the actual specialization from character data
func GetSpecialization(characterID string) string {
func GetSpecializationOld(characterID string) string {
// TODO: Implement actual character specialization lookup
// For now, return a default specialization
return "Beherrschen"
}
// findBestCategoryForSkillImprovement findet die Kategorie mit den niedrigsten EP-Kosten für eine Fertigkeit
func findBestCategoryForSkillImprovement(skillName, characterClass string, level int) (string, string, error) {
// findBestCategoryForSkillImprovementOld findet die Kategorie mit den niedrigsten EP-Kosten für eine Fertigkeit
func findBestCategoryForSkillImprovementOld(skillName, characterClass string, level int) (string, string, error) {
classKey := characterClass
// Sammle alle Kategorien und Schwierigkeiten, in denen die Fertigkeit verfügbar ist
@@ -612,8 +612,8 @@ func findBestCategoryForSkillImprovement(skillName, characterClass string, level
return bestOption.category, bestOption.difficulty, nil
}
// FindBestCategoryForSkillLearning findet die Kategorie mit den niedrigsten EP-Kosten für das Lernen einer Fertigkeit
func FindBestCategoryForSkillLearning(skillName, characterClass string) (string, string, error) {
// FindBestCategoryForSkillLearningOld findet die Kategorie mit den niedrigsten EP-Kosten für das Lernen einer Fertigkeit
func FindBestCategoryForSkillLearningOld(skillName, characterClass string) (string, string, error) {
classKey := characterClass
// Sammle alle Kategorien und Schwierigkeiten, in denen die Fertigkeit verfügbar ist
@@ -659,7 +659,7 @@ func FindBestCategoryForSkillLearning(skillName, characterClass string) (string,
return bestOption.category, bestOption.difficulty, nil
}
func CalcSkillLernCost(costResult *SkillCostResultNew, reward *string) error {
func CalcSkillLernCostOld(costResult *SkillCostResultNew, reward *string) error {
// Berechne die Lernkosten basierend auf den aktuellen Werten im costResult
// Hier sollte die Logik zur Berechnung der Lernkosten implementiert werden
//Finde EP kosten für die Kategorie für die Charakterklasse aus learningCostsData.EPPerTE
@@ -669,7 +669,7 @@ func CalcSkillLernCost(costResult *SkillCostResultNew, reward *string) error {
// Wenn Kategorie und Schwierigkeit noch nicht gesetzt sind, finde die beste Option
if costResult.Category == "" || costResult.Difficulty == "" {
bestCategory, bestDifficulty, err := FindBestCategoryForSkillLearning(costResult.SkillName, classKey)
bestCategory, bestDifficulty, err := FindBestCategoryForSkillLearningOld(costResult.SkillName, classKey)
if err != nil {
return err
}
@@ -709,8 +709,8 @@ func CalcSkillLernCost(costResult *SkillCostResultNew, reward *string) error {
return nil
}
// CalcSkillImproveCost berechnet die Kosten für die Verbesserung einer Fertigkeit
func CalcSkillImproveCost(costResult *SkillCostResultNew, currentLevel int, reward *string) error {
// CalcSkillImproveCostOld berechnet die Kosten für die Verbesserung einer Fertigkeit
func CalcSkillImproveCostOld(costResult *SkillCostResultNew, currentLevel int, reward *string) error {
// Für Skill-Verbesserung könnten die Kosten vom aktuellen Level abhängen
//Finde EP kosten für die Kategorie für die Charakterklasse aus learningCostsData.EPPerTE
@@ -723,7 +723,7 @@ func CalcSkillImproveCost(costResult *SkillCostResultNew, currentLevel int, rewa
// Wenn Kategorie und Schwierigkeit noch nicht gesetzt sind, finde die beste Option
if costResult.Category == "" || costResult.Difficulty == "" {
bestCategory, bestDifficulty, err := findBestCategoryForSkillImprovement(costResult.SkillName, classKey, currentLevel+1)
bestCategory, bestDifficulty, err := findBestCategoryForSkillImprovementOld(costResult.SkillName, classKey, currentLevel+1)
if err != nil {
return err
}
@@ -775,12 +775,12 @@ func CalcSkillImproveCost(costResult *SkillCostResultNew, currentLevel int, rewa
return nil
}
// CalcSpellLernCost berechnet die Kosten für das Erlernen eines Zaubers
func CalcSpellLernCost(costResult *SkillCostResultNew, reward *string) error {
// CalcSpellLernCostOld berechnet die Kosten für das Erlernen eines Zaubers
func CalcSpellLernCostOld(costResult *SkillCostResultNew, reward *string) error {
// Für Zauber verwenden wir eine ähnliche Logik wie für Skills
// TODO: Implementiere spezifische Zauber-Kostenlogik wenn verfügbar
classKey := costResult.CharacterClass
spellCategory, spellLevel, err := GetSpellInfo(costResult.SkillName)
spellCategory, spellLevel, err := GetSpellInfoNew(costResult.SkillName)
if err != nil {
return fmt.Errorf("failed to get spell info: %w", err)
}
@@ -789,7 +789,7 @@ func CalcSpellLernCost(costResult *SkillCostResultNew, reward *string) error {
return fmt.Errorf("EP-Kosten für Zauber '%s' und Klasse '%s' nicht gefunden", costResult.SkillName, classKey)
}
if classKey == "Ma" {
spezialgebiet := GetSpecialization(costResult.CharacterID)
spezialgebiet := GetSpecializationOld(costResult.CharacterID)
if spellCategory == spezialgebiet {
SpellEPPerLE = 30 // Spezialgebiet für Magier
}
@@ -840,7 +840,7 @@ func CalcSpellLernCost(costResult *SkillCostResultNew, reward *string) error {
return nil
}
func GetLernCostNextLevel(request *LernCostRequest, costResult *SkillCostResultNew, reward *string, level int, characterRasse string) error {
func GetLernCostNextLevelOld(request *LernCostRequest, costResult *SkillCostResultNew, reward *string, level int, characterRasse string) error {
// Diese Funktion berechnet die Kosten für das Erlernen oder Verbessern einer Fertigkeit oder eines Zaubers
// abhängig von der Aktion (learn/improve) und der Belohnung.
// die Berechnung erfolgt immer für genau 1 Level
@@ -855,7 +855,7 @@ func GetLernCostNextLevel(request *LernCostRequest, costResult *SkillCostResultN
switch {
case request.Action == "learn" && request.Type == "skill":
// Skill-Lernen: Kein PP und kein Gold für EP erlaubt
err := CalcSkillLernCost(costResult, request.Reward)
err := CalcSkillLernCostOld(costResult, request.Reward)
if err != nil {
return fmt.Errorf("fehler bei der Kostenberechnung: %w", err)
}
@@ -867,7 +867,7 @@ func GetLernCostNextLevel(request *LernCostRequest, costResult *SkillCostResultN
// Zauber-Lernen: PP und Gold für EP ist erlaubt
costResult.PPUsed = request.UsePP
costResult.GoldUsed = request.UseGold
err := CalcSpellLernCost(costResult, request.Reward)
err := CalcSpellLernCostOld(costResult, request.Reward)
if err != nil {
return fmt.Errorf("fehler bei der Kostenberechnung: %w", err)
}
@@ -879,7 +879,7 @@ func GetLernCostNextLevel(request *LernCostRequest, costResult *SkillCostResultN
// Skill-Verbesserung: PP und Gold für EP ist erlaubt
costResult.PPUsed = request.UsePP
costResult.GoldUsed = request.UseGold
err := CalcSkillImproveCost(costResult, request.CurrentLevel, request.Reward)
err := CalcSkillImproveCostOld(costResult, request.CurrentLevel, request.Reward)
if err != nil {
return fmt.Errorf("fehler bei der Kostenberechnung: %w", err)
}
backend/gsmaster/lernkosten_maps_test.go
+16 -16
View File
@@ -63,7 +63,7 @@ func TestGetSkillCategory(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := GetSkillCategory(tt.skillName)
result := GetSkillCategoryOld(tt.skillName)
// Check if result is in the list of expected values
found := false
@@ -177,7 +177,7 @@ func TestGetSkillDifficulty(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := GetSkillDifficulty(tt.category, tt.skillName)
result := GetSkillDifficultyOld(tt.category, tt.skillName)
if result != tt.expected {
t.Errorf("GetSkillDifficulty(%q, %q) = %q, want %q", tt.category, tt.skillName, result, tt.expected)
}
@@ -339,7 +339,7 @@ func TestCalcSkillLernCost(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := CalcSkillLernCost(tt.costResult, nil) // nil reward for original tests
err := CalcSkillLernCostOld(tt.costResult, nil) // nil reward for original tests
if tt.expectError {
if err == nil {
@@ -434,19 +434,19 @@ func TestSkillCoverage(t *testing.T) {
skillsFound[skill] = false
// Test that GetSkillCategory can find this skill
foundCategory := GetSkillCategory(skill)
foundCategory := GetSkillCategoryOld(skill)
if foundCategory == "Unbekannt" {
t.Errorf("GetSkillCategory could not find skill: %s (should be in %s)", skill, category)
}
// Test that GetSkillDifficulty can find this skill without category
foundDifficulty := GetSkillDifficulty("", skill)
foundDifficulty := GetSkillDifficultyOld("", skill)
if foundDifficulty == "Unbekannt" {
t.Errorf("GetSkillDifficulty could not find skill: %s (should have difficulty %s)", skill, difficulty)
}
// Test that GetSkillDifficulty can find this skill with category
foundDifficultyWithCategory := GetSkillDifficulty(category, skill)
foundDifficultyWithCategory := GetSkillDifficultyOld(category, skill)
if foundDifficultyWithCategory == "Unbekannt" {
t.Errorf("GetSkillDifficulty could not find skill: %s in category %s (should have difficulty %s)", skill, category, difficulty)
}
@@ -493,7 +493,7 @@ func TestFindBestCategoryForSkill(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
category, difficulty, err := findBestCategoryForSkillImprovement(tt.skillName, tt.characterClass, tt.currentLevel)
category, difficulty, err := findBestCategoryForSkillImprovementOld(tt.skillName, tt.characterClass, tt.currentLevel)
if tt.expectError {
if err == nil {
@@ -570,7 +570,7 @@ func TestCalcSkillLernCostWithRewards(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Create cost result
cat, difficulty, _ := FindBestCategoryForSkillLearning(tt.skillName, tt.characterClass)
cat, difficulty, _ := FindBestCategoryForSkillLearningOld(tt.skillName, tt.characterClass)
costResult := &SkillCostResultNew{
CharacterClass: tt.characterClass,
SkillName: tt.skillName,
@@ -585,13 +585,13 @@ func TestCalcSkillLernCostWithRewards(t *testing.T) {
Category: costResult.Category,
Difficulty: costResult.Difficulty,
}
err := CalcSkillLernCost(baselineResult, stringPtr("default"))
err := CalcSkillLernCostOld(baselineResult, stringPtr("default"))
if err != nil {
t.Fatalf("Failed to calculate baseline costs: %v", err)
}
// Calculate costs with reward
err = CalcSkillLernCost(costResult, tt.reward)
err = CalcSkillLernCostOld(costResult, tt.reward)
if err != nil {
t.Fatalf("Failed to calculate costs: %v", err)
}
@@ -721,7 +721,7 @@ func TestCalcSkillImproveCostWithRewards(t *testing.T) {
// Lassen Sie Kategorie und Schwierigkeit leer, damit die Funktion die beste auswählt
}
err := CalcSkillImproveCost(costResult, tt.currentLevel, tt.reward)
err := CalcSkillImproveCostOld(costResult, tt.currentLevel, tt.reward)
if err != nil {
t.Fatalf("Failed to calculate improvement costs: %v", err)
}
@@ -817,7 +817,7 @@ func TestGetSpellInfo(t *testing.T) {
for _, tt := range tests {
t.Run(tt.spellName, func(t *testing.T) {
school, level, err := GetSpellInfo(tt.spellName)
school, level, err := GetSpellInfoNew(tt.spellName)
if tt.expectError {
if err == nil {
@@ -924,7 +924,7 @@ func TestCalcSpellLernCostWithRewards(t *testing.T) {
CharacterID: "test-character",
}
err := CalcSpellLernCost(costResult, tt.reward)
err := CalcSpellLernCostOld(costResult, tt.reward)
if err != nil {
t.Fatalf("Failed to calculate spell costs: %v", err)
}
@@ -961,7 +961,7 @@ func TestGetSpecialization(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := GetSpecialization(tt.characterID)
result := GetSpecializationOld(tt.characterID)
if result != tt.expectedSpec {
t.Errorf("Expected specialization %s, got %s", tt.expectedSpec, result)
}
@@ -1011,7 +1011,7 @@ func TestFindBestCategoryForSkillLearning(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
category, difficulty, err := FindBestCategoryForSkillLearning(tt.skillName, tt.characterClass)
category, difficulty, err := FindBestCategoryForSkillLearningOld(tt.skillName, tt.characterClass)
if tt.expectError {
if err == nil {
@@ -1153,7 +1153,7 @@ func TestGetLernCostNextLevel(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := GetLernCostNextLevel(tt.request, tt.costResult, tt.reward, tt.level, tt.characterTyp)
err := GetLernCostNextLevelOld(tt.request, tt.costResult, tt.reward, tt.level, tt.characterTyp)
if tt.expectError {
if err == nil {
backend/gsmaster/lerntabellen_test.go
+2 -2
View File
@@ -11,7 +11,7 @@ func TestLerntabellenForHexer(t *testing.T) {
// Testfall für Menschenkenntnis als Hexer - Lernkosten
t.Run("Lernkosten für Menschenkenntnis als Hexer", func(t *testing.T) {
// Verwende die exportierte Funktion CalculateDetailedSkillLearningCost
result, err := CalculateDetailedSkillLearningCost("Menschenkenntnis", "Hexer")
result, err := CalculateDetailedSkillLearningCostOld("Menschenkenntnis", "Hexer")
assert.NoError(t, err, "CalculateDetailedSkillLearningCost sollte keinen Fehler zurückgeben")
assert.NotNil(t, result, "Ergebnis sollte nicht nil sein")
@@ -34,7 +34,7 @@ func TestLerntabellenForHexer(t *testing.T) {
t.Run("Verbesserungskosten für Menschenkenntnis als Hexer", func(t *testing.T) {
// Verwende die exportierte Funktion CalculateDetailedSkillImprovementCost
currentLevel := 10
result, err := CalculateDetailedSkillImprovementCost("Menschenkenntnis", "Hexer", currentLevel)
result, err := CalculateDetailedSkillImprovementCostOld("Menschenkenntnis", "Hexer", currentLevel)
assert.NoError(t, err, "CalculateDetailedSkillImprovementCost sollte keinen Fehler zurückgeben")
assert.NotNil(t, result, "Ergebnis sollte nicht nil sein")
backend/gsmaster/levelup.go
+8 -8
View File
@@ -69,7 +69,7 @@ var AllowedGroups = map[CharClass]map[SkillGroup]bool}
var Config LevelConfig // holds all loaded data
func loadLevelingConfig(opts ...string) error {
func loadLevelingConfigOld(opts ...string) error {
// Adjust path as needed
filePath := "../testdata/leveldata.json"
if len(opts) > 0 {
@@ -89,10 +89,10 @@ func loadLevelingConfig(opts ...string) error {
return nil
}
// CalculateSpellLearnCost combines SpellLearnCost with SpellEPPerSchoolByClass
func CalculateSpellLearnCost(spell string, class string) (int, error) {
// CalculateSpellLearnCostOld combines SpellLearnCost with SpellEPPerSchoolByClass
func CalculateSpellLearnCostOld(spell string, class string) (int, error) {
if Config.AllowedSchools == nil {
loadLevelingConfig()
loadLevelingConfigOld()
}
var spl models.Spell
@@ -128,9 +128,9 @@ func CalculateSpellLearnCost(spell string, class string) (int, error) {
return totalEP, nil
}
// CalculateSkillLearnCost: erstmalige Kosten in EP
// CalculateSkillLearnCostOld: erstmalige Kosten in EP
// Then refer to Config in your calculations:
func CalculateSkillLearnCost(skill string, class string) (int, error) {
func CalculateSkillLearnCostOld(skill string, class string) (int, error) {
/*
if !Config.AllowedGroups[class][skill.Group] {
return 0, fmt.Errorf("die Klasse %s darf %s nicht lernen", class, skill.Group)
@@ -206,9 +206,9 @@ func CalculateImprovementCost(skill string, class string, currentSkillLevel int)
func CalculateLearnCost(skillType string, name string, class string) (int, error) {
if skillType == "skill" {
return CalculateSkillLearnCost(name, class)
return CalculateSkillLearnCostOld(name, class)
} else if skillType == "spell" {
return CalculateSpellLearnCost(name, class)
return CalculateSpellLearnCostOld(name, class)
}
return 0, errors.New("unknown skill type")
}
backend/gsmaster/levelup_test.go
+8 -8
View File
@@ -71,11 +71,11 @@ func TestLoadLevelingConfig(t *testing.T) {
}()
// Call init() which should panic
loadLevelingConfig("/invalid/path/leveldata.json")
loadLevelingConfigOld("/invalid/path/leveldata.json")
}
func TestInitValidConfig(t *testing.T) {
loadLevelingConfig()
loadLevelingConfigOld()
setupTestDB(false)
/*
// Save original Config
@@ -87,7 +87,7 @@ func TestInitValidConfig(t *testing.T) {
// Test with valid config file
os.Setenv("CONFIG_PATH", "/data/dev/bamort/config/leveldata.json")
loadLevelingConfig("../testdata/leveldata.json")
loadLevelingConfigOld("../testdata/leveldata.json")
// Verify Config was populated
assert.LessOrEqual(t, 1, len(Config.BaseLearnCost), "Expected BaseLearnCost to be populated")
@@ -96,7 +96,7 @@ func TestInitValidConfig(t *testing.T) {
}
func TestCalculateSpellLearnCost(t *testing.T) {
loadLevelingConfig()
loadLevelingConfigOld()
setupTestDB(false)
/*
// Save original Config
@@ -176,7 +176,7 @@ func TestCalculateSpellLearnCost(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := CalculateSpellLearnCost(tt.spell.Name, tt.class)
got, err := CalculateSpellLearnCostOld(tt.spell.Name, tt.class)
if tt.wantErr {
if err == nil {
assert.Error(t, err, "CalculateSpellLearnCost() expected error")
@@ -200,7 +200,7 @@ func TestCalculateSpellLearnCost(t *testing.T) {
}
func TestCalculateLearnCost(t *testing.T) {
loadLevelingConfig()
loadLevelingConfigOld()
setupTestDB(false)
// Save original Config
/*
@@ -294,7 +294,7 @@ func TestCalculateLearnCost(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := CalculateSkillLearnCost(tt.skill.Name, tt.class)
got, err := CalculateSkillLearnCostOld(tt.skill.Name, tt.class)
if tt.wantErr {
if err == nil {
assert.Error(t, err, "CalculateLearnCost() expected error")
@@ -318,7 +318,7 @@ func TestCalculateLearnCost(t *testing.T) {
}
func TestCalculateImprovementCost(t *testing.T) {
loadLevelingConfig()
loadLevelingConfigOld()
setupTestDB(false)
/*
// Save original Config
backend/integration_test/getspellinfo_test.go
+1 -1
View File
@@ -55,7 +55,7 @@ func TestGetSpellInfoIntegration(t *testing.T) {
for _, tt := range tests {
t.Run(tt.spellName, func(t *testing.T) {
school, level, err := gsmaster.GetSpellInfo(tt.spellName)
school, level, err := gsmaster.GetSpellInfoNew(tt.spellName)
if tt.expectError {
if err == nil {
backend/models/model_learning_costs.go
+2 -2
View File
@@ -288,8 +288,8 @@ func GetEPPerLEForClassAndSpellSchool(classCode string, schoolName string) (int,
return result.EPPerLE, nil
}
// GetSkillCategoryAndDifficulty findet die beste Kategorie für eine Fertigkeit basierend auf niedrigsten EP-Kosten
func GetSkillCategoryAndDifficulty(skillName string, classCode string) (*SkillLearningInfo, error) {
// GetSkillCategoryAndDifficultyNew findet die beste Kategorie für eine Fertigkeit basierend auf niedrigsten EP-Kosten
func GetSkillCategoryAndDifficultyNew(skillName string, classCode string) (*SkillLearningInfo, error) {
var results []SkillLearningInfo
err := database.DB.Raw(`
backend/models/model_skills.go
+1 -1
View File
@@ -40,7 +40,7 @@ func (object *SkZauber) TableName() string {
return dbPrefix + "_" + "spells"
}
func (object *SkFertigkeit) GetGsm() *Skill {
func (object *SkFertigkeit) GetSkillByName() *Skill {
var gsmsk Skill
gsmsk.First(object.Name)
if gsmsk.ID == 0 {