major refactoring: db.Player is now core.Player

- misc. cleanup
- core/db/players.go: works with core.Player types, will also grab inventory table

core/db/account.go

@@ -0,0 +1,66 @@
+package db
+
+import (
+	"fmt"
+
+	"golang.org/x/crypto/bcrypt"
+
+	"github.com/CPunch/gopenfusion/core/protocol"
+	"github.com/blockloop/scan"
+)
+
+type Account struct {
+	AccountID    int
+	Login        string
+	Password     string
+	Selected     int
+	AccountLevel int
+	Created      int
+	LastLogin    int
+	BannedUntil  int
+	BannedSince  int
+	BanReason    string
+}
+
+func (db *DBHandler) NewAccount(Login, Password string) (*Account, error) {
+	hash, err := bcrypt.GenerateFromPassword([]byte(Password), 12)
+	if err != nil {
+		return nil, err
+	}
+
+	row, err := db.Query("INSERT INTO Accounts (Login, Password, AccountLevel) VALUES(?, ?, ?) RETURNING *", Login, hash, protocol.CN_ACCOUNT_LEVEL__USER)
+	if err != nil {
+		return nil, err
+	}
+
+	var account Account
+	if err := scan.Row(&account, row); err != nil {
+		return nil, err
+	}
+
+	return &account, nil
+}
+
+var (
+	LoginErrorInvalidID       = fmt.Errorf("Invalid Login ID!")
+	LoginErrorInvalidPassword = fmt.Errorf("Invalid ID && Password combo!")
+)
+
+func (db *DBHandler) TryLogin(Login, Password string) (*Account, error) {
+	row, err := db.Query("SELECT * FROM Accounts WHERE Login=?", Login)
+	if err != nil {
+		return nil, err
+	}
+
+	var account Account
+	if err := scan.Row(&account, row); err != nil {
+		return nil, LoginErrorInvalidID
+	}
+
+	if bcrypt.CompareHashAndPassword([]byte(account.Password), []byte(Password)) != nil {
+		return nil, LoginErrorInvalidPassword
+	}
+
+	// else, login was a success
+	return &account, nil
+}

core/db/inventory.go

@@ -0,0 +1,62 @@
+package db
+
+import (
+	"database/sql"
+
+	"github.com/CPunch/gopenfusion/core/protocol"
+)
+
+type Inventory struct {
+	PlayerID  int
+	Slot      int
+	ID        int
+	Type      int
+	Opt       int
+	TimeLimit int
+}
+
+// start && end are both inclusive
+func (db *DBHandler) GetPlayerInventorySlots(PlayerID int, start int, end int) ([]protocol.SItemBase, error) {
+	rows, err := db.Query("SELECT Slot, Type, ID, Opt, TimeLimit FROM Inventory WHERE Slot BETWEEN ? AND ? AND PlayerID = ?", start, end, PlayerID)
+	if err != nil {
+		return nil, err
+	}
+
+	items := make([]protocol.SItemBase, end-start)
+	for rows.Next() {
+		var slot int
+		item := protocol.SItemBase{}
+
+		if err := rows.Scan(
+			&slot, &item.IType, &item.IID, &item.IOpt, &item.ITimeLimit); err != nil {
+			return nil, err
+		}
+
+		items[slot-start] = item
+	}
+
+	return items, nil
+}
+
+// start is inclusive
+func (db *DBHandler) SetPlayerInventorySlots(PlayerID int, start int, items []protocol.SItemBase) error {
+	return db.Transaction(func(tx *sql.Tx) error {
+		// delete inventory slots
+		_, err := db.Exec("DELETE FROM Inventory WHERE Slot BETWEEN ? AND ? AND PlayerID = ?", start, start+len(items)-1, PlayerID)
+		if err != nil {
+			return err
+		}
+
+		// insert inventory
+		for i, item := range items {
+			if item.IID != 0 {
+				_, err := db.Exec("INSERT INTO Inventory (PlayerID, Slot, ID, Type, Opt, TimeLimit) VALUES (?, ?, ?, ?, ?, ?)", PlayerID, start+i, item.IID, item.IType, item.IOpt, item.ITimeLimit)
+				if err != nil {
+					return err
+				}
+			}
+		}
+
+		return nil
+	})
+}

core/db/migrations/new.sql

@@ -0,0 +1,164 @@
+-- this file has been lifted from https://github.com/OpenFusionProject/OpenFusion/blob/master/sql/tables.sql
+-- all credit to original contributors!
+
+CREATE TABLE IF NOT EXISTS Accounts (
+    AccountID    INTEGER NOT NULL,
+    Login        TEXT    NOT NULL UNIQUE COLLATE NOCASE,
+    Password     TEXT    NOT NULL,
+    Selected     INTEGER  DEFAULT 1 NOT NULL,
+    AccountLevel INTEGER NOT NULL,
+    Created      INTEGER DEFAULT (strftime('%s', 'now')) NOT NULL,
+    LastLogin    INTEGER DEFAULT (strftime('%s', 'now')) NOT NULL,
+    BannedUntil  INTEGER DEFAULT 0 NOT NULL,
+    BannedSince  INTEGER DEFAULT 0 NOT NULL,
+    BanReason    TEXT    DEFAULT '' NOT NULL,
+    PRIMARY KEY(AccountID AUTOINCREMENT)
+);
+
+CREATE TABLE IF NOT EXISTS Players (
+    PlayerID           INTEGER NOT NULL,
+    AccountID          INTEGER NOT NULL,
+    FirstName          TEXT NOT NULL COLLATE NOCASE,
+    LastName           TEXT NOT NULL COLLATE NOCASE,
+    NameCheck          INTEGER NOT NULL,
+    Slot               INTEGER NOT NULL,
+    Created            INTEGER DEFAULT (strftime('%s', 'now')) NOT NULL,
+    LastLogin          INTEGER DEFAULT (strftime('%s', 'now')) NOT NULL,
+    Level              INTEGER DEFAULT 1 NOT NULL,
+    Nano1              INTEGER DEFAULT 0 NOT NULL,
+    Nano2              INTEGER DEFAULT 0 NOT NULL,
+    Nano3              INTEGER DEFAULT 0 NOT NULL,
+    AppearanceFlag     INTEGER DEFAULT 0 NOT NULL,
+    TutorialFlag       INTEGER DEFAULT 0 NOT NULL,
+    PayZoneFlag        INTEGER DEFAULT 0 NOT NULL,
+    XCoordinate        INTEGER NOT NULL,
+    YCoordinate        INTEGER NOT NULL,
+    ZCoordinate        INTEGER NOT NULL,
+    Angle              INTEGER NOT NULL,
+    HP                 INTEGER NOT NULL,
+    FusionMatter       INTEGER DEFAULT 0 NOT NULL,
+    Taros              INTEGER DEFAULT 0 NOT NULL,
+    BatteryW           INTEGER DEFAULT 0 NOT NULL,
+    BatteryN           INTEGER DEFAULT 0 NOT NULL,
+    Mentor             INTEGER DEFAULT 5 NOT NULL,
+    CurrentMissionID   INTEGER DEFAULT 0 NOT NULL,
+    WarpLocationFlag   INTEGER DEFAULT 0 NOT NULL,
+    SkywayLocationFlag BLOB NOT NULL,
+    FirstUseFlag       BLOB NOT NULL,
+    Quests             BLOB NOT NULL,
+    PRIMARY KEY(PlayerID AUTOINCREMENT),
+    FOREIGN KEY(AccountID) REFERENCES Accounts(AccountID) ON DELETE CASCADE,
+    UNIQUE (AccountID, Slot),
+    UNIQUE (FirstName, LastName)
+);
+
+CREATE TABLE IF NOT EXISTS Appearances (
+    PlayerID    INTEGER UNIQUE NOT NULL,
+    Body        INTEGER DEFAULT 0 NOT NULL,
+    EyeColor    INTEGER DEFAULT 1 NOT NULL,
+    FaceStyle   INTEGER DEFAULT 1 NOT NULL,
+    Gender      INTEGER DEFAULT 1 NOT NULL,
+    HairColor   INTEGER DEFAULT 1 NOT NULL,
+    HairStyle   INTEGER DEFAULT 1 NOT NULL,
+    Height      INTEGER DEFAULT 0 NOT NULL,
+    SkinColor   INTEGER DEFAULT 1 NOT NULL,
+    FOREIGN KEY(PlayerID) REFERENCES Players(PlayerID) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS Inventory (
+    PlayerID    INTEGER NOT NULL,
+    Slot        INTEGER NOT NULL,
+    ID          INTEGER NOT NULL,
+    Type        INTEGER NOT NULL,
+    Opt         INTEGER NOT NULL,
+    TimeLimit   INTEGER DEFAULT 0 NOT NULL,
+    FOREIGN KEY(PlayerID) REFERENCES Players(PlayerID) ON DELETE CASCADE,
+    UNIQUE (PlayerID, Slot)
+);
+
+CREATE TABLE IF NOT EXISTS QuestItems (
+    PlayerID    INTEGER NOT NULL,
+    Slot        INTEGER NOT NULL,
+    ID          INTEGER NOT NULL,
+    Opt         INTEGER NOT NULL,
+    FOREIGN KEY(PlayerID) REFERENCES Players(PlayerID) ON DELETE CASCADE,
+    UNIQUE (PlayerID, Slot)
+);
+
+CREATE TABLE IF NOT EXISTS Nanos (
+    PlayerID    INTEGER NOT NULL,
+    ID          INTEGER NOT NULL,
+    Skill       INTEGER NOT NULL,
+    Stamina     INTEGER DEFAULT 150 NOT NULL,
+    FOREIGN KEY(PlayerID) REFERENCES Players(PlayerID) ON DELETE CASCADE,
+    UNIQUE (PlayerID, ID)
+);
+
+CREATE TABLE IF NOT EXISTS RunningQuests (
+    PlayerID              INTEGER NOT NULL,
+    TaskID                INTEGER NOT NULL,
+    RemainingNPCCount1    INTEGER NOT NULL,
+    RemainingNPCCount2    INTEGER NOT NULL,
+    RemainingNPCCount3    INTEGER NOT NULL,
+    FOREIGN KEY(PlayerID) REFERENCES Players(PlayerID) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS Buddyships (
+    PlayerAID    INTEGER NOT NULL,
+    PlayerBID    INTEGER NOT NULL,
+    FOREIGN KEY(PlayerAID) REFERENCES Players(PlayerID) ON DELETE CASCADE,
+    FOREIGN KEY(PlayerBID) REFERENCES Players(PlayerID) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS Blocks (
+    PlayerID           INTEGER NOT NULL,
+    BlockedPlayerID    INTEGER NOT NULL,
+    FOREIGN KEY(PlayerID)        REFERENCES Players(PlayerID) ON DELETE CASCADE,
+    FOREIGN KEY(BlockedPlayerID) REFERENCES Players(PlayerID) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS EmailData (
+    PlayerID        INTEGER NOT NULL,
+    MsgIndex        INTEGER NOT NULL,
+    ReadFlag        INTEGER NOT NULL,
+    ItemFlag        INTEGER NOT NULL,
+    SenderID        INTEGER NOT NULL,
+    SenderFirstName TEXT NOT NULL COLLATE NOCASE,
+    SenderLastName  TEXT NOT NULL COLLATE NOCASE,
+    SubjectLine     TEXT NOT NULL,
+    MsgBody         TEXT NOT NULL,
+    Taros           INTEGER NOT NULL,
+    SendTime        INTEGER NOT NULL,
+    DeleteTime      INTEGER NOT NULL,
+    FOREIGN KEY(PlayerID) REFERENCES Players(PlayerID) ON DELETE CASCADE,
+    UNIQUE(PlayerID, MsgIndex)
+);
+
+CREATE TABLE IF NOT EXISTS EmailItems (
+    PlayerID    INTEGER NOT NULL,
+    MsgIndex    INTEGER NOT NULL,
+    Slot        INTEGER NOT NULL,
+    ID          INTEGER NOT NULL,
+    Type        INTEGER NOT NULL,
+    Opt         INTEGER NOT NULL,
+    TimeLimit   INTEGER NOT NULL,
+    FOREIGN KEY(PlayerID) REFERENCES Players(PlayerID) ON DELETE CASCADE,
+    UNIQUE (PlayerID, MsgIndex, Slot)
+);
+
+CREATE TABLE IF NOT EXISTS RaceResults(
+    EPID      INTEGER NOT NULL,
+    PlayerID  INTEGER NOT NULL,
+    Score     INTEGER NOT NULL,
+    RingCount INTEGER NOT NULL,
+    Time      INTEGER NOT NULL,
+    Timestamp INTEGER NOT NULL,
+    FOREIGN KEY(PlayerID) REFERENCES Players(PlayerID) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS RedeemedCodes(
+    PlayerID    INTEGER NOT NULL,
+    Code        TEXT NOT NULL,
+    FOREIGN KEY(PlayerID) REFERENCES Players(PlayerID) ON DELETE CASCADE,
+    UNIQUE (PlayerID, Code)
+)

core/db/players.go

@@ -0,0 +1,201 @@
+package db
+
+import (
+	"database/sql"
+
+	"github.com/CPunch/gopenfusion/config"
+	"github.com/CPunch/gopenfusion/core"
+	"github.com/CPunch/gopenfusion/core/protocol"
+	"github.com/blockloop/scan"
+)
+
+// returns PlayerID, error
+func (db *DBHandler) NewPlayer(AccountID int, FirstName, LastName string, slot int) (int, error) {
+	nameCheck := 1 // for now, we approve all names
+	QuestFlag := make([]byte, 128)
+	SkywayLocationFlag := make([]byte, 16)
+	FirstUseFlag := make([]byte, 16)
+
+	var PlayerID int
+	if err := db.Transaction(func(tx *sql.Tx) error {
+		// create player
+		row, err := tx.Query(
+			"INSERT INTO Players (AccountID, Slot, FirstName, LastName, XCoordinate, YCoordinate, ZCoordinate, Angle, HP, NameCheck, Quests, SkywayLocationFlag, FirstUseFlag) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING PlayerID",
+			AccountID, slot, FirstName, LastName, config.SPAWN_X, config.SPAWN_Y, config.SPAWN_Z, 0, config.GetMaxHP(1), nameCheck, QuestFlag, SkywayLocationFlag, FirstUseFlag)
+		if err != nil {
+			return err
+		}
+
+		if err := scan.Row(&PlayerID, row); err != nil {
+			return err
+		}
+
+		// create appearance
+		if _, err := tx.Exec("INSERT INTO Appearances (PlayerID) VALUES (?)", PlayerID); err != nil {
+			return err
+		}
+
+		return nil
+	}); err != nil {
+		return -1, nil
+	}
+
+	return PlayerID, nil
+}
+
+// TODO: should this operate on the raw packet? should we do validation here or prior?
+func (db *DBHandler) FinishPlayer(character *protocol.SP_CL2LS_REQ_CHAR_CREATE, AccountId int) error {
+	return db.Transaction(func(tx *sql.Tx) error {
+		// update AppearanceFlag
+		_, err := tx.Exec("UPDATE Players SET AppearanceFlag = 1 WHERE PlayerID = ? AND AccountID = ? AND AppearanceFlag = 0", character.PCStyle.IPC_UID, AccountId)
+		if err != nil {
+			return err
+		}
+
+		// update Appearance
+		_, err = tx.Exec("UPDATE Appearances SET Body = ?, EyeColor = ?, FaceStyle = ?, Gender = ?, HairColor = ?, HairStyle = ?, Height = ?, SkinColor = ? WHERE PlayerID = ?",
+			character.PCStyle.IBody,
+			character.PCStyle.IEyeColor,
+			character.PCStyle.IFaceStyle,
+			character.PCStyle.IGender,
+			character.PCStyle.IHairColor,
+			character.PCStyle.IHairStyle,
+			character.PCStyle.IHeight,
+			character.PCStyle.ISkinColor,
+			character.PCStyle.IPC_UID)
+		if err != nil {
+			return err
+		}
+
+		// update Inventory
+		items := [3]int16{character.SOn_Item.IEquipUBID, character.SOn_Item.IEquipLBID, character.SOn_Item.IEquipFootID}
+		for i := 0; i < len(items); i++ {
+			_, err = tx.Exec("INSERT INTO Inventory (PlayerID, Slot, ID, Type, Opt) VALUES (?, ?, ?, ?, 1)", character.PCStyle.IPC_UID, i, items[i], i+1)
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+}
+
+func (db *DBHandler) FinishTutorial(PlayerID, AccountID int) error {
+	_, err := db.Exec("UPDATE Players SET TutorialFlag = 1 WHERE PlayerID = ? AND AccountID = ? AND TutorialFlag = 0", PlayerID, AccountID)
+	if err != nil {
+		return err
+	}
+
+	// TODO: reference openfusion's finishTutorial for their academy specific patches
+	return nil
+}
+
+// returns the deleted Slot number
+func (db *DBHandler) DeletePlayer(PlayerID, AccountID int) (int, error) {
+	row, err := db.Query("DELETE FROM Players WHERE AccountID = ? AND PlayerID = ? RETURNING Slot")
+	if err != nil {
+		return -1, err
+	}
+
+	var slot int
+	for row.Next() {
+		if err := row.Scan(&slot); err != nil {
+			return -1, err
+		}
+	}
+
+	return slot, nil
+}
+
+const (
+	QUERY_PLAYERS = `SELECT
+		p.PlayerID, p.AccountID, p.Slot, p.FirstName, p.LastName,
+		p.Level, p.Nano1, p.Nano2, p.Nano3,
+		p.AppearanceFlag, p.TutorialFlag, p.PayZoneFlag,
+		p.XCoordinate, p.YCoordinate, p.ZCoordinate, p.NameCheck,
+		p.Angle, p.HP, p.FusionMatter, p.Taros, p.Quests,
+		p.BatteryW, p.BatteryN, p.Mentor, p.WarpLocationFlag,
+		p.SkywayLocationFlag, p.CurrentMissionID, p.FirstUseFlag,
+		a.Body, a.EyeColor, a.FaceStyle, a.Gender, a.HairColor, a.HairStyle,
+		a.Height, a.SkinColor, acc.AccountLevel
+	FROM Players as p
+	INNER JOIN Appearances as a ON p.PlayerID = a.PlayerID
+	INNER JOIN Accounts as acc ON p.AccountID = acc.AccountID `
+)
+
+func (db *DBHandler) readPlayer(rows *sql.Rows) (*core.Player, error) {
+	plr := core.Player{}
+
+	if err := rows.Scan(
+		&plr.PlayerID, &plr.AccountID, &plr.Slot, &plr.PCStyle.SzFirstName, &plr.PCStyle.SzLastName,
+		&plr.Level, &plr.EquippedNanos[0], &plr.EquippedNanos[1], &plr.EquippedNanos[2],
+		&plr.PCStyle2.IAppearanceFlag, &plr.PCStyle2.ITutorialFlag, &plr.PCStyle2.IPayzoneFlag,
+		&plr.X, &plr.Y, &plr.Z, &plr.PCStyle.INameCheck,
+		&plr.Angle, &plr.HP, &plr.FusionMatter, &plr.Taros, &plr.Quests,
+		&plr.BatteryW, &plr.BatteryN, &plr.Mentor, &plr.WarpLocationFlag,
+		&plr.SkywayLocationFlag, &plr.CurrentMissionID, &plr.FirstUseFlag,
+		&plr.PCStyle.IBody, &plr.PCStyle.IEyeColor, &plr.PCStyle.IFaceStyle, &plr.PCStyle.IGender, &plr.PCStyle.IHairColor, &plr.PCStyle.IHairStyle,
+		&plr.PCStyle.IHeight, &plr.PCStyle.ISkinColor, &plr.AccountLevel); err != nil {
+		return nil, err
+	}
+	plr.PCStyle.IPC_UID = int64(plr.PlayerID)
+
+	inven, err := db.GetPlayerInventorySlots(plr.PlayerID, 0, config.AEQUIP_COUNT+config.AINVEN_COUNT+config.ABANK_COUNT)
+	if err != nil {
+		return nil, err
+	}
+
+	// populate player inven
+	for i, item := range inven {
+		if item.IID == 0 { // skip empty slots
+			continue
+		}
+
+		switch {
+		case i < config.AEQUIP_COUNT:
+			plr.Equip[i] = item
+		case i < config.AEQUIP_COUNT+config.AINVEN_COUNT:
+			plr.Inven[i-config.AEQUIP_COUNT] = item
+		default:
+			plr.Bank[i-config.AEQUIP_COUNT-config.AINVEN_COUNT] = item
+		}
+	}
+
+	return &plr, nil
+}
+
+func (db *DBHandler) GetPlayer(PlayerID int) (*core.Player, error) {
+	rows, err := db.Query(QUERY_PLAYERS+"WHERE p.PlayerID = ?", PlayerID)
+	if err != nil {
+		return nil, err
+	}
+
+	var plr *core.Player
+	for rows.Next() {
+		plr, err = db.readPlayer(rows)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return plr, nil
+}
+
+func (db *DBHandler) GetPlayers(AccountID int) ([]core.Player, error) {
+	rows, err := db.Query(QUERY_PLAYERS+"WHERE p.AccountID = ?", AccountID)
+	if err != nil {
+		return nil, err
+	}
+
+	var plrs []core.Player
+	for rows.Next() {
+		plr, err := db.readPlayer(rows)
+		if err != nil {
+			return nil, err
+		}
+
+		plrs = append(plrs, *plr)
+	}
+
+	return plrs, nil
+}

core/db/schema.go

@@ -0,0 +1,72 @@
+package db
+
+/*
+	This database has been based off of openfusion's. Databases should be completely interchangable between
+	openfusion and gopenfusion.
+*/
+
+import (
+	"database/sql"
+	_ "embed"
+	"fmt"
+
+	_ "github.com/glebarez/go-sqlite"
+)
+
+type DBHandler struct {
+	db *sql.DB
+}
+
+//go:embed migrations/new.sql
+var createDBQuery string
+
+func OpenLiteDB(dbPath string) (*DBHandler, error) {
+	sqliteFmt := fmt.Sprintf("%s", dbPath)
+
+	db, err := sql.Open("sqlite", sqliteFmt)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DBHandler{db}, nil
+}
+
+func (db *DBHandler) Query(query string, args ...any) (*sql.Rows, error) {
+	return db.db.Query(query, args...)
+}
+
+func (db *DBHandler) Exec(query string, args ...any) (sql.Result, error) {
+	return db.db.Exec(query, args...)
+}
+
+func (db *DBHandler) Close() error {
+	return db.db.Close()
+}
+
+func (db *DBHandler) Setup() error {
+	// create db tables
+	_, err := db.db.Exec(createDBQuery)
+	return err
+}
+
+// calls transaction, if transaction returns a non-nil error the transaction is rolled back. otherwise the transaction is committed
+func (db *DBHandler) Transaction(transaction func(*sql.Tx) error) (err error) {
+	tx, err := db.db.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if p := recover(); p != nil {
+			// we panic'd ??? rollback and rethrow
+			tx.Rollback()
+			panic(p)
+		} else if err != nil {
+			tx.Rollback()
+		} else {
+			err = tx.Commit()
+		}
+	}()
+
+	err = transaction(tx)
+	return
+}

core/player.go

@@ -0,0 +1,36 @@
+package core
+
+import (
+	"github.com/CPunch/gopenfusion/config"
+	"github.com/CPunch/gopenfusion/core/protocol"
+)
+
+type Player struct {
+	PlayerID           int
+	AccountID          int
+	AccountLevel       int
+	Slot               int
+	PCStyle            protocol.SPCStyle
+	PCStyle2           protocol.SPCStyle2
+	EquippedNanos      [3]int
+	Nanos              [config.NANO_COUNT]protocol.SNano
+	Equip              [config.AEQUIP_COUNT]protocol.SItemBase
+	Inven              [config.AINVEN_COUNT]protocol.SItemBase
+	Bank               [config.ABANK_COUNT]protocol.SItemBase
+	SkywayLocationFlag []byte
+	FirstUseFlag       []byte
+	Quests             []byte
+	HP                 int
+	Level              int
+	Taros              int
+	FusionMatter       int
+	Mentor             int
+	X, Y, Z            int
+	Angle              int
+	BatteryN           int
+	BatteryW           int
+	WarpLocationFlag   int
+	ActiveNanoSlotNum  int
+	Fatigue            int
+	CurrentMissionID   int
+}

core/protocol/cnpeer.go

@@ -0,0 +1,148 @@
+package protocol
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"log"
+	"net"
+
+	"github.com/CPunch/gopenfusion/core/protocol/pool"
+)
+
+const (
+	USE_E = iota
+	USE_FE
+)
+
+type PeerHandler interface {
+	HandlePacket(peer *CNPeer, typeID uint32, pkt Packet) error
+	Disconnect(peer *CNPeer)
+}
+
+// CNPeer is a simple wrapper for net.Conn connections to send/recv packets over the Fusionfall packet protocol.
+type CNPeer struct {
+	conn      net.Conn
+	handler   PeerHandler
+	SzID      string
+	E_key     []byte
+	FE_key    []byte
+	AccountID int
+	whichKey  int
+	alive     bool
+}
+
+func NewCNPeer(handler PeerHandler, conn net.Conn) *CNPeer {
+	return &CNPeer{
+		conn:      conn,
+		handler:   handler,
+		SzID:      "",
+		E_key:     []byte(DEFAULT_KEY),
+		FE_key:    nil,
+		AccountID: -1,
+		whichKey:  USE_E,
+		alive:     true,
+	}
+}
+
+func (peer *CNPeer) Send(typeID uint32, data ...interface{}) error {
+	// grab buffer from pool
+	buf := pool.Get()
+	defer pool.Put(buf)
+
+	// body start
+	pkt := NewPacket(buf)
+
+	// encode type id
+	if err := pkt.Encode(typeID); err != nil {
+		return err
+	}
+
+	// encode data
+	for _, trailer := range data {
+		if err := pkt.Encode(trailer); err != nil {
+			return err
+		}
+	}
+
+	// encrypt body
+	switch peer.whichKey {
+	case USE_E:
+		EncryptData(buf.Bytes(), peer.E_key)
+	case USE_FE:
+		EncryptData(buf.Bytes(), peer.FE_key)
+	}
+
+	// write packet size
+	if err := binary.Write(peer.conn, binary.LittleEndian, uint32(buf.Len())); err != nil {
+		return err
+	}
+
+	// write packet body
+	log.Printf("Sending %#v, sizeof: %d", data, buf.Len())
+	if _, err := peer.conn.Write(buf.Bytes()); err != nil {
+		return fmt.Errorf("[FATAL] failed to write packet body! %v", err)
+	}
+
+	return nil
+}
+
+func (peer *CNPeer) Kill() {
+	if !peer.alive {
+		return
+	}
+
+	peer.alive = false
+	peer.conn.Close()
+	peer.handler.Disconnect(peer)
+}
+
+// meant to be invoked as a goroutine
+func (peer *CNPeer) Handler() {
+	defer peer.Kill()
+
+	for {
+		// read packet size, the goroutine spends most of it's time parked here
+		var sz uint32
+		if err := binary.Read(peer.conn, binary.LittleEndian, &sz); err != nil {
+			log.Printf("[FATAL] failed to read packet size! %v\n", err)
+			return
+		}
+
+		// client should never send a packet size outside of this range
+		if sz > CN_PACKET_BUFFER_SIZE || sz < 4 {
+			log.Printf("[FATAL] malicious packet size received! %d", sz)
+			return
+		}
+
+		// grab buffer && read packet body
+		if err := func() error { // we wrap this in a closure so we can easily defer the buffer return to pool
+			buf := pool.Get()
+			defer pool.Put(buf)
+			if _, err := buf.ReadFrom(io.LimitReader(peer.conn, int64(sz))); err != nil {
+				return fmt.Errorf("failed to read packet body! %v", err)
+			}
+
+			// decrypt
+			DecryptData(buf.Bytes(), peer.E_key)
+			pkt := NewPacket(buf)
+
+			// create packet && read typeID
+			var typeID uint32
+			if err := pkt.Decode(&typeID); err != nil {
+				return fmt.Errorf("failed to read packet type! %v", err)
+			}
+
+			// dispatch packet
+			log.Printf("Got packet ID: %x, with a sizeof: %d\n", typeID, sz)
+			if err := peer.handler.HandlePacket(peer, typeID, pkt); err != nil {
+				return err
+			}
+
+			return nil
+		}(); err != nil {
+			log.Printf("[FATAL] %v", err)
+			return
+		}
+	}
+}

core/protocol/encrypt.go

@@ -0,0 +1,71 @@
+package protocol
+
+import (
+	"crypto/rand"
+	"encoding/binary"
+)
+
+const (
+	DEFAULT_KEY = "m@rQn~W#"
+	KEY_LENGTH  = 8
+)
+
+func encrypt_byte_change_A(ERSize int, data []byte) int {
+	var num, num2, num3 int
+
+	for num+ERSize <= len(data) {
+		num4 := num + num3
+		num5 := num + (ERSize - 1 - num3)
+
+		b := data[num4]
+		data[num4] = data[num5]
+		data[num5] = b
+		num += ERSize
+		num3++
+		if num3 > ERSize/2 {
+			num3 = 0
+		}
+	}
+
+	num2 = ERSize - (num + ERSize - len(data))
+	return num + num2
+}
+
+func xorData(buff, key []byte, size int) {
+	for i := 0; i < size; i++ {
+		buff[i] ^= key[i%KEY_LENGTH]
+	}
+}
+
+func EncryptData(buff, key []byte) {
+	ERSize := len(buff)%(KEY_LENGTH/2+1)*2 + KEY_LENGTH
+	xorData(buff, key, len(buff))
+	encrypt_byte_change_A(ERSize, buff)
+}
+
+func DecryptData(buff, key []byte) {
+	ERSize := len(buff)%(KEY_LENGTH/2+1)*2 + KEY_LENGTH
+	size := encrypt_byte_change_A(ERSize, buff)
+	xorData(buff, key, size)
+}
+
+func CreateNewKey(uTime uint64, iv1, iv2 uint64) []byte {
+	num := iv1 + 1
+	num2 := iv2 + 1
+
+	dEKey := uint64(binary.LittleEndian.Uint64([]byte(DEFAULT_KEY)))
+	key := dEKey * (uTime * num * num2)
+	buf := make([]byte, 8)
+	binary.LittleEndian.PutUint64(buf, uint64(key))
+	return buf
+}
+
+func GenSerialKey() (int64, error) {
+	tmp := [8]byte{}
+	if _, err := rand.Read(tmp[:]); err != nil {
+		return 0, err
+	}
+
+	// convert to uint64 && return
+	return int64(binary.LittleEndian.Uint64(tmp[:])), nil
+}

core/protocol/packet.go

@@ -0,0 +1,158 @@
+package protocol
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"reflect"
+	"strconv"
+	"unicode/utf16"
+)
+
+/*
+	this file handles serializing (and deserializing) structs to alignment-strict c structures generated via `tools/genstructs.py`.
+	see script for details on usage!
+*/
+
+type Packet struct {
+	readWriter io.ReadWriter
+}
+
+func NewPacket(readWriter io.ReadWriter) Packet {
+	return Packet{
+		readWriter: readWriter,
+	}
+}
+
+func (pkt Packet) encodeStructField(field reflect.StructField, value reflect.Value) error {
+	// log.Printf("Encoding '%s'", field.Name)
+
+	switch field.Type.Kind() {
+	case reflect.String: // all strings in fusionfall packets are encoded as utf16, we'll need to encode it
+		sz, err := strconv.Atoi(field.Tag.Get("size"))
+		if err != nil {
+			return fmt.Errorf("Failed to grab string 'size' tag!!")
+		}
+
+		buf16 := utf16.Encode([]rune(value.String()))
+
+		// len(buf16) needs to be the same size as sz
+		if len(buf16) > sz {
+			// truncate
+			buf16 = buf16[:sz]
+		} else {
+			// grow
+			// TODO: probably a better way to do this?
+			for len(buf16) < sz {
+				buf16 = append(buf16, 0)
+			}
+		}
+
+		// write
+		if err := binary.Write(pkt.readWriter, binary.LittleEndian, buf16); err != nil {
+			return err
+		}
+	default:
+		if err := pkt.Encode(value.Interface()); err != nil {
+			return err
+		}
+	}
+
+	// write padding bytes
+	pad, err := strconv.Atoi(field.Tag.Get("pad"))
+	if err == nil {
+		for i := 0; i < pad; i++ {
+			if _, err := pkt.readWriter.Write([]byte{0}); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (pkt Packet) Encode(data interface{}) error {
+	rv := reflect.Indirect(reflect.ValueOf(data))
+
+	switch rv.Kind() {
+	case reflect.Struct:
+		// walk through each struct fields
+		sz := rv.NumField()
+		for i := 0; i < sz; i++ {
+			if err := pkt.encodeStructField(rv.Type().Field(i), rv.Field(i)); err != nil {
+				return err
+			}
+		}
+	default:
+		// we pass everything else to go's binary package
+		if err := binary.Write(pkt.readWriter, binary.LittleEndian, data); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (pkt Packet) decodeStructField(field reflect.StructField, value reflect.Value) error {
+	// log.Printf("Decoding '%s'", field.Name)
+
+	switch field.Type.Kind() {
+	case reflect.String: // all strings in fusionfall packets are encoded as utf16, we'll need to decode it
+		sz, err := strconv.Atoi(field.Tag.Get("size"))
+		if err != nil {
+			return fmt.Errorf("Failed to grab string 'size' tag!!")
+		}
+
+		buf16 := make([]uint16, sz)
+		if err := binary.Read(pkt.readWriter, binary.LittleEndian, buf16); err != nil {
+			return err
+		}
+
+		// find null terminator
+		var realSize int
+		for ; realSize < len(buf16); realSize++ {
+			if buf16[realSize] == 0 {
+				break
+			}
+		}
+
+		value.SetString(string(utf16.Decode(buf16[:realSize])))
+	default:
+		if err := pkt.Decode(value.Addr().Interface()); err != nil {
+			return err
+		}
+	}
+
+	// consume padding bytes
+	pad, err := strconv.Atoi(field.Tag.Get("pad"))
+	if err == nil {
+		for i := 0; i < pad; i++ {
+			if _, err := pkt.readWriter.Read([]byte{0}); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (pkt Packet) Decode(data interface{}) error {
+	rv := reflect.Indirect(reflect.ValueOf(data))
+
+	switch rv.Kind() {
+	case reflect.Struct:
+		// walk through each struct fields
+		sz := rv.NumField()
+		for i := 0; i < sz; i++ {
+			if err := pkt.decodeStructField(rv.Type().Field(i), rv.Field(i)); err != nil {
+				return err
+			}
+		}
+	default:
+		if err := binary.Read(pkt.readWriter, binary.LittleEndian, data); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

core/protocol/pool/pool.go

@@ -0,0 +1,19 @@
+package pool
+
+import (
+	"bytes"
+	"sync"
+)
+
+var allocator = &sync.Pool{
+	New: func() any { return new(bytes.Buffer) },
+}
+
+func Get() *bytes.Buffer {
+	return allocator.Get().(*bytes.Buffer)
+}
+
+func Put(buf *bytes.Buffer) {
+	buf.Reset()
+	allocator.Put(buf)
+}