266 lines
7.3 KiB
Go
266 lines
7.3 KiB
Go
package pdfrender
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"bamort/database"
|
|
"bamort/models"
|
|
)
|
|
|
|
// MapCharacterToViewModel converts a domain Character to a CharacterSheetViewModel
|
|
func MapCharacterToViewModel(char *models.Char) (*CharacterSheetViewModel, error) {
|
|
vm := &CharacterSheetViewModel{
|
|
Skills: make([]SkillViewModel, 0),
|
|
Weapons: make([]WeaponViewModel, 0),
|
|
Spells: make([]SpellViewModel, 0),
|
|
MagicItems: make([]MagicItemViewModel, 0),
|
|
Equipment: make([]EquipmentViewModel, 0),
|
|
GameResults: make([]GameResultViewModel, 0),
|
|
}
|
|
|
|
// Map basic character info
|
|
vm.Character = CharacterInfo{
|
|
Name: char.Name,
|
|
Type: char.Typ,
|
|
Grade: char.Grad,
|
|
Age: char.Alter,
|
|
Height: char.Groesse,
|
|
Weight: char.Gewicht,
|
|
Gender: char.Gender,
|
|
Homeland: char.Herkunft,
|
|
Religion: char.Glaube,
|
|
Stand: char.SocialClass,
|
|
IconBase64: "", // Will be set later if image exists
|
|
Vermoegen: WealthInfo{
|
|
Goldstuecke: char.Vermoegen.Goldstuecke,
|
|
Silberstuecke: char.Vermoegen.Silberstuecke,
|
|
Kupferstuecke: char.Vermoegen.Kupferstuecke,
|
|
},
|
|
}
|
|
|
|
// Map attributes
|
|
vm.Attributes = mapAttributes(char)
|
|
|
|
// Map derived values
|
|
vm.DerivedValues = mapDerivedValues(char)
|
|
|
|
// Map skills
|
|
vm.Skills = mapSkills(char)
|
|
|
|
// Map weapons
|
|
vm.Weapons = mapWeapons(char)
|
|
|
|
// Map spells
|
|
vm.Spells = mapSpells(char)
|
|
|
|
// Map equipment
|
|
vm.Equipment = mapEquipment(char)
|
|
|
|
return vm, nil
|
|
}
|
|
|
|
// mapAttributes extracts attribute values from Eigenschaften slice
|
|
func mapAttributes(char *models.Char) AttributeValues {
|
|
attrs := AttributeValues{}
|
|
|
|
for _, e := range char.Eigenschaften {
|
|
switch e.Name {
|
|
case "St":
|
|
attrs.St = e.Value
|
|
case "Gs":
|
|
attrs.Gs = e.Value
|
|
case "Gw":
|
|
attrs.Gw = e.Value
|
|
case "Ko":
|
|
attrs.Ko = e.Value
|
|
case "In":
|
|
attrs.In = e.Value
|
|
case "Zt":
|
|
attrs.Zt = e.Value
|
|
case "Au":
|
|
attrs.Au = e.Value
|
|
case "pA":
|
|
attrs.PA = e.Value
|
|
case "Wk":
|
|
attrs.Wk = e.Value
|
|
}
|
|
}
|
|
|
|
attrs.B = char.B.Value
|
|
|
|
return attrs
|
|
}
|
|
|
|
// mapDerivedValues extracts derived values like LP, AP, etc.
|
|
func mapDerivedValues(char *models.Char) DerivedValueSet {
|
|
// Get attributes for bonus calculations
|
|
attrs := mapAttributes(char)
|
|
|
|
return DerivedValueSet{
|
|
LPMax: char.Lp.Max,
|
|
LPAktuell: char.Lp.Value,
|
|
APMax: char.Ap.Max,
|
|
APAktuell: char.Ap.Value,
|
|
AngriffBonus: calculateAttributeBonus(attrs.Gs),
|
|
SchadenBonus: (attrs.St / 20) + (attrs.Gs / 30) - 3,
|
|
}
|
|
}
|
|
|
|
// mapSkills converts character skills to SkillViewModel
|
|
func mapSkills(char *models.Char) []SkillViewModel {
|
|
skills := make([]SkillViewModel, 0, len(char.Fertigkeiten))
|
|
|
|
for _, skill := range char.Fertigkeiten {
|
|
skills = append(skills, SkillViewModel{
|
|
Name: skill.Name,
|
|
Category: skill.Category,
|
|
Value: skill.Fertigkeitswert,
|
|
Bonus: skill.Bonus,
|
|
PracticePoints: skill.Pp,
|
|
IsLearned: skill.Fertigkeitswert > 0,
|
|
})
|
|
}
|
|
|
|
return skills
|
|
}
|
|
|
|
// mapWeapons converts character weapon skills to WeaponViewModel
|
|
// EW = Waffenfertigkeit.Fertigkeitswert + Character.AngriffBonus + Weapon.Anb
|
|
func mapWeapons(char *models.Char) []WeaponViewModel {
|
|
weapons := make([]WeaponViewModel, 0, len(char.Waffenfertigkeiten))
|
|
|
|
// Calculate character's attack bonus once
|
|
attrs := mapAttributes(char)
|
|
angriffsBonus := calculateAttributeBonus(attrs.Gs)
|
|
// schadenBonus will be used later for damage calculation
|
|
// schadenBonus := (attrs.St / 20) + (attrs.Gs / 30) - 3
|
|
|
|
// Create a map of equipped weapons for quick lookup
|
|
equippedWeapons := make(map[string]*models.EqWaffe)
|
|
for i := range char.Waffen {
|
|
equippedWeapons[char.Waffen[i].Name] = &char.Waffen[i]
|
|
}
|
|
|
|
for _, weaponSkill := range char.Waffenfertigkeiten {
|
|
vm := WeaponViewModel{
|
|
Name: weaponSkill.Name,
|
|
Value: weaponSkill.Fertigkeitswert, // Base skill value
|
|
}
|
|
|
|
// If character has this weapon equipped, add weapon bonuses
|
|
if equippedWeapon, exists := equippedWeapons[weaponSkill.Name]; exists {
|
|
// EW = skill + character attack bonus + weapon attack bonus
|
|
vm.Value += angriffsBonus + equippedWeapon.Anb
|
|
|
|
// TODO: Calculate damage including weapon and character bonuses
|
|
// TODO: Add range information for ranged weapons
|
|
} else {
|
|
// No equipped weapon, just use skill + character bonus
|
|
vm.Value += angriffsBonus
|
|
}
|
|
|
|
weapons = append(weapons, vm)
|
|
}
|
|
|
|
return weapons
|
|
}
|
|
|
|
// mapSpells converts character spells to SpellViewModel
|
|
func mapSpells(char *models.Char) []SpellViewModel {
|
|
spells := make([]SpellViewModel, 0, len(char.Zauber))
|
|
|
|
for _, charSpell := range char.Zauber {
|
|
vm := SpellViewModel{
|
|
Name: charSpell.Name,
|
|
Bonus: charSpell.Bonus,
|
|
}
|
|
|
|
// Try to load spell details from gsmaster (only if database is available)
|
|
// In test environments without DB, we skip this enrichment
|
|
if database.DB != nil {
|
|
masterSpell := &models.Spell{}
|
|
err := masterSpell.First(charSpell.Name)
|
|
|
|
// If master spell found, add all details
|
|
if err == nil && masterSpell.ID > 0 {
|
|
vm.Stufe = masterSpell.Stufe
|
|
vm.AP = masterSpell.AP
|
|
vm.Art = masterSpell.Art
|
|
vm.Zauberdauer = masterSpell.Zauberdauer
|
|
vm.Reichweite = masterSpell.Reichweite
|
|
vm.Wirkungsziel = masterSpell.Wirkungsziel
|
|
vm.Wirkungsbereich = masterSpell.Wirkungsbereich
|
|
vm.Wirkungsdauer = masterSpell.Wirkungsdauer
|
|
vm.Ursprung = masterSpell.Ursprung
|
|
vm.Category = masterSpell.Category
|
|
vm.LearningCategory = masterSpell.LearningCategory
|
|
vm.Beschreibung = masterSpell.Beschreibung
|
|
|
|
// If description is empty, use source code and page number
|
|
if vm.Beschreibung == "" && masterSpell.SourceID > 0 && masterSpell.PageNumber > 0 {
|
|
source := &models.Source{}
|
|
if err := database.DB.First(source, masterSpell.SourceID).Error; err == nil {
|
|
vm.Beschreibung = source.Code + " S." + fmt.Sprintf("%d", masterSpell.PageNumber)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// If spell details not found or DB not available, just use name and bonus from character
|
|
|
|
spells = append(spells, vm)
|
|
}
|
|
|
|
return spells
|
|
}
|
|
|
|
// mapEquipment converts character equipment to EquipmentViewModel
|
|
func mapEquipment(char *models.Char) []EquipmentViewModel {
|
|
equipment := make([]EquipmentViewModel, 0, len(char.Ausruestung)+len(char.Behaeltnisse))
|
|
|
|
// Add regular equipment
|
|
for _, item := range char.Ausruestung {
|
|
equipment = append(equipment, EquipmentViewModel{
|
|
Name: item.Name,
|
|
Quantity: item.Anzahl,
|
|
Weight: item.Gewicht,
|
|
TotalWeight: item.Gewicht * float64(item.Anzahl),
|
|
Value: int(item.Wert),
|
|
Location: item.BeinhaltetIn,
|
|
Container: item.BeinhaltetIn,
|
|
IsWorn: item.BeinhaltetIn == "Am Körper",
|
|
IsContainer: false,
|
|
})
|
|
}
|
|
|
|
// Add containers
|
|
for _, container := range char.Behaeltnisse {
|
|
equipment = append(equipment, EquipmentViewModel{
|
|
Name: container.Name,
|
|
Quantity: 1,
|
|
Weight: container.Gewicht,
|
|
TotalWeight: container.Gewicht,
|
|
Value: int(container.Wert),
|
|
IsContainer: true,
|
|
})
|
|
}
|
|
|
|
return equipment
|
|
}
|
|
|
|
// calculateAttributeBonus calculates attribute bonus based on value
|
|
// Same logic as in character/derived_values_calculator.go
|
|
func calculateAttributeBonus(value int) int {
|
|
if value >= 1 && value <= 5 {
|
|
return -2
|
|
} else if value >= 6 && value <= 20 {
|
|
return -1
|
|
} else if value >= 21 && value <= 80 {
|
|
return 0
|
|
} else if value >= 81 && value <= 95 {
|
|
return 1
|
|
} else if value >= 96 && value <= 100 {
|
|
return 2
|
|
}
|
|
return 0
|
|
}
|