woe/world/character.go

package world

import "fmt"
import "os"
// import "strconv"
import "github.com/beoran/woe/monolog"
import "github.com/beoran/woe/sitef"

/* Characters may exist "outside" of any world, because, at login of a client,
 * the Character must be loaded or created before it enters a World. */

type Character struct {
    Being       
    Account * Account
}


func NewCharacterFromBeing(being Being, account * Account) (*Character) {
    return &Character{being, account}
}

func (me * Character) Init(account * Account, name string, 
              kin Entitylike, gender Entitylike, job Entitylike) (* Character) {
    me.Account = account
    me.Being.Init("character", name, account.Privilege, kin, gender, job)
    return me
}

func NewCharacter(account * Account, name string, 
              kin Entitylike, gender Entitylike, job Entitylike) (* Character) {
    me := &Character{};
    return me.Init(account, name, kin, gender, job)
}

// Save a character into a a sitef record.
func (me * Character) SaveSirec(rec * sitef.Record) (err error) {
    rec.Put("accountname", me.Account.Name)
    me.Being.SaveSitef(rec)
    return nil
}

// Load a character from a sitef record.
func (me * Character) LoadSirec(rec sitef.Record) (err error) {
    aname := rec.Get("accountname")
    account, err := DefaultWorld.LoadAccount(aname)
    if err != nil {
        return err
    } 
    me.Account = account
    me.Being.LoadSitef(rec)
    return nil
}


// Save a character as a sitef file.
func (me * Character) Save(dirname string) (err error) {
    path := SavePathFor(dirname, "character", me.ID)
    
    rec                := sitef.NewRecord()
    me.SaveSirec(rec)
    monolog.Debug("Saving Character record: %s %v", path, rec)
    return sitef.SaveRecord(path, *rec)
}


// Load a character from a sitef file. Does no account checking, but returns the account name.
func LoadCharacter(dirname string, id string) (character *Character, aname string, err error) {
    
    path := SavePathFor(dirname, "character", id)
    
    records, err := sitef.ParseFilename(path)
    if err != nil {
        return nil, "", err
    }
    
    if len(records) < 1 {
        return nil, "",  fmt.Errorf("No sitef record found for %s!", id)
    }
    
    record := records[0]
    monolog.Info("Loading Character record: %s %v", path, record)
    
    character               = new(Character)
    aname                   = record.Get("accountname")
    character.Being.LoadSitef(*record);
    
    return character, aname, nil
}

// Load a character WITH A GIVEN NAME from a sitef file. Does no account checking, but returns the account name.
func LoadCharacterByName(dirname string, name string) (character *Character, aname string, err error) {
    id := EntityNameToID("character", name)
    return LoadCharacter(dirname, id)
}


// Load an character from a sitef file for the given account.
func (account * Account) LoadCharacter(dirname string, id string) (character *Character, err error) {
    
    character, aname, err := LoadCharacter(dirname, id)
    if character == nil {
        return character, err
    }
    
    if aname != account.Name  {
        err := fmt.Errorf("Account doesn't match! %s %s", aname, account.Name)
        monolog.Error("%s", err.Error())
        return nil, err
    }
        
    character.Account = account    
    return character, nil
}



// Deletes the character itself from disk
func (me * Character) Delete(dirname string) bool {
    path := SavePathFor(dirname, "character", me.ID)
    
    if err := os.Remove(path) ; err != nil {
        monolog.Warning("Could not delete character: %v %s: %s", 
            me, path, err.Error())
        return false
    }
    
    me.Account = nil
    monolog.Info("Character deleted: %s", me.ID)    
    return true
} 

func (me * Character) AskLong() string {
    return me.Long + "\n" + me.ToStatus()
}