chenyh
/
vRp.CD2g_test
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

refactor: 移除 game 包中大量陈旧及不合理设计

This commit is contained in:
kercylan98 2023-12-22 10:28:49 +08:00
parent 41246ef365
commit af0165af71
12 changed files with 1 additions and 512 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/release.yml vendored
View File

@ -18,4 +18,4 @@ jobs:
bump-minor-pre-major: true
bump-patch-for-minor-pre-major: true
changelog-types: '[{"type":"other","section":"Other | 其他更改","hidden":false},{"type":"revert","section":"Reverts | 回退","hidden":false},{"type":"feat","section":"Features | 新特性","hidden":false},{"type":"fix","section":"Bug Fixes | 修复","hidden":false},{"type":"improvement","section":"Feature Improvements | 改进","hidden":false},{"type":"docs","section":"Docs | 文档优化","hidden":false},{"type":"style","section":"Styling | 可读性优化","hidden":false},{"type":"refactor","section":"Code Refactoring | 重构","hidden":false},{"type":"perf","section":"Performance Improvements | 性能优化","hidden":false},{"type":"test","section":"Tests | 新增或优化测试用例","hidden":false},{"type":"build","section":"Build System | 影响构建的修改","hidden":false},{"type":"ci","section":"CI | 更改我们的 CI 配置文件和脚本","hidden":false}]'
# release-as: 0.3.0
release-as: 0.4.0

3
game/README.md
View File

@ -6,9 +6,6 @@
## Activity 游戏活动
提供了通用的游戏活动接口及各类辅助函数，开发者可以使用它来快速创建和管理游戏中的各类活动。活动是游戏中的特殊事件，通常在限时或周期内举行，为玩家提供额外奖励、挑战或合作机会。活动框架将实现活动时间的管理，包括开始和结束时间的设定，并提供活动数据的管理功能，例如参与玩家的记录、活动奖励等。开发者可以根据具体游戏需求，自由定制不同类型的活动，并快速集成到游戏中。
## Poker 扑克玩法
提供了通用的扑克游戏数据结构和辅助函数，如牌堆、扑克牌、牌型、匹配器等，使得开发者可以轻松实现各种扑克类游戏。扑克游戏是一种流行的纸牌游戏，通常涉及赌注和策略。在这个子目录中，我们将实现通用的扑克游戏框架，例如德州扑克框架、奥马哈扑克框架等，开发者可以基于这些框架快速搭建具有不同规则的扑克游戏，并灵活调整游戏规则和玩法，较为核心的内容则是提供了牌型检测及最优组合选取的功能，以及内置了一系列常用的牌型等。
## Room 游戏房间
提供了通用的基础游戏房间设计，开发者可以使用它来构建游戏中的多人模式功能。房间是指游戏中的多人对战或合作模式，玩家可以创建或加入房间，与其他玩家一起进行游戏。 该目录内提供了统一的房间管理及座位号等常用功能，并配置了大量的事件供给状态监控。

19
game/builtin/actor.go
View File

@ -1,19 +0,0 @@
package builtin
func NewActor(guid int64) *Actor {
return &Actor{
guid: guid,
}
}
type Actor struct {
guid int64
}
func (slf *Actor) SetGuid(guid int64) {
slf.guid = guid
}
func (slf *Actor) GetGuid() int64 {
return slf.guid
}

22
game/builtin/item.go
View File

@ -1,22 +0,0 @@
package builtin
import "github.com/kercylan98/minotaur/game"
func NewItem[ItemID comparable](id ItemID) *Item[ItemID] {
item := &Item[ItemID]{
id: id,
}
return item
}
type Item[ItemID comparable] struct {
id ItemID
}
func (slf *Item[ItemID]) GetID() ItemID {
return slf.id
}
func (slf *Item[ItemID]) IsSame(item game.Item[ItemID]) bool {
return slf.id == item.GetID()
}

313
game/builtin/item_container.go
View File

@ -1,313 +0,0 @@
package builtin
import (
"github.com/kercylan98/minotaur/game"
"github.com/kercylan98/minotaur/utils/huge"
"github.com/kercylan98/minotaur/utils/super"
"sync/atomic"
)
func NewItemContainer[ItemID comparable, Item game.Item[ItemID]](options ...ItemContainerOption[ItemID, Item]) *ItemContainer[ItemID, Item] {
itemContainer := &ItemContainer[ItemID, Item]{
items: map[int64]*ItemContainerMember[ItemID, Item]{},
itemIdGuidRef: map[ItemID]map[int64]bool{},
}
for _, option := range options {
option(itemContainer)
}
return itemContainer
}
type ItemContainer[ItemID comparable, Item game.Item[ItemID]] struct {
guid atomic.Int64
sizeLimit int
size int
expandSize int
items map[int64]*ItemContainerMember[ItemID, Item]
itemIdGuidRef map[ItemID]map[int64]bool
sort []*int64
maxSort int
vacancy []int
stackLimit map[ItemID]*huge.Int
}
func (slf *ItemContainer[ItemID, Item]) GetSize() int {
return slf.size
}
func (slf *ItemContainer[ItemID, Item]) GetSizeLimit() int {
return slf.sizeLimit + slf.expandSize
}
func (slf *ItemContainer[ItemID, Item]) SetExpandSize(size int) {
slf.expandSize = size
}
func (slf *ItemContainer[ItemID, Item]) GetItem(guid int64) (game.ItemContainerMember[ItemID, Item], error) {
item, exist := slf.items[guid]
if !exist {
return nil, ErrItemNotExist
}
return item, nil
}
func (slf *ItemContainer[ItemID, Item]) GetItems() []game.ItemContainerMember[ItemID, Item] {
var result = make([]game.ItemContainerMember[ItemID, Item], 0, len(slf.sort))
for _, guid := range slf.sort {
if guid == nil {
continue
}
result = append(result, slf.items[*guid])
}
return result
}
func (slf *ItemContainer[ItemID, Item]) GetItemsFull() []game.ItemContainerMember[ItemID, Item] {
var result = make([]game.ItemContainerMember[ItemID, Item], len(slf.sort), len(slf.sort))
for i, guid := range slf.sort {
if guid == nil {
result[i] = nil
} else {
result[i] = slf.items[*guid]
}
}
sizeLimit := slf.GetSizeLimit()
for sizeLimit > 0 && len(result) > sizeLimit {
result = append(result, nil)
}
return result
}
func (slf *ItemContainer[ItemID, Item]) GetItemsMap() map[int64]game.ItemContainerMember[ItemID, Item] {
var m = make(map[int64]game.ItemContainerMember[ItemID, Item])
for k, v := range slf.items {
m[k] = v
}
return m
}
func (slf *ItemContainer[ItemID, Item]) ExistItem(guid int64) bool {
_, exist := slf.items[guid]
return exist
}
func (slf *ItemContainer[ItemID, Item]) ExistItemWithID(id ItemID) bool {
return len(slf.itemIdGuidRef[id]) > 0
}
func (slf *ItemContainer[ItemID, Item]) AddItem(item Item, count *huge.Int) (guid int64, err error) {
if count.LessThanOrEqualTo(huge.IntZero) {
return 0, ErrCannotAddNegativeOrZeroItem
}
for guid := range slf.itemIdGuidRef[item.GetID()] {
member := slf.items[guid]
if member.GetItem().IsSame(item) {
if stackLimit := slf.stackLimit[item.GetID()]; stackLimit != nil && member.count.Copy().Add(count).GreaterThan(stackLimit) {
continue
}
member.count.Add(count)
return guid, nil
}
}
if slf.size >= slf.GetSizeLimit() {
return 0, ErrItemContainerIsFull
}
guid = slf.guid.Add(1)
slf.items[guid] = &ItemContainerMember[ItemID, Item]{
item: item,
guid: guid,
count: count.Copy(),
sort: super.If(len(slf.vacancy) == 0,
func() int {
sort := len(slf.sort)
slf.sort = append(slf.sort, &guid)
if sort > slf.maxSort {
slf.maxSort = sort
}
return sort
}(),
func() int {
sort := slf.vacancy[0]
slf.vacancy = slf.vacancy[1:]
slf.sort[sort] = &guid
return sort
}(),
),
}
guids, exist := slf.itemIdGuidRef[item.GetID()]
if !exist {
guids = map[int64]bool{}
slf.itemIdGuidRef[item.GetID()] = guids
}
guids[guid] = true
slf.size++
return guid, nil
}
func (slf *ItemContainer[ItemID, Item]) DeductItem(guid int64, count *huge.Int) error {
if !slf.ExistItem(guid) {
return ErrItemNotExist
}
member := slf.items[guid]
if member.count.GreaterThanOrEqualTo(count) {
member.count.Sub(count)
if member.count.EqualTo(huge.IntZero) {
slf.size--
slf.sort[member.sort] = nil
slf.vacancy = append(slf.vacancy, member.sort)
delete(slf.items, guid)
sizeLimit := slf.GetSizeLimit()
for slf.sort[slf.maxSort] == nil && slf.maxSort > sizeLimit {
slf.sort = append(slf.sort[0:slf.maxSort], slf.sort[slf.maxSort+1:]...)
slf.maxSort--
}
}
return nil
} else {
var need = count.Copy()
var handles []func()
var guids = slf.itemIdGuidRef[member.GetID()]
for guid := range guids {
member := slf.items[guid]
if need.GreaterThanOrEqualTo(member.count) {
need.Sub(member.count)
handles = append(handles, func() {
member.count = huge.IntZero.Copy()
slf.size--
delete(guids, guid)
delete(slf.items, guid)
if len(guids) == 0 {
delete(slf.itemIdGuidRef, member.GetID())
}
slf.sort[member.sort] = nil
slf.vacancy = append(slf.vacancy, member.sort)
sizeLimit := slf.GetSizeLimit()
for slf.sort[slf.maxSort] == nil && slf.maxSort > sizeLimit {
slf.sort = append(slf.sort[0:slf.maxSort], slf.sort[slf.maxSort+1:]...)
slf.maxSort--
}
})
} else {
member.count.Sub(need)
need = huge.IntZero
}
}
if need.GreaterThan(huge.IntZero) {
return ErrItemInsufficientQuantity
}
for _, handle := range handles {
handle()
}
return nil
}
}
func (slf *ItemContainer[ItemID, Item]) TransferTo(guid int64, count *huge.Int, target game.ItemContainer[ItemID, Item]) error {
if target == nil {
return ErrItemContainerNotExist
}
if count.LessThanOrEqualTo(huge.IntZero) {
return ErrCannotAddNegativeOrZeroItem
}
member, err := slf.GetItem(guid)
if err != nil {
return err
}
if err = slf.CheckDeductItem(guid, count); err != nil {
return err
}
if err = target.CheckAllowAdd(member.GetItem(), count); err != nil {
return err
}
_ = slf.DeductItem(guid, count)
_, _ = target.AddItem(member.GetItem(), count)
return nil
}
func (slf *ItemContainer[ItemID, Item]) CheckAllowAdd(item Item, count *huge.Int) error {
if count.LessThanOrEqualTo(huge.IntZero) {
return ErrCannotAddNegativeOrZeroItem
}
for guid := range slf.itemIdGuidRef[item.GetID()] {
member := slf.items[guid]
if member.GetItem().IsSame(item) {
if stackLimit := slf.stackLimit[item.GetID()]; stackLimit != nil && member.count.Copy().Add(count).GreaterThan(stackLimit) {
continue
}
return nil
}
}
if slf.size >= slf.GetSizeLimit() {
return ErrItemContainerIsFull
}
return nil
}
func (slf *ItemContainer[ItemID, Item]) CheckDeductItem(guid int64, count *huge.Int) error {
if !slf.ExistItem(guid) {
return ErrItemNotExist
}
member := slf.items[guid]
if member.count.GreaterThanOrEqualTo(count) {
return nil
} else {
var need = count.Copy()
var guids = slf.itemIdGuidRef[member.GetID()]
for guid := range guids {
member := slf.items[guid]
if need.GreaterThanOrEqualTo(member.count) {
need.Sub(member.count)
} else {
need = huge.IntZero
}
}
if need.GreaterThan(huge.IntZero) {
return ErrItemInsufficientQuantity
}
return nil
}
}
func (slf *ItemContainer[ItemID, Item]) Remove(guid int64) {
member, exist := slf.items[guid]
if !exist {
return
}
delete(slf.items, guid)
delete(slf.itemIdGuidRef[member.GetID()], guid)
slf.sort[member.sort] = nil
slf.vacancy = append(slf.vacancy, member.sort)
sizeLimit := slf.GetSizeLimit()
for slf.sort[slf.maxSort] == nil && slf.maxSort > sizeLimit {
slf.sort = append(slf.sort[0:slf.maxSort], slf.sort[slf.maxSort+1:]...)
slf.maxSort--
}
}
func (slf *ItemContainer[ItemID, Item]) RemoveWithID(id ItemID) {
for guid := range slf.itemIdGuidRef[id] {
member, exist := slf.items[guid]
if !exist {
continue
}
delete(slf.items, guid)
slf.sort[member.sort] = nil
slf.vacancy = append(slf.vacancy, member.sort)
}
delete(slf.itemIdGuidRef, id)
sizeLimit := slf.GetSizeLimit()
for slf.sort[slf.maxSort] == nil && slf.maxSort > sizeLimit {
slf.sort = append(slf.sort[0:slf.maxSort], slf.sort[slf.maxSort+1:]...)
slf.maxSort--
}
}
func (slf *ItemContainer[ItemID, Item]) Clear() {
slf.items = map[int64]*ItemContainerMember[ItemID, Item]{}
slf.itemIdGuidRef = map[ItemID]map[int64]bool{}
slf.sort = nil
slf.maxSort = 0
slf.vacancy = nil
}

11
game/builtin/item_container_errors.go
View File

@ -1,11 +0,0 @@
package builtin
import "errors"
var (
ErrCannotAddNegativeOrZeroItem = errors.New("cannot add items with negative quantities or zero")
ErrItemNotExist = errors.New("item not exist")
ErrItemInsufficientQuantity = errors.New("item insufficient quantity")
ErrItemContainerIsFull = errors.New("item container is full")
ErrItemContainerNotExist = errors.New("item container not exist")
)

36
game/builtin/item_container_member.go
View File

@ -1,36 +0,0 @@
package builtin
import (
"github.com/kercylan98/minotaur/game"
"github.com/kercylan98/minotaur/utils/huge"
)
func NewItemContainerMember[ItemID comparable, I game.Item[ItemID]](guid int64, item I) *ItemContainerMember[ItemID, I] {
return &ItemContainerMember[ItemID, I]{
item: item,
guid: guid,
}
}
type ItemContainerMember[ItemID comparable, I game.Item[ItemID]] struct {
item I
guid int64
sort int
count *huge.Int
}
func (slf *ItemContainerMember[ItemID, I]) GetID() ItemID {
return slf.item.GetID()
}
func (slf *ItemContainerMember[ItemID, I]) GetGUID() int64 {
return slf.guid
}
func (slf *ItemContainerMember[ItemID, I]) GetCount() *huge.Int {
return slf.count.Copy()
}
func (slf *ItemContainerMember[ItemID, I]) GetItem() I {
return slf.item
}

31
game/builtin/item_container_options.go
View File

@ -1,31 +0,0 @@
package builtin
import (
"github.com/kercylan98/minotaur/game"
"github.com/kercylan98/minotaur/utils/huge"
)
type ItemContainerOption[ItemID comparable, Item game.Item[ItemID]] func(container *ItemContainer[ItemID, Item])
// WithItemContainerSizeLimit 通过特定的物品容器非堆叠数量上限创建物品容器
func WithItemContainerSizeLimit[ItemID comparable, Item game.Item[ItemID]](sizeLimit int) ItemContainerOption[ItemID, Item] {
return func(container *ItemContainer[ItemID, Item]) {
if sizeLimit <= 0 {
return
}
container.sizeLimit = sizeLimit
}
}
// WithItemContainerStackLimit 通过设置特定物品堆叠数量创建容器
func WithItemContainerStackLimit[ItemID comparable, Item game.Item[ItemID]](id ItemID, stackLimit *huge.Int) ItemContainerOption[ItemID, Item] {
return func(container *ItemContainer[ItemID, Item]) {
if stackLimit.LessThanOrEqualTo(huge.IntZero) {
return
}
if container.stackLimit == nil {
container.stackLimit = map[ItemID]*huge.Int{}
}
container.stackLimit[id] = stackLimit
}
}

6
game/builtin/item_container_sort.go
View File

@ -1,6 +0,0 @@
package builtin
type itemContainerSort[ItemID comparable] struct {
id ItemID
guid int64
}

8
game/item.go
View File

@ -1,8 +0,0 @@
package game
type Item[ID comparable] interface {
// GetID 获取物品ID
GetID() ID
// IsSame 与另一个物品比较是否相同
IsSame(item Item[ID]) bool
}

47
game/item_container.go
View File

@ -1,47 +0,0 @@
package game
import "github.com/kercylan98/minotaur/utils/huge"
// ItemContainer 物品容器
type ItemContainer[ItemID comparable, I Item[ItemID]] interface {
// GetSize 获取容器物品非堆叠数量
GetSize() int
// GetSizeLimit 获取容器物品非堆叠数量上限
GetSizeLimit() int
// SetExpandSize 设置拓展非堆叠数量上限
SetExpandSize(size int)
// GetItem 获取物品
GetItem(guid int64) (ItemContainerMember[ItemID, I], error)
// GetItems 获取所有非空物品
// - 物品顺序为容器内顺序
// - 空的容器空间将被忽略
GetItems() []ItemContainerMember[ItemID, I]
// GetItemsFull 获取所有物品
// - 物品顺序为容器内顺序
// - 空的容器空间将被设置为nil
// - 当容器非堆叠物品上限为0时，最后一个非空物品之后的所有空物品都将被忽略
// - 当容器非堆叠物品未达到上限时，其余空间将使用nil填充
GetItemsFull() []ItemContainerMember[ItemID, I]
// GetItemsMap 获取所有物品
GetItemsMap() map[int64]ItemContainerMember[ItemID, I]
// ExistItem 物品是否存在
ExistItem(guid int64) bool
// ExistItemWithID 是否存在特定ID的物品
ExistItemWithID(id ItemID) bool
// AddItem 添加物品
AddItem(item I, count *huge.Int) (guid int64, err error)
// DeductItem 扣除特定物品数量，当数量为0将被移除，数量不足时将不进行任何改变
DeductItem(guid int64, count *huge.Int) error
// TransferTo 转移特定物品到另一个容器中
TransferTo(guid int64, count *huge.Int, target ItemContainer[ItemID, I]) error
// CheckAllowAdd 检查是否允许添加特定物品
CheckAllowAdd(item I, count *huge.Int) error
// CheckDeductItem 检查是否允许扣除特定物品
CheckDeductItem(guid int64, count *huge.Int) error
// Remove 移除特定guid的物品
Remove(guid int64)
// RemoveWithID 移除所有物品ID匹配的物品
RemoveWithID(id ItemID)
// Clear 清空物品容器
Clear()
}

15
game/item_container_member.go
View File

@ -1,15 +0,0 @@
package game
import "github.com/kercylan98/minotaur/utils/huge"
// ItemContainerMember 物品容器成员信息
type ItemContainerMember[ItemID comparable, I Item[ItemID]] interface {
// GetID 获取物品ID
GetID() ItemID
// GetGUID 获取物品GUID
GetGUID() int64
// GetCount 获取物品数量
GetCount() *huge.Int
// GetItem 获取物品
GetItem() I
}