294 lines
7.8 KiB
Go
294 lines
7.8 KiB
Go
package model
|
|
|
|
import (
|
|
"encoding/xml"
|
|
"errors"
|
|
"fmt"
|
|
"legendsbrowser/util"
|
|
"os"
|
|
"reflect"
|
|
"strings"
|
|
)
|
|
|
|
type World struct {
|
|
XMLName xml.Name `xml:"df_world"`
|
|
Name string `xml:"name"`
|
|
AltName string `xml:"altname"`
|
|
|
|
OtherElements
|
|
|
|
RegionMap map[int]*Region `xml:"regions>region"`
|
|
UndergroundRegionMap map[int]*UndergroundRegion `xml:"underground_regions>underground_region"`
|
|
LandmassMap map[int]*Landmass `xml:"landmasses>landmass"`
|
|
SiteMap map[int]*Site `xml:"sites>site"`
|
|
WorldConstructionMap map[int]*WorldConstruction `xml:"world_constructions>world_construction"`
|
|
ArtifactMap map[int]*Artifact `xml:"artifacts>artifact"`
|
|
HistoricalFigureMap map[int]*HistoricalFigure `xml:"historical_figures>historical_figure"`
|
|
HistoricalEventMap map[int]*HistoricalEvent `xml:"historical_events>historical_event"`
|
|
HistoricalEventCollectionMap map[int]*HistoricalEventCollection `xml:"historical_event_collections>historical_event_collection"`
|
|
HistoricalEraMap map[int]*HistoricalEra `xml:"historical_eras>historical_era"`
|
|
EntityMap map[int]*Entity `xml:"entities>entity"`
|
|
DanceFormMap map[int]*DanceForm `xml:"dance_forms>dance_form"`
|
|
MusicalFormMap map[int]*MusicalForm `xml:"musical_forms>musical_form"`
|
|
PoeticFormMap map[int]*PoeticForm `xml:"poetic_forms>poetic_form"`
|
|
WrittenContentMap map[int]*WrittenContent `xml:"written_contents>written_content"`
|
|
}
|
|
|
|
func (w *World) Load(file string) {
|
|
xmlFile, err := os.Open(file)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
fmt.Println("Successfully Opened users.xml")
|
|
defer xmlFile.Close()
|
|
|
|
converter := util.NewConvertReader(xmlFile)
|
|
|
|
// byteValue, _ := io.ReadAll(converter)
|
|
// fmt.Println(len(byteValue))
|
|
|
|
fillTypes(reflect.TypeOf(w))
|
|
fmt.Println(types["Region"])
|
|
|
|
d := xml.NewDecoder(converter)
|
|
parseObject(d, nil, reflect.ValueOf(w))
|
|
|
|
// err = xml.Unmarshal(byteValue, w)
|
|
// if err != nil {
|
|
// fmt.Println(err)
|
|
// }
|
|
fmt.Println("World loaded")
|
|
}
|
|
|
|
var types = make(map[string]map[string]reflect.StructField)
|
|
|
|
func fillTypes(t reflect.Type) {
|
|
if t.Kind() == reflect.Pointer {
|
|
t = t.Elem()
|
|
}
|
|
if t.Kind() != reflect.Struct {
|
|
return
|
|
}
|
|
fmt.Println(t.Name())
|
|
|
|
if _, ok := types[t.Name()]; ok {
|
|
return
|
|
}
|
|
|
|
info := make(map[string]reflect.StructField)
|
|
DeepFields(t, &info, make([]int, 0))
|
|
|
|
types[t.Name()] = info
|
|
}
|
|
|
|
func DeepFields(t reflect.Type, info *map[string]reflect.StructField, index []int) {
|
|
for i := 0; i < t.NumField(); i++ {
|
|
f := t.Field(i)
|
|
f.Index = append(index, f.Index[0])
|
|
if xml, ok := f.Tag.Lookup("xml"); ok {
|
|
if p := strings.Index(xml, ">"); p >= 0 {
|
|
(*info)[xml[0:p]] = f
|
|
} else {
|
|
for _, s := range strings.Split(xml, "|") {
|
|
(*info)[s] = f
|
|
}
|
|
}
|
|
if f.Type.Kind() == reflect.Map || f.Type.Kind() == reflect.Slice {
|
|
fillTypes(f.Type.Elem())
|
|
}
|
|
fmt.Println(i, f)
|
|
}
|
|
if f.Type.Kind() == reflect.Struct && f.Anonymous {
|
|
DeepFields(f.Type, info, f.Index)
|
|
}
|
|
}
|
|
}
|
|
|
|
func parseObject(d *xml.Decoder, start *xml.StartElement, val reflect.Value) error {
|
|
if start == nil {
|
|
for {
|
|
tok, err := d.Token()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if t, ok := tok.(xml.StartElement); ok {
|
|
start = &t
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if val.Kind() == reflect.Pointer {
|
|
val = val.Elem()
|
|
}
|
|
|
|
typ, ok := types[val.Type().Name()]
|
|
if !ok {
|
|
d.Skip()
|
|
return nil
|
|
}
|
|
|
|
Loop:
|
|
for {
|
|
tok, err := d.Token()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch t := tok.(type) {
|
|
case xml.StartElement:
|
|
if ty, ok := typ[t.Name.Local]; ok {
|
|
if ty.Type.Kind() == reflect.Map {
|
|
fmt.Println(" ", t.Name.Local, val.Type().Name(), ty)
|
|
f := val.Field(ty.Index[0])
|
|
if f.IsNil() {
|
|
f.Set(reflect.MakeMapWithSize(ty.Type, 0))
|
|
}
|
|
parseMap(d, ty, f)
|
|
}
|
|
} else {
|
|
d.Skip()
|
|
}
|
|
// parseObject(d, &t, val)
|
|
case xml.EndElement:
|
|
break Loop
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func parseMap(d *xml.Decoder, field reflect.StructField, dest reflect.Value) error {
|
|
x, ok := field.Tag.Lookup("xml")
|
|
if !ok {
|
|
return errors.New("no xml tag")
|
|
}
|
|
elementName := strings.Split(x, ">")[1]
|
|
|
|
var lastStart *xml.StartElement
|
|
var id int
|
|
|
|
Loop:
|
|
for {
|
|
tok, err := d.Token()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch t := tok.(type) {
|
|
case xml.StartElement:
|
|
if t.Name.Local == elementName {
|
|
lastStart = &t
|
|
id = -1
|
|
} else if t.Name.Local == "id" {
|
|
if id != -1 {
|
|
return errors.New("ID at invalid place")
|
|
}
|
|
d.DecodeElement(&id, &t)
|
|
|
|
obj := dest.MapIndex(reflect.ValueOf(id))
|
|
if !obj.IsValid() {
|
|
obj = reflect.New(field.Type.Elem().Elem())
|
|
dest.SetMapIndex(reflect.ValueOf(id), obj)
|
|
obj.Elem().FieldByIndex(types[obj.Type().Elem().Name()]["id"].Index).SetInt(int64(id))
|
|
}
|
|
d.DecodeElement(obj.Interface(), lastStart)
|
|
} else {
|
|
fmt.Println("SKIP", elementName, t.Name.Local)
|
|
d.Skip()
|
|
}
|
|
case xml.EndElement:
|
|
if t.Name.Local != elementName {
|
|
break Loop
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (w *World) Process() {
|
|
// w.RegionMap = make(map[int]*Region)
|
|
// mapObjects(&w.Regions, &w.RegionMap)
|
|
|
|
// w.UndergroundRegionMap = make(map[int]*UndergroundRegion)
|
|
// mapObjects(&w.UndergroundRegions, &w.UndergroundRegionMap)
|
|
|
|
// w.LandmassMap = make(map[int]*Landmass)
|
|
// mapObjects(&w.Landmasses, &w.LandmassMap)
|
|
|
|
// w.SiteMap = make(map[int]*Site)
|
|
// mapObjects(&w.Sites, &w.SiteMap)
|
|
|
|
// w.WorldConstructionMap = make(map[int]*WorldConstruction)
|
|
// mapObjects(&w.WorldConstructions, &w.WorldConstructionMap)
|
|
|
|
// w.ArtifactMap = make(map[int]*Artifact)
|
|
// mapObjects(&w.Artifacts, &w.ArtifactMap)
|
|
|
|
// w.HistoricalFigureMap = make(map[int]*HistoricalFigure)
|
|
// mapObjects(&w.HistoricalFigures, &w.HistoricalFigureMap)
|
|
|
|
// w.HistoricalEventMap = make(map[int]*HistoricalEvent)
|
|
// mapObjects(&w.HistoricalEvents, &w.HistoricalEventMap)
|
|
|
|
// w.HistoricalEventCollectionMap = make(map[int]*HistoricalEventCollection)
|
|
// mapObjects(&w.HistoricalEventCollections, &w.HistoricalEventCollectionMap)
|
|
|
|
// w.EntityMap = make(map[int]*Entity)
|
|
// mapObjects(&w.Entities, &w.EntityMap)
|
|
|
|
w.processEvents()
|
|
}
|
|
|
|
func (w *World) processEvents() {
|
|
legendFields := make(map[string][]int)
|
|
|
|
t := reflect.TypeOf(HistoricalEvent{})
|
|
for i := 0; i < t.NumField(); i++ {
|
|
f := t.Field(i)
|
|
l, ok := f.Tag.Lookup("legend")
|
|
if ok {
|
|
legendFields[l] = append(legendFields[l], i)
|
|
}
|
|
}
|
|
|
|
// for eventIndex := 0; eventIndex < len(w.HistoricalEvents); eventIndex++ {
|
|
// e := w.HistoricalEvents[eventIndex]
|
|
// v := reflect.ValueOf(*e)
|
|
// processEvent(e, &v, legendFields["entity"], &w.EntityMap)
|
|
// processEvent(e, &v, legendFields["site"], &w.SiteMap)
|
|
// processEvent(e, &v, legendFields["hf"], &w.HistoricalFigureMap)
|
|
// processEvent(e, &v, legendFields["artifact"], &w.ArtifactMap)
|
|
// // processEvent(e, &v, legendFields["wc"], &w.WorldConstructionMap)
|
|
// // processEvent(e, &v, legendFields["structure"], &w.St)
|
|
// }
|
|
}
|
|
|
|
func processEvent[T HasEvents](event *HistoricalEvent, v *reflect.Value, fields []int, objectMap *map[int]T) {
|
|
for _, i := range fields {
|
|
val := v.Field(i)
|
|
if !val.IsZero() {
|
|
switch val.Elem().Kind() {
|
|
case reflect.Slice:
|
|
ids := val.Interface().(*[]int)
|
|
for _, id := range *ids {
|
|
if x, ok := (*objectMap)[id]; ok {
|
|
x.SetEvents(append(x.GetEvents(), event))
|
|
}
|
|
}
|
|
case reflect.Int:
|
|
id := int(val.Elem().Int())
|
|
if x, ok := (*objectMap)[id]; ok {
|
|
x.SetEvents(append(x.GetEvents(), event))
|
|
}
|
|
default:
|
|
fmt.Println("unknown", val.Elem().Kind())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func mapObjects[T Identifiable](objects *[]T, objectMap *map[int]T) {
|
|
for i, obj := range *objects {
|
|
(*objectMap)[obj.Id()] = (*objects)[i]
|
|
}
|
|
}
|