game

package
v0.0.14 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 13, 2023 License: MIT Imports: 6 Imported by: 0

Documentation

Overview

Package game 提供了通用游戏相关的接口和一组内置的实现。

主要特性：

  • 包 builtin 内提供了大量的常用游戏功能的内置实现，包括房间、状态机等。
  • 包 poker 内提供了用于处理扑克牌游戏的函数和数据结构。

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AOI2D 

type AOI2D interface {
	// AddEntity 添加对象
	AddEntity(entity AOIEntity2D)
	// DeleteEntity 移除对象
	DeleteEntity(entity AOIEntity2D)
	// Refresh 刷新对象焦点
	Refresh(entity AOIEntity2D)
	// GetFocus 获取对象焦点列表
	GetFocus(guid int64) map[int64]AOIEntity2D
	// SetSize 设置总区域大小
	//  - 将会导致区域的重新划分
	SetSize(width, height int)
	// SetAreaSize 设置区域大小
	//  - 将会导致区域的重新划分
	SetAreaSize(width, height int)

	// RegEntityJoinVisionEvent 在新对象进入视野时将会立刻执行被注册的事件处理函数
	RegEntityJoinVisionEvent(handle EntityJoinVisionEventHandle)
	OnEntityJoinVisionEvent(entity, target AOIEntity2D)
	// RegEntityLeaveVisionEvent 在对象离开视野时将会立刻执行被注册的事件处理函数
	RegEntityLeaveVisionEvent(handle EntityLeaveVisionEventHandle)
	OnEntityLeaveVisionEvent(entity, target AOIEntity2D)
}

AOI2D 基于2D定义的AOI功能接口

  • AOI（Area Of Interest）翻译过来叫感兴趣的区域，是大型多人在线的游戏服务器中一个非常重要的基础模块，用于游戏对象在场景中的视野管理
  • 透过 AOI 系统可以在其他玩家或怪物进入视野时得到感知，从而进行相应处理
  • 内置实现：builtin.AOI2D
  • 构建函数：builtin.NewAOI2D

type AOIEntity2D 

type AOIEntity2D interface {
	Actor
	Position2D
	// GetVision 获取视距
	GetVision() float64
}

AOIEntity2D 基于2D定义的AOI对象功能接口

  • AOI 对象提供了 AOI 系统中常用的属性，诸如位置坐标和视野范围等

type Actor 

type Actor interface {
	// SetGuid 设置对象的唯一标识符
	//  - 需要注意的是该函数不应该主动执行，否则可能产生意想不到的情况
	SetGuid(guid int64)
	// GetGuid 获取对象的唯一标识符
	GetGuid() int64
}

Actor 表示游戏中的可以放到游戏场景中的游戏对象的基本类型

  • 需要注意 Actor 不等于 Player
  • 在 Minotaur 中，每个网络连接可以表示一个 Player，而每个玩家可以拥有多个 Actor
  • Actor 并非 Player 独有，场景中也可包含各类无主的 Actor
  • 内置实现：builtin.Actor
  • 构建函数：builtin.NewActor

type ActorAnnihilationEventHandle 

type ActorAnnihilationEventHandle[ID comparable, P Player[ID]] func(world World[ID, P], actor Actor)

type ActorGeneratedEventHandle 

type ActorGeneratedEventHandle[ID comparable, P Player[ID]] func(world World[ID, P], actor Actor)

type ActorOwnerChangeEventHandle 

type ActorOwnerChangeEventHandle[ID comparable, P Player[ID]] func(world World[ID, P], actor Actor, old, new ID, isolated bool)

type AttrChangeEventHandle 

type AttrChangeEventHandle func(id int, attrs Attrs)

type Attrs 

type Attrs interface {
	SetAttrInt(id int, value int)
	SetAttrInt8(id int, value int8)
	SetAttrInt16(id int, value int16)
	SetAttrInt32(id int, value int32)
	SetAttrInt64(id int, value int64)
	SetAttrUint(id int, value uint)
	SetAttrUint8(id int, value uint8)
	SetAttrUint16(id int, value uint16)
	SetAttrUint32(id int, value uint32)
	SetAttrUint64(id int, value uint64)
	SetAttrFloat32(id int, value float32)
	SetAttrFloat64(id int, value float64)
	SetAttrHugeInt(id int, value *huge.Int)

	GetAttrInt(id int) int
	GetAttrInt8(id int) int8
	GetAttrInt16(id int) int16
	GetAttrInt32(id int) int32
	GetAttrInt64(id int) int64
	GetAttrUint(id int) uint
	GetAttrUint8(id int) uint8
	GetAttrUint16(id int) uint16
	GetAttrUint32(id int) uint32
	GetAttrUint64(id int) uint64
	GetAttrFloat32(id int) float32
	GetAttrFloat64(id int) float64
	GetAttrHugeInt(id int) *huge.Int

	ChangeAttrInt(id int, value int)
	ChangeAttrInt8(id int, value int8)
	ChangeAttrInt16(id int, value int16)
	ChangeAttrInt32(id int, value int32)
	ChangeAttrInt64(id int, value int64)
	ChangeAttrUint(id int, value uint)
	ChangeAttrUint8(id int, value uint8)
	ChangeAttrUint16(id int, value uint16)
	ChangeAttrUint32(id int, value uint32)
	ChangeAttrUint64(id int, value uint64)
	ChangeAttrFloat32(id int, value float32)
	ChangeAttrFloat64(id int, value float64)
	ChangeAttrHugeInt(id int, value *huge.Int)

	// RegAttrChangeEvent 任一属性发生变化将立即执行被注册的事件处理函数
	RegAttrChangeEvent(handle AttrChangeEventHandle)
	OnAttrChangeEvent(id int)
	// RegAttrIdChangeEvent 特定属性发生变化将立即执行被注册的事件处理函数
	RegAttrIdChangeEvent(id int, handle AttrChangeEventHandle)
	OnAttrIdChangeEvent(id int)
}

Attrs 游戏属性接口定义

  • 属性通常为直接读取配置，是否合理暂不清晰，目前不推荐使用

type EntityJoinVisionEventHandle 

type EntityJoinVisionEventHandle func(entity, target AOIEntity2D)

type EntityLeaveVisionEventHandle 

type EntityLeaveVisionEventHandle func(entity, target AOIEntity2D)

type FSM 

type FSM[State comparable, Data comparable] interface {
	// Update 执行当前状态行为
	Update()
	// Register 注册一个状态到当前状态机中
	Register(state FSMState[State, Data])
	// Unregister 取消一个状态的注册
	Unregister(state State)
	// HasState 检查是否某状态已注册
	HasState(state State) bool
	// Change 改变当前状态为输入的状态
	Change(state State)
}

FSM 有限状态机接口定义

  • 有限状态机（Finite State Machine，简称FSM），它将系统看做一系列状态，而每个状态都有其对应的行为和转换条件
  • 在游戏中，可以将各种游戏对象和游戏系统抽象为状态和转移，使用有限状态机来描述它们之间的关系，来实现游戏的逻辑和行为

使用场景

  • 角色行为控制：游戏角色的行为通常会根据不同状态来变化，例如走、跑、跳、攻击等。通过使用有限状态机来描述角色的状态和状态之间的转移，可以实现角色行为的流畅切换和控制
  • NPC行为控制：游戏中的 NPC 通常需要有一定的 AI 行为，例如巡逻、追击、攻击等。通过使用有限状态机来描述 NPC 的行为状态和转移条件，可以实现 NPC 行为的智能控制
  • 游戏流程控制：游戏的各个流程可以看做状态，例如登录、主界面、游戏场景等。通过使用有限状态机来描述游戏的流程状态和转移条件，可以实现游戏流程的控制和管理

在服务端中使用 FSM 可以使游戏状态管理更加清晰和简单，清晰各状态职责

  • 内置实现：builtin.FSM
  • 构建函数：builtin.NewFSM

type FSMState 

type FSMState[State comparable, Data any] interface {
	// GetState 获取当前状态
	GetState() State
	// Enter 状态开始行为
	Enter(data Data)
	// Update 当前状态行为
	Update(data Data)
	// Exit 状态退出行为
	Exit(data Data)
}

FSMState 有限状态机状态接口定义

  • 描述了 FSM 中的状态行为

需要一个可比较的状态类型及相应的数据类型，数据类型在无需使用时支持传入 nil

  • 内置实现：builtin.FSMState
  • 构建函数：builtin.NewFSMState

type FSMStateEnterHandle 

type FSMStateEnterHandle[Data any] func(data Data)

type FSMStateExitHandle 

type FSMStateExitHandle[Data any] func(data Data)

type FSMStateUpdateHandle 

type FSMStateUpdateHandle[Data any] func(data Data)

type Gameplay 

type Gameplay interface {
	// GameStart 游戏玩法开始
	GameStart(handle func() error) error
	// GetTime 获取游戏玩法的时间偏移
	GetTime() *offset.Time
	// GetCurrentTime 获取玩法当前存在偏移的时间
	GetCurrentTime() time.Time
	// SetTimeOffset 设置玩法时间偏移
	SetTimeOffset(offset time.Duration)
	// Release 释放游戏玩法资源
	Release()

	// RegGameplayStartEvent 在游戏玩法开始时将立即执行被注册的事件处理函数
	RegGameplayStartEvent(handle GameplayStartEventHandle)
	OnGameplayStartEvent()
	// RegGameplayTimeChangeEvent 游戏玩法的时间被改变（非自然流逝）时将立刻执行被注册的事件处理函数
	RegGameplayTimeChangeEvent(handle GameplayTimeChangeEventHandle)
	OnGameplayTimeChangeEvent()
	// RegGameplayReleaseEvent 游戏玩法资源被释放前将立即执行被注册的事件处理函数
	RegGameplayReleaseEvent(handle GameplayReleaseEventHandle)
	OnGameplayReleaseEvent()
}

Gameplay 游戏玩法

type GameplayOver 

type GameplayOver interface {
	// GameOver 游戏玩法结束
	GameOver()

	// RegGameplayOverEvent 游戏玩法结束时将立即调用被注册的事件处理函数
	RegGameplayOverEvent(handle GameplayOverEventHandle)
	OnGameplayOverEvent()
}

type GameplayOverEventHandle 

type GameplayOverEventHandle func()

type GameplayReleaseEventHandle 

type GameplayReleaseEventHandle func()

type GameplayStartEventHandle 

type GameplayStartEventHandle func(startTime time.Time)

type GameplayTime 

type GameplayTime interface {
	Gameplay
	GameplayOver
	// GetEndTime 获取游戏结束时间
	GetEndTime() time.Time
	// SetEndTime 设置游戏结束时间
	SetEndTime(t time.Time)
	// ChangeEndTime 通过相对时间的方式改变游戏结束时间
	ChangeEndTime(d time.Duration)
	// Release 释放资源
	Release()
}

GameplayTime 为游戏玩法添加游戏时长的特性

type GameplayTimeChangeEventHandle 

type GameplayTimeChangeEventHandle func(current time.Time)

type Item 

type Item[ID comparable] interface {
	// GetID 获取物品ID
	GetID() ID
	// IsSame 与另一个物品比较是否相同
	IsSame(item Item[ID]) bool
}

type 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()
}

ItemContainer 物品容器

type ItemContainerMember 

type ItemContainerMember[ItemID comparable, I Item[ItemID]] interface {
	// GetID 获取物品ID
	GetID() ItemID
	// GetGUID 获取物品GUID
	GetGUID() int64
	// GetCount 获取物品数量
	GetCount() *huge.Int
	// GetItem 获取物品
	GetItem() I
}

ItemContainerMember 物品容器成员信息

type Player 

type Player[ID comparable] interface {
	// GetID 获取玩家ID
	GetID() ID
	// UseConn 指定连接
	UseConn(conn *server.Conn)
	// Close 关闭玩家并且释放其资源
	Close()
}

Player 玩家

type PlayerJoinRoomEventHandle 

type PlayerJoinRoomEventHandle[ID comparable, P Player[ID]] func(room Room[ID, P], player P)

type PlayerJoinWorldEventHandle 

type PlayerJoinWorldEventHandle[ID comparable, P Player[ID]] func(world World[ID, P], player P)

type PlayerKickedOutEventHandle 

type PlayerKickedOutEventHandle[ID comparable, P Player[ID]] func(room Room[ID, P], executor, kicked ID, reason string)

type PlayerLeaveRoomEventHandle 

type PlayerLeaveRoomEventHandle[ID comparable, P Player[ID]] func(room Room[ID, P], player P)

type PlayerLeaveWorldEventHandle 

type PlayerLeaveWorldEventHandle[ID comparable, P Player[ID]] func(world World[ID, P], player P)

type Position2D 

type Position2D interface {
	// GetPosition 获取对象位置
	GetPosition() (x, y float64)
}

Position2D 2D位置接口定义

type Position2DSet 

type Position2DSet interface {
	SetPosition(x, y float64)
}

Position2DSet 2D位置设置接口定义

type Position3D 

type Position3D interface {
	GetPosition() (x, y, z float64)
}

type RankChangeEventHandle 

type RankChangeEventHandle[CompetitorID comparable, Score generic.Ordered] func(rankingList RankingList[CompetitorID, Score], competitorId CompetitorID, oldRank, newRank int, oldScore, newScore Score)

type RankClearBeforeEventHandle 

type RankClearBeforeEventHandle[CompetitorID comparable, Score generic.Ordered] func(rankingList RankingList[CompetitorID, Score])

type RankingList 

type RankingList[CompetitorID comparable, Score generic.Ordered] interface {
	// Competitor 声明排行榜竞争者
	//  - 如果竞争者存在的情况下，会更新已有成绩，否则新增竞争者
	Competitor(competitorId CompetitorID, score Score)
	// RemoveCompetitor 删除特定竞争者
	RemoveCompetitor(competitorId CompetitorID)
	// Size 获取竞争者数量
	Size() int
	// GetRank 获取竞争者排名
	//  - 排名从 0 开始
	GetRank(competitorId CompetitorID) (int, error)
	// GetCompetitor 获取特定排名的竞争者
	GetCompetitor(rank int) (CompetitorID, error)
	// GetCompetitorWithRange 获取第start名到第end名竞争者
	GetCompetitorWithRange(start, end int) ([]CompetitorID, error)
	// GetScore 获取竞争者成绩
	GetScore(competitorId CompetitorID) (Score, error)
	// GetAllCompetitor 获取所有竞争者ID
	//  - 结果为名次有序的
	GetAllCompetitor() []CompetitorID
	// Clear 清空排行榜
	Clear()

	// RegRankChangeEvent 排名改变时将立即执行注册的事件处理函数
	//  - 排名为-1时表示未上榜
	RegRankChangeEvent(handle RankChangeEventHandle[CompetitorID, Score])
	OnRankChangeEvent(competitorId CompetitorID, oldRank, newRank int, oldScore, newScore Score)
	// RegRankClearBeforeEvent 在排行榜被清空前执行被注册的事件处理函数
	RegRankClearBeforeEvent(handle RankClearBeforeEventHandle[CompetitorID, Score])
	OnRankClearBeforeEvent()
}

RankingList 排行榜

type Room 

type Room[PlayerID comparable, P Player[PlayerID]] interface {
	// GetGuid 获取房间的唯一标识符
	GetGuid() int64
	// GetPlayerLimit 获取玩家人数上限
	GetPlayerLimit() int
	// GetPlayer 根据玩家id获取玩家
	GetPlayer(id PlayerID) P
	// GetPlayers 获取房间中的所有玩家
	GetPlayers() hash.MapReadonly[PlayerID, P]
	// GetPlayerCount 获取玩家数量
	GetPlayerCount() int
	// IsExistPlayer 检查房间中是否存在特定玩家
	IsExistPlayer(id PlayerID) bool
	// IsOwner 检查玩家是否是房主
	IsOwner(id PlayerID) bool
	// ChangeOwner 设置玩家为房主
	ChangeOwner(id PlayerID)

	// Join 使特定玩家加入房间
	Join(player P) error
	// Leave 使特定玩家离开房间
	Leave(id PlayerID)
	// KickOut 将特定玩家踢出房间
	KickOut(id, target PlayerID, reason string) error

	// RegPlayerJoinRoomEvent 玩家进入房间时将立即执行被注册的事件处理函数
	RegPlayerJoinRoomEvent(handle PlayerJoinRoomEventHandle[PlayerID, P])
	OnPlayerJoinRoomEvent(player P)
	// RegPlayerLeaveRoomEvent 玩家离开房间时将立即执行被注册的事件处理函数
	RegPlayerLeaveRoomEvent(handle PlayerLeaveRoomEventHandle[PlayerID, P])
	OnPlayerLeaveRoomEvent(player P)
	// RegPlayerKickedOutEvent 当玩家被踢出游戏时将立即执行被注册的事件处理函数
	RegPlayerKickedOutEvent(handle PlayerKickedOutEventHandle[PlayerID, P])
	OnPlayerKickedOutEvent(executor, kicked PlayerID, reason string)
}

Room 房间类似于简版的游戏世界(World)，不过没有游戏实体

type RoomSeat 

type RoomSeat[PlayerID comparable, P Player[PlayerID]] interface {
	Room[PlayerID, P]
	// AddSeat 将玩家添加到座位号中
	AddSeat(id PlayerID)
	// AddSeatWithAssign 将玩家添加到座位号中，并分配特定的座位号
	AddSeatWithAssign(id PlayerID, seat int)
	// RemovePlayerSeat 移除玩家的座位号
	RemovePlayerSeat(id PlayerID)
	// RemoveSeat 移除特定座位号
	RemoveSeat(seat int)
	// SetSeat 设置玩家座位号，当玩家没有座位号时，将会返回错误信息
	//  - 如果座位号有其他玩家，他们的位置将互换
	SetSeat(id PlayerID, seat int) error
	// GetSeat 获取玩家座位号
	GetSeat(id PlayerID) (int, error)
	// GetPlayerIDWithSeat 根据座位号获取玩家ID
	GetPlayerIDWithSeat(seat int) (PlayerID, error)
	// GetSeatInfo 获取座位信息，空缺的位置将为空
	GetSeatInfo() []*PlayerID
	// GetSeatInfoMap 以map的方式获取座位号
	GetSeatInfoMap() map[int]PlayerID
	// GetSeatInfoMapVacancy 以map的方式获取座位号，空缺的位置将被保留为nil
	GetSeatInfoMapVacancy() map[int]*PlayerID
	// GetSeatInfoWithPlayerIDMap 获取座位信息，将以玩家ID作为key
	GetSeatInfoWithPlayerIDMap() map[PlayerID]int
	// GetFirstSeat 获取第一个非空缺座位号，不存在时将返回-1
	GetFirstSeat() int
	// GetNextSeat 获取下一个座位号，空缺的位置将会被跳过
	//  - 超出范围将返回-1
	//  - 当没有下一个座位号时将始终返回本身
	GetNextSeat(seat int) int
	// GetNextSeatVacancy 获取下一个座位号，空缺的位置将被保留
	//  - 超出范围将返回-1
	//  - 当没有下一个座位号时将始终返回本身
	GetNextSeatVacancy(seat int) int
}

RoomSeat 带有座位号的房间实现

type Terrain2D 

type Terrain2D interface {
	GetBlock(x, y int) Terrain2DBlock
	GetBlocks() [][]Terrain2DBlock
	GetWidth() int
	GetHeight() int
}

Terrain2D 地形

type Terrain2DBlock 

type Terrain2DBlock interface {
	// GetTerrain 获取归属的地形
	GetTerrain() Terrain2D
	// GetCost 获取移动消耗
	GetCost() float64
}

Terrain2DBlock 地形块

type World 

type World[PlayerID comparable, P Player[PlayerID]] interface {
	// GetGuid 获取世界的唯一标识符
	GetGuid() int64
	// GetPlayerLimit 获取玩家人数上限
	GetPlayerLimit() int
	// GetPlayer 根据玩家id获取玩家
	GetPlayer(id PlayerID) P
	// GetPlayers 获取世界中的所有玩家
	GetPlayers() hash.MapReadonly[PlayerID, P]
	// GetActor 根据唯一标识符获取世界中的游戏对象
	GetActor(guid int64) Actor
	// GetActors 获取世界中的所有游戏对象
	GetActors() hash.MapReadonly[int64, Actor]
	// GetPlayerActor 获取游戏世界中归属特定玩家的特定游戏对象
	GetPlayerActor(id PlayerID, guid int64) Actor
	// GetPlayerActors 获取游戏世界中归属特定玩家的所有游戏对象
	GetPlayerActors(id PlayerID) hash.MapReadonly[int64, Actor]
	// IsExistPlayer 检查游戏世界中是否存在特定玩家
	IsExistPlayer(id PlayerID) bool
	// IsExistActor 检查游戏世界中是否存在特定游戏对象
	IsExistActor(guid int64) bool
	// IsOwner 检查游戏世界中的特定游戏对象是否归属特定玩家
	IsOwner(id PlayerID, guid int64) bool

	// Join 使特定玩家加入游戏世界
	Join(player P) error
	// Leave 使特定玩家离开游戏世界
	Leave(id PlayerID)

	// AddActor 添加游戏对象
	AddActor(actor Actor)
	// RemoveActor 移除游戏对象
	RemoveActor(guid int64)
	// SetActorOwner 设置游戏对象归属玩家
	SetActorOwner(guid int64, id PlayerID)
	// RemoveActorOwner 移除游戏对象归属，置为无主的
	RemoveActorOwner(guid int64)

	// Reset 重置世界资源
	Reset()
	// Release 释放世界资源，释放后世界将不可用
	Release()

	// RegWorldResetEvent 世界被重置后将立即执行被注册的事件处理函数
	RegWorldResetEvent(handle WorldResetEventHandle[PlayerID, P])
	OnWorldResetEvent()
	// RegWorldReleaseEvent 世界被释放前将立即执行被注册的事件处理函数，此刻世界仍然可用
	RegWorldReleaseEvent(handle WorldReleaseEventHandle[PlayerID, P])
	OnWorldReleaseEvent()
	// RegPlayerJoinWorldEvent 玩家进入世界时将立即执行被注册的事件处理函数
	RegPlayerJoinWorldEvent(handle PlayerJoinWorldEventHandle[PlayerID, P])
	OnPlayerJoinWorldEvent(player P)
	// RegPlayerLeaveWorldEvent 玩家离开世界时将立即执行被注册的事件处理函数
	RegPlayerLeaveWorldEvent(handle PlayerLeaveWorldEventHandle[PlayerID, P])
	OnPlayerLeaveWorldEvent(player P)
	// RegActorGeneratedEvent 游戏世界中的游戏对象生成完成时将立即执行被注册的事件处理函数
	RegActorGeneratedEvent(handle ActorGeneratedEventHandle[PlayerID, P])
	OnActorGeneratedEvent(actor Actor)
	// RegActorAnnihilationEvent 游戏世界中的游戏对象被移除前执行被注册的事件处理函数
	RegActorAnnihilationEvent(handle ActorAnnihilationEventHandle[PlayerID, P])
	OnActorAnnihilationEvent(actor Actor)
	// RegActorOwnerChangeEvent 游戏对象的归属被改变时立刻执行被注册的事件处理函数
	RegActorOwnerChangeEvent(handle ActorOwnerChangeEventHandle[PlayerID, P])
	OnActorOwnerChangeEvent(actor Actor, old, new PlayerID, isolated bool)
}

World 游戏世界接口定义

type WorldReleaseEventHandle 

type WorldReleaseEventHandle[ID comparable, P Player[ID]] func(world World[ID, P])

type WorldResetEventHandle 

type WorldResetEventHandle[ID comparable, P Player[ID]] func(world World[ID, P])

Source Files

View all Source files

Directories

Path Synopsis
Package builtin 包含了通用游戏相关的接口的内置实现
 Package builtin 包含了通用游戏相关的接口的内置实现
Package poker 提供了一组用于处理扑克牌游戏的函数和数据结构。
 Package poker 提供了一组用于处理扑克牌游戏的函数和数据结构。

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.