Added Vec2 and Temp File system

.gitignore

@@ -5,4 +5,4 @@ doorgo/
 *.json
 *.toml
 geode
-
+nodes/

db.go

@@ -35,10 +35,9 @@ type User struct {
 	Password            string   // bcrypt
 	Faction             *Faction `gorm:"-"` // Hot loaded in memory
 	FactionId           uint64
-	FactionSO           bool // Faction.Senior_Officer
-	FactionO            bool // Faction.Officer
-	X                   uint64
-	Y                   uint64
+	FactionSO           bool  // Faction.Senior_Officer
+	FactionO            bool  // Faction.Officer
+	Pos                 *Vec2 `gorm:"embedded"`
 	World               uint32
 	Health              uint32
 	MaxHealth           uint32

main.go

@@ -1,9 +1,12 @@
 package main
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"log"
+	"os"
+	"path/filepath"
 	"strings"
 	"time"
 
@@ -16,6 +19,116 @@ var (
 	u   *User
 )
 
+func SaveTemp() {
+	if d.Disconnected || udb == nil || u == nil {
+		return
+	}
+	stat, err := os.Stat("nodes")
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			err = os.Mkdir("nodes", 0775)
+			if err != nil {
+				fmt.Println("Err", err)
+				return
+			}
+		} else {
+			fmt.Println("Err", err)
+			return
+		}
+	} else if !stat.IsDir() {
+		err = os.Remove("nodes")
+		if err != nil {
+			fmt.Println("Err", err)
+			return
+		}
+		err = os.Mkdir("nodes", 0775)
+		if err != nil {
+			fmt.Println("Err", err)
+			return
+		}
+	}
+	tname := filepath.Join("nodes", fmt.Sprintf("%d.json", d.Config.Node))
+	payload, err := json.MarshalIndent(u, "", "  ")
+	if err != nil {
+		fmt.Println("Err", err)
+		return
+	}
+	err = os.WriteFile(tname, payload, 0666)
+	if err != nil {
+		fmt.Println("Err", err)
+	}
+}
+
+func DropTemp() {
+	if d.Disconnected {
+		return
+	}
+	tname := filepath.Join("nodes", fmt.Sprintf("%d.json", d.Config.Node))
+	err := os.Remove(tname)
+	if err != nil {
+		fmt.Println("Err", err)
+	}
+}
+
+func GetTempByNode(node int) *User {
+	tname := filepath.Join("nodes", fmt.Sprintf("%d.json", node))
+	payload, err := os.ReadFile(tname)
+	if err != nil {
+		if !errors.Is(err, os.ErrNotExist) {
+			fmt.Println("Err", err)
+		}
+		return nil
+	}
+	var u *User
+	err = json.Unmarshal(payload, &u)
+	if err != nil {
+		fmt.Println("Err", err)
+		return nil
+	}
+	return u
+}
+
+func UpdateTemp() {
+	t := GetTempByNode(d.Config.Node)
+	if t != nil {
+		u = t
+	}
+}
+
+func GetTempByName(name string) *User {
+	ls, err := os.ReadDir("nodes")
+	if err != nil {
+		if !errors.Is(err, os.ErrNotExist) {
+			fmt.Println("Err", err)
+		}
+		return nil
+	}
+	var u *User
+	for _, entry := range ls {
+		if entry.IsDir() {
+			continue
+		}
+		if strings.HasPrefix(entry.Name(), ".") || !strings.HasSuffix(entry.Name(), ".json") {
+			continue
+		}
+		fname := filepath.Join("nodes", entry.Name())
+		payload, err := os.ReadFile(fname)
+		if err != nil {
+			fmt.Println("Err", fname, err)
+			continue
+		}
+		err = json.Unmarshal(payload, &u)
+		if err != nil {
+			fmt.Println("Err", fname, err)
+			continue
+		}
+		if strings.EqualFold(u.Name, name) {
+			return u
+		}
+	}
+	return nil
+}
+
 func main() {
 	d.Init("Geode")
 	defer d.Close()
@@ -101,8 +214,8 @@ LOGIN:
 				u.Gold = 200
 			case 'r', 'R':
 				u.Class = C_RANGER
-				u.Health = 20
-				u.MaxHealth = 20
+				u.Health = 22
+				u.MaxHealth = 22
 				u.MaxMagic = 0
 				u.Magic = 0
 				u.Gold = 200
@@ -136,8 +249,11 @@ LOGIN:
 				d.WriteS(door.Reset + door.CRNL)
 				break LOGIN
 			}
+
 		}
 	}
+	SaveTemp()
+	defer DropTemp()
 	d.WriteS(door.ColorTextS("BRI CYA ON BLA") + "Welcome " + door.ColorTextS("BRI WHI ON BLA") + u.Name + door.ColorTextS("BRI CYA ON BLA") + " the ")
 	d.WriteS(door.ColorTextS(u.Class.ColorText()) + u.Class.Name())
 	d.WriteS(door.Reset + door.CRNL)
@@ -165,9 +281,9 @@ func renderStatusBar(msg ...string) {
 		pos_txt += msg[0] + " - "
 	}
 	if u.MaxMagic != 0 {
-		pos_txt += fmt.Sprintf("%-3d%% (%d, %d) %-3d%%", int((float64(u.Health)/float64(u.MaxHealth))*100.0), u.X, u.Y, int((float64(u.Magic)/float64(u.MaxMagic))*100.0))
+		pos_txt += fmt.Sprintf("%-3d%% %s %-3d%%", int((float64(u.Health)/float64(u.MaxHealth))*100.0), u.Pos.String(), int((float64(u.Magic)/float64(u.MaxMagic))*100.0))
 	} else {
-		pos_txt += fmt.Sprintf("%-3d%% (%d, %d)", int((float64(u.Health)/float64(u.MaxHealth))*100.0), u.X, u.Y)
+		pos_txt += fmt.Sprintf("%-3d%% %s", int((float64(u.Health)/float64(u.MaxHealth))*100.0), u.Pos.String())
 	}
 	if len(msg) >= 2 {
 		pos_txt += " - " + msg[1]

vec2.go

@@ -0,0 +1,351 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type Vec2 struct {
+	X int64
+	Y int64
+}
+
+func NewVec2(axis ...int64) *Vec2 {
+	if len(axis) == 0 {
+		return &Vec2{X: 0, Y: 0}
+	} else if len(axis) == 1 {
+		return &Vec2{X: axis[0], Y: axis[0]}
+	} else {
+		return &Vec2{X: axis[0], Y: axis[1]}
+	}
+}
+
+func (v *Vec2) Clone() *Vec2 {
+	if v == nil {
+		return nil
+	}
+	return &Vec2{X: v.X, Y: v.Y}
+}
+
+func (v *Vec2) Add(axis ...int64) *Vec2 {
+	if v == nil {
+		return nil
+	}
+	if len(axis) == 0 {
+		return v
+	} else if len(axis) == 1 {
+		v.X += axis[0]
+		v.Y += axis[0]
+		return v
+	} else {
+		v.X += axis[0]
+		v.Y += axis[1]
+		return v
+	}
+}
+
+func (v *Vec2) Sub(axis ...int64) *Vec2 {
+	if v == nil {
+		return nil
+	}
+	if len(axis) == 0 {
+		return v
+	} else if len(axis) == 1 {
+		v.X -= axis[0]
+		v.Y -= axis[0]
+		return v
+	} else {
+		v.X -= axis[0]
+		v.Y -= axis[1]
+		return v
+	}
+}
+
+func (v *Vec2) Mul(axis ...int64) *Vec2 {
+	if v == nil {
+		return nil
+	}
+	if len(axis) == 0 {
+		return v
+	} else if len(axis) == 1 {
+		v.X *= axis[0]
+		v.Y *= axis[0]
+		return v
+	} else {
+		v.X *= axis[0]
+		v.Y *= axis[1]
+		return v
+	}
+}
+
+func (v *Vec2) Div(axis ...int64) *Vec2 {
+	if v == nil {
+		return nil
+	}
+	if len(axis) == 0 {
+		return v
+	} else if len(axis) == 1 {
+		v.X /= axis[0]
+		v.Y /= axis[0]
+		return v
+	} else {
+		v.X /= axis[0]
+		v.Y /= axis[1]
+		return v
+	}
+}
+
+func (v *Vec2) Rem(axis ...int64) *Vec2 {
+	if v == nil {
+		return nil
+	}
+	if len(axis) == 0 {
+		return v
+	} else if len(axis) == 1 {
+		v.X %= axis[0]
+		v.Y %= axis[0]
+		return v
+	} else {
+		v.X %= axis[0]
+		v.Y %= axis[1]
+		return v
+	}
+}
+
+func (v *Vec2) Set(axis ...int64) *Vec2 {
+	if v == nil {
+		return nil
+	}
+	if len(axis) == 0 {
+		v.X = 0
+		v.Y = 0
+		return v
+	} else if len(axis) == 1 {
+		v.X = axis[0]
+		v.Y = axis[0]
+		return v
+	} else {
+		v.X = axis[0]
+		v.Y = axis[1]
+		return v
+	}
+}
+
+func (v *Vec2) AddBy(o *Vec2) *Vec2 {
+	if v == nil {
+		return nil
+	}
+	if o == nil {
+		return v
+	}
+	v.X += o.X
+	v.Y += o.Y
+	return v
+}
+
+func (v *Vec2) SubBy(o *Vec2) *Vec2 {
+	if v == nil {
+		return nil
+	}
+	if o == nil {
+		return v
+	}
+	v.X -= o.X
+	v.Y -= o.Y
+	return v
+}
+
+func (v *Vec2) MulBy(o *Vec2) *Vec2 {
+	if v == nil {
+		return nil
+	}
+	if o == nil {
+		return v
+	}
+	v.X *= o.X
+	v.Y *= o.Y
+	return v
+}
+
+func (v *Vec2) DivBy(o *Vec2) *Vec2 {
+	if v == nil {
+		return nil
+	}
+	if o == nil {
+		return v
+	}
+	v.X /= o.X
+	v.Y /= o.Y
+	return v
+}
+
+func (v *Vec2) RemBy(o *Vec2) *Vec2 {
+	if v == nil {
+		return nil
+	}
+	if o == nil {
+		return v
+	}
+	v.X -= o.X
+	v.Y -= o.Y
+	return v
+}
+
+func (v *Vec2) SetTo(o *Vec2) *Vec2 {
+	if v == nil {
+		return nil
+	}
+	if o == nil {
+		return v
+	}
+	v.X = o.X
+	v.Y = o.Y
+	return v
+}
+
+func (v *Vec2) Abs() *Vec2 {
+	if v == nil {
+		return nil
+	}
+	v.X = I64Abs(v.X)
+	v.Y = I64Abs(v.Y)
+	return v
+}
+
+func I64Abs(i int64) int64 {
+	if i < 0 {
+		return -i
+	}
+	return i
+}
+
+func (v *Vec2) Negate() *Vec2 {
+	if v == nil {
+		return nil
+	}
+	v.X = -v.X
+	v.Y = -v.Y
+	return v
+}
+
+func (v *Vec2) Less(axis ...int64) bool {
+	if v == nil || len(axis) == 0 {
+		return false
+	}
+	if len(axis) == 1 {
+		return v.X < axis[0] && v.Y < axis[0]
+	} else {
+		return v.X < axis[0] && v.Y < axis[1]
+	}
+}
+
+func (v *Vec2) Great(axis ...int64) bool {
+	if v == nil || len(axis) == 0 {
+		return false
+	}
+	if len(axis) == 1 {
+		return v.X > axis[0] && v.Y > axis[0]
+	} else {
+		return v.X > axis[0] && v.Y > axis[1]
+	}
+}
+
+func (v *Vec2) Eq(axis ...int64) bool {
+	if v == nil {
+		return false
+	}
+	if len(axis) == 0 {
+		return v.X == 0 && v.Y == 0
+	} else if len(axis) == 1 {
+		return v.X == axis[0] && v.Y == axis[0]
+	} else {
+		return v.X == axis[0] && v.Y == axis[1]
+	}
+}
+
+func (v *Vec2) LessThan(o *Vec2) bool {
+	if v == nil || o == nil {
+		return false
+	}
+	return v.X < o.X && v.Y < o.Y
+}
+
+func (v *Vec2) GreatThan(o *Vec2) bool {
+	if v == nil || o == nil {
+		return false
+	}
+	return v.X > o.X && v.Y > o.Y
+}
+
+func (v *Vec2) EqTo(o *Vec2) bool {
+	if v == nil || o == nil {
+		return false
+	}
+	return v.X == o.X && v.Y == o.Y
+}
+
+func (v *Vec2) Dist(axis ...int64) int64 {
+	if v == nil {
+		return -1
+	}
+	if len(axis) == 0 {
+		return I64Abs(v.X) + I64Abs(v.Y)
+	} else if len(axis) == 1 {
+		a := I64Abs(v.X) + I64Abs(v.Y)
+		b := I64Abs(axis[0]) + I64Abs(axis[0])
+		return I64Abs(a - b)
+	} else {
+		a := I64Abs(v.X) + I64Abs(v.Y)
+		b := I64Abs(axis[0]) + I64Abs(axis[1])
+		return I64Abs(a - b)
+	}
+}
+
+func (v *Vec2) DistTo(o *Vec2) int64 {
+	if v == nil || o == nil {
+		return -1
+	}
+	a := I64Abs(v.X) + I64Abs(v.Y)
+	b := I64Abs(o.X) + I64Abs(o.Y)
+	return I64Abs(a - b)
+}
+
+func (v *Vec2) String() string {
+	return fmt.Sprintf("(%d, %d)", v.X, v.Y)
+}
+
+var (
+	ErrVec2Format    error = fmt.Errorf("missing parentheses and/or comma")
+	ErrTooManyCommas error = fmt.Errorf("missing or too many commas")
+	ErrInvalidAxisX  error = fmt.Errorf("missing or invalid X-axis")
+	ErrInvalidAxisY  error = fmt.Errorf("missing or invalid Y-axis")
+)
+
+func StrToVec2(s string) (*Vec2, error) {
+	if !strings.Contains(s, "(") || !strings.Contains(s, ")") || !strings.Contains(s, ",") {
+		return nil, ErrVec2Format
+	}
+	work := strings.ReplaceAll(s, "(", "")
+	work = strings.ReplaceAll(work, ")", "")
+	commas := strings.Count(work, ",")
+	if commas != 1 {
+		return nil, ErrTooManyCommas
+	}
+	parts := strings.Split(work, ",")
+	for idx, part := range parts {
+		parts[idx] = strings.TrimSpace(part)
+	}
+	if len(parts) != 2 {
+		return nil, ErrTooManyCommas
+	}
+	x, err := strconv.ParseInt(parts[0], 10, 64)
+	if err != nil {
+		return nil, ErrInvalidAxisX
+	}
+	y, err := strconv.ParseInt(parts[1], 10, 64)
+	if err != nil {
+		return nil, ErrInvalidAxisY
+	}
+	return &Vec2{X: x, Y: y}, nil
+}