test

Documentation

Index

• Variables
• type Book
• type Committee
• type Owner
• type Person
• type Pet
• type PetCommunity
• type PetKind
• type Token

Variables

var TestBookSystem = server.CreateSystemFromRequestHandler(func(ctx *server.TransactionCtx[*pb_test.C2S_Test]) {
	req := ctx.Req.Data
	w := ctx.W

	playerID := int(req.GetIdentityPayload().GetPlayerId())

	for _, bookInfo := range req.BookInfos {
		switch bookInfo.Op {
		case pb_test.Operation_Add:
			bookTable.Add(w, Book{
				Title:   bookInfo.Title,
				Author:  bookInfo.Author,
				OwnerID: playerID,
			})
		case pb_test.Operation_AddSpecific:
			bookTable.AddSpecific(w, int(bookInfo.Entity), Book{
				Title:   bookInfo.Title,
				Author:  bookInfo.Author,
				OwnerID: playerID,
			})
		case pb_test.Operation_Remove:
			server.QueueTxFromInternal(w, ctx.GameCtx.GameTick.TickNumber+1, server.NewKeystoneTx(testRemoveRequest{
				Title:    bookInfo.Title,
				Author:   bookInfo.Author,
				PlayerID: playerID,
			}, nil), "")
		case pb_test.Operation_Update:
			book := bookTable.Get(w, int(bookInfo.Entity))
			if book.Title == "" {
				ctx.EmitError(fmt.Sprintf("no book to update with entity %v", bookInfo.Entity), []int{playerID})
				return
			}

			book.Title = bookInfo.Title
			book.Author = bookInfo.Author
			bookTable.Set(w, int(bookInfo.Entity), book)
		}
	}
})

var TestRemoveBookSystem = server.CreateSystemFromRequestHandler(func(ctx *server.TransactionCtx[testRemoveRequest]) {
	req := ctx.Req.Data
	w := ctx.GameCtx.World

	bookFilter := Book{Author: req.Author, Title: req.Title, OwnerID: req.PlayerID}
	fieldNames := []string{"OwnerID"}
	if req.Author == "" && req.Title == "" {
		ctx.EmitError("author or title must be provided to remove a book", []int{req.PlayerID})
		return
	}

	if req.Author != "" {
		fieldNames = append(fieldNames, "Author")
	}
	if req.Title != "" {
		fieldNames = append(fieldNames, "Title")
	}

	bookEntities := bookTable.Filter(w, bookFilter, fieldNames)
	for _, e := range bookEntities {
		bookTable.RemoveEntity(w, e)
	}
})

Types

type Book

type Book struct {
	Title   string
	Author  string
	OwnerID int
	Id      int `gorm:"primaryKey;autoIncrement:false"`
}

type Committee

type Committee struct {
	CommitteeOwners utils.SerializableArray[Owner] `gorm:"serializer:json"`
}

type Owner

type Owner struct {
	Name  string    `json:"name"`
	Age   int       `json:"age"`
	Happy bool      `json:"happy"`
	Pets  []Pet     `json:"pets"`
	Pos   state.Pos `json:"pos" gorm:"embedded"`
}

type Person

type Person struct {
	Name       string
	MainWallet string
	Age        int
	Address    string
	Position   state.Pos `gorm:"embedded"`
	BookId     int
	Id         int `gorm:"primaryKey;autoIncrement:false"`
}

type Pet

type Pet struct {
	Kind PetKind `json:"kind"`
	Name string  `json:"name"`
}

type PetCommunity

type PetCommunity struct {
	Owners    utils.SerializableArray[Owner] `gorm:"serializer:json"`
	Committee Committee                      `gorm:"embedded"`
	Id        int                            `gorm:"primaryKey;autoIncrement:false"`
}

type PetKind

type PetKind int

const (
	Dog PetKind = iota
	Cat
)

type Token

type Token struct {
	OriginalOwnerId int
	OwnerId         int
	Id              int `gorm:"primaryKey;autoIncrement:false"`
}