924 lines
22 KiB
Go
924 lines
22 KiB
Go
package sprite
|
||
|
||
import (
|
||
"image"
|
||
"image/color/palette"
|
||
"image/draw"
|
||
"image/gif"
|
||
"image/png"
|
||
"log"
|
||
"os"
|
||
"sort"
|
||
)
|
||
|
||
// 设置为true启用调试日志
|
||
var debugLog = false
|
||
|
||
func logDebug(format string, args ...interface{}) {
|
||
if debugLog {
|
||
log.Printf(format, args...)
|
||
}
|
||
}
|
||
|
||
// SpriteIndexNode 表示同一个Index下的精灵链表节点
|
||
type SpriteIndexNode struct {
|
||
Sprite *Sprite
|
||
Next *SpriteIndexNode // 指向同一Index下的下一个精灵
|
||
}
|
||
|
||
// IndexGroup 表示一个索引组，包含所有具有相同Index的精灵
|
||
type IndexGroup struct {
|
||
Index int
|
||
Head *SpriteIndexNode // 指向第一个精灵
|
||
Count int // 该组中精灵数量
|
||
Next *IndexGroup // 指向下一个索引组
|
||
Prev *IndexGroup // 指向上一个索引组
|
||
}
|
||
|
||
// NamedSpriteBoard 提供按名称哈希查找，按索引排序的精灵图管理
|
||
type NamedSpriteBoard struct {
|
||
Sprites []*Sprite
|
||
// nameMap 用于O(1)的按名称查找，键为Name，值为精灵指针
|
||
nameMap map[string]*Sprite
|
||
// indexGroups 按Index排序的索引组链表
|
||
indexHead *IndexGroup // 索引组链表头
|
||
indexTail *IndexGroup // 索引组链表尾
|
||
// 索引组的映射表，用于O(1)按索引查找索引组
|
||
indexMap map[int]*IndexGroup
|
||
// 总精灵数量
|
||
count int
|
||
}
|
||
|
||
// NewNamedSpriteBoard 创建一个新的NamedSpriteBoard
|
||
func NewNamedSpriteBoard() *NamedSpriteBoard {
|
||
return &NamedSpriteBoard{
|
||
Sprites: make([]*Sprite, 0),
|
||
nameMap: make(map[string]*Sprite),
|
||
indexMap: make(map[int]*IndexGroup),
|
||
indexHead: nil,
|
||
indexTail: nil,
|
||
count: 0,
|
||
}
|
||
}
|
||
|
||
// AddSprite 添加精灵，O(1)时间复杂度查找，O(logn)插入
|
||
func (b *NamedSpriteBoard) AddSprite(sprite *Sprite) {
|
||
// 必须有名称
|
||
if sprite.Name == "" {
|
||
return
|
||
}
|
||
|
||
// 如果已存在同名精灵，先移除
|
||
if _, exists := b.nameMap[sprite.Name]; exists {
|
||
b.RemoveSpriteByName(sprite.Name)
|
||
}
|
||
|
||
// 将精灵添加到名称映射
|
||
b.nameMap[sprite.Name] = sprite
|
||
|
||
// 查找或创建索引组
|
||
indexGroup, exists := b.indexMap[sprite.Index]
|
||
if !exists {
|
||
// 创建新的索引组
|
||
indexGroup = &IndexGroup{
|
||
Index: sprite.Index,
|
||
Head: nil,
|
||
Count: 0,
|
||
Next: nil,
|
||
Prev: nil,
|
||
}
|
||
|
||
// 将索引组添加到映射表
|
||
b.indexMap[sprite.Index] = indexGroup
|
||
|
||
// 插入到索引组链表中的正确位置
|
||
b.insertIndexGroup(indexGroup)
|
||
}
|
||
|
||
// 创建新的精灵节点
|
||
newNode := &SpriteIndexNode{
|
||
Sprite: sprite,
|
||
Next: nil,
|
||
}
|
||
|
||
// 在索引组中按名称排序插入
|
||
b.insertSpriteToGroup(indexGroup, newNode)
|
||
|
||
// 更新计数
|
||
indexGroup.Count++
|
||
b.count++
|
||
|
||
// 更新兼容层
|
||
b.updateSpriteArray()
|
||
}
|
||
|
||
// insertIndexGroup 将索引组插入到正确的位置，O(logn)时间复杂度
|
||
func (b *NamedSpriteBoard) insertIndexGroup(group *IndexGroup) {
|
||
// 如果是第一个索引组
|
||
if b.indexHead == nil {
|
||
b.indexHead = group
|
||
b.indexTail = group
|
||
return
|
||
}
|
||
|
||
// 如果应该插入到头部
|
||
if group.Index < b.indexHead.Index {
|
||
group.Next = b.indexHead
|
||
b.indexHead.Prev = group
|
||
b.indexHead = group
|
||
return
|
||
}
|
||
|
||
// 如果应该插入到尾部
|
||
if group.Index > b.indexTail.Index {
|
||
group.Prev = b.indexTail
|
||
b.indexTail.Next = group
|
||
b.indexTail = group
|
||
return
|
||
}
|
||
|
||
// 找到插入位置 - 将链表的元素放入数组进行二分查找
|
||
groups := make([]*IndexGroup, 0)
|
||
current := b.indexHead
|
||
for current != nil {
|
||
groups = append(groups, current)
|
||
current = current.Next
|
||
}
|
||
|
||
// 二分查找插入位置
|
||
insertPos := sort.Search(len(groups), func(i int) bool {
|
||
return groups[i].Index >= group.Index
|
||
})
|
||
|
||
// 插入到找到的位置之前
|
||
prevGroup := groups[insertPos-1]
|
||
nextGroup := groups[insertPos]
|
||
|
||
group.Next = nextGroup
|
||
group.Prev = prevGroup
|
||
prevGroup.Next = group
|
||
nextGroup.Prev = group
|
||
}
|
||
|
||
// insertSpriteToGroup 将精灵节点按名称排序插入到索引组，O(n)时间复杂度
|
||
// 由于同一个Index下的精灵数量通常不多，所以使用简单的插入排序
|
||
func (b *NamedSpriteBoard) insertSpriteToGroup(group *IndexGroup, node *SpriteIndexNode) {
|
||
// 如果索引组为空
|
||
if group.Head == nil {
|
||
group.Head = node
|
||
return
|
||
}
|
||
|
||
// 如果应该插入到头部
|
||
if node.Sprite.Name < group.Head.Sprite.Name {
|
||
node.Next = group.Head
|
||
group.Head = node
|
||
return
|
||
}
|
||
|
||
// 查找插入位置
|
||
current := group.Head
|
||
for current.Next != nil && current.Next.Sprite.Name < node.Sprite.Name {
|
||
current = current.Next
|
||
}
|
||
|
||
// 插入节点
|
||
node.Next = current.Next
|
||
current.Next = node
|
||
}
|
||
|
||
// GetSpriteByName 通过名称获取精灵，O(1)时间复杂度
|
||
func (b *NamedSpriteBoard) GetSpriteByName(name string) *Sprite {
|
||
sprite, exists := b.nameMap[name]
|
||
if exists {
|
||
return sprite
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// GetSpritesByIndex 获取具有特定索引的所有精灵，O(1)查找 + O(n)收集
|
||
func (b *NamedSpriteBoard) GetSpritesByIndex(index int) []*Sprite {
|
||
group, exists := b.indexMap[index]
|
||
if !exists {
|
||
return nil
|
||
}
|
||
|
||
sprites := make([]*Sprite, 0, group.Count)
|
||
current := group.Head
|
||
for current != nil {
|
||
sprites = append(sprites, current.Sprite)
|
||
current = current.Next
|
||
}
|
||
|
||
return sprites
|
||
}
|
||
|
||
// RemoveSpriteByName 通过名称删除精灵，O(1)查找 + O(n)删除
|
||
func (b *NamedSpriteBoard) RemoveSpriteByName(name string) bool {
|
||
sprite, exists := b.nameMap[name]
|
||
if !exists {
|
||
return false
|
||
}
|
||
|
||
// 从名称映射中移除
|
||
delete(b.nameMap, name)
|
||
|
||
// 查找对应的索引组
|
||
group := b.indexMap[sprite.Index]
|
||
if group == nil {
|
||
return false
|
||
}
|
||
|
||
// 从索引组中移除精灵
|
||
removed := b.removeSpriteFromGroup(group, name)
|
||
if !removed {
|
||
return false
|
||
}
|
||
|
||
// 如果索引组变为空，则删除该索引组
|
||
if group.Count == 0 {
|
||
b.removeIndexGroup(group)
|
||
}
|
||
|
||
// 更新计数
|
||
b.count--
|
||
|
||
// 更新兼容层
|
||
b.updateSpriteArray()
|
||
|
||
return true
|
||
}
|
||
|
||
// removeSpriteFromGroup 从索引组中移除指定名称的精灵，O(n)时间复杂度
|
||
func (b *NamedSpriteBoard) removeSpriteFromGroup(group *IndexGroup, name string) bool {
|
||
logDebug("removeSpriteFromGroup: 尝试从索引组 %d 中移除精灵 %s", group.Index, name)
|
||
|
||
// 如果索引组为空
|
||
if group.Head == nil {
|
||
logDebug("removeSpriteFromGroup: 索引组为空")
|
||
return false
|
||
}
|
||
|
||
// 如果是头节点
|
||
if group.Head.Sprite.Name == name {
|
||
logDebug("removeSpriteFromGroup: 移除头节点 %s", name)
|
||
group.Head = group.Head.Next
|
||
group.Count--
|
||
return true
|
||
}
|
||
|
||
// 查找节点
|
||
current := group.Head
|
||
for current.Next != nil && current.Next.Sprite.Name != name {
|
||
logDebug("removeSpriteFromGroup: 检查节点 %s", current.Next.Sprite.Name)
|
||
current = current.Next
|
||
}
|
||
|
||
// 如果找到了节点
|
||
if current.Next != nil {
|
||
logDebug("removeSpriteFromGroup: 找到并移除节点 %s", name)
|
||
current.Next = current.Next.Next
|
||
group.Count--
|
||
return true
|
||
}
|
||
|
||
logDebug("removeSpriteFromGroup: 未找到节点 %s", name)
|
||
return false
|
||
}
|
||
|
||
// removeIndexGroup 从索引组链表中移除索引组，O(1)时间复杂度
|
||
func (b *NamedSpriteBoard) removeIndexGroup(group *IndexGroup) {
|
||
// 从索引映射表中移除
|
||
delete(b.indexMap, group.Index)
|
||
|
||
// 从链表中移除
|
||
if group.Prev != nil {
|
||
group.Prev.Next = group.Next
|
||
} else {
|
||
b.indexHead = group.Next // 头节点变更
|
||
}
|
||
|
||
if group.Next != nil {
|
||
group.Next.Prev = group.Prev
|
||
} else {
|
||
b.indexTail = group.Prev // 尾节点变更
|
||
}
|
||
}
|
||
|
||
// UpdateSpriteIndex 更新精灵的索引，O(1)查找 + O(logn)插入
|
||
func (b *NamedSpriteBoard) UpdateSpriteIndex(name string, newIndex int) bool {
|
||
sprite, exists := b.nameMap[name]
|
||
if !exists {
|
||
return false
|
||
}
|
||
|
||
// 保存旧索引
|
||
oldIndex := sprite.Index
|
||
|
||
// 从旧索引组中移除
|
||
oldGroup := b.indexMap[oldIndex]
|
||
if oldGroup == nil {
|
||
return false
|
||
}
|
||
|
||
if !b.removeSpriteFromGroup(oldGroup, name) {
|
||
return false
|
||
}
|
||
|
||
// 如果旧索引组变为空，则删除
|
||
if oldGroup.Count == 0 {
|
||
b.removeIndexGroup(oldGroup)
|
||
}
|
||
|
||
// 更新精灵的索引
|
||
sprite.Index = newIndex
|
||
|
||
// 查找或创建新索引组
|
||
newGroup, exists := b.indexMap[newIndex]
|
||
if !exists {
|
||
// 创建新的索引组
|
||
newGroup = &IndexGroup{
|
||
Index: newIndex,
|
||
Head: nil,
|
||
Count: 0,
|
||
Next: nil,
|
||
Prev: nil,
|
||
}
|
||
|
||
// 将索引组添加到映射表
|
||
b.indexMap[newIndex] = newGroup
|
||
|
||
// 插入到索引组链表中的正确位置
|
||
b.insertIndexGroup(newGroup)
|
||
}
|
||
|
||
// 创建新的精灵节点
|
||
newNode := &SpriteIndexNode{
|
||
Sprite: sprite,
|
||
Next: nil,
|
||
}
|
||
|
||
// 在新索引组中按名称排序插入
|
||
b.insertSpriteToGroup(newGroup, newNode)
|
||
newGroup.Count++
|
||
|
||
// 更新兼容层
|
||
b.updateSpriteArray()
|
||
|
||
return true
|
||
}
|
||
|
||
// UpdateSpriteName 更新精灵的名称，O(1)查找 + O(n)插入
|
||
func (b *NamedSpriteBoard) UpdateSpriteName(oldName, newName string) bool {
|
||
logDebug("UpdateSpriteName: 尝试将 %s 更新为 %s", oldName, newName)
|
||
sprite, exists := b.nameMap[oldName]
|
||
if !exists {
|
||
logDebug("UpdateSpriteName: 未找到精灵 %s", oldName)
|
||
return false
|
||
}
|
||
|
||
// 检查新名称是否已存在
|
||
if _, exists := b.nameMap[newName]; exists && newName != oldName {
|
||
logDebug("UpdateSpriteName: 新名称 %s 已存在", newName)
|
||
return false
|
||
}
|
||
|
||
// 保存索引
|
||
index := sprite.Index
|
||
logDebug("UpdateSpriteName: 精灵索引为 %d", index)
|
||
|
||
// 从索引组中移除再添加，以保持排序
|
||
group := b.indexMap[index]
|
||
if group == nil {
|
||
logDebug("UpdateSpriteName: 未找到索引组 %d", index)
|
||
return false
|
||
}
|
||
|
||
logDebug("UpdateSpriteName: 在索引组 %d 中查找名称 %s", index, oldName)
|
||
// 调试输出当前索引组的所有精灵
|
||
current := group.Head
|
||
i := 0
|
||
for current != nil {
|
||
logDebug("UpdateSpriteName: 索引组精灵[%d]: %s", i, current.Sprite.Name)
|
||
current = current.Next
|
||
i++
|
||
}
|
||
|
||
// 从索引组链表中删除节点
|
||
if !b.removeSpriteFromGroup(group, oldName) {
|
||
logDebug("UpdateSpriteName: 从索引组中移除精灵 %s 失败", oldName)
|
||
return false
|
||
}
|
||
|
||
// 从名称映射中移除旧名称
|
||
delete(b.nameMap, oldName)
|
||
|
||
// 更新精灵名称
|
||
sprite.Name = newName
|
||
|
||
// 添加到新名称映射
|
||
b.nameMap[newName] = sprite
|
||
|
||
// 创建新节点并添加回索引组
|
||
newNode := &SpriteIndexNode{
|
||
Sprite: sprite,
|
||
Next: nil,
|
||
}
|
||
b.insertSpriteToGroup(group, newNode)
|
||
group.Count++ // 增加计数，因为removeSpriteFromGroup已经减少了计数
|
||
|
||
// 更新兼容层
|
||
b.updateSpriteArray()
|
||
logDebug("UpdateSpriteName: 成功更新名称从 %s 到 %s", oldName, newName)
|
||
|
||
return true
|
||
}
|
||
|
||
// GetAllSprites 获取所有精灵，按Index主排序，Name次排序
|
||
func (b *NamedSpriteBoard) GetAllSprites() []*Sprite {
|
||
sprites := make([]*Sprite, 0, b.count)
|
||
|
||
// 遍历所有索引组
|
||
currentGroup := b.indexHead
|
||
for currentGroup != nil {
|
||
// 遍历当前索引组中的所有精灵
|
||
currentNode := currentGroup.Head
|
||
for currentNode != nil {
|
||
sprites = append(sprites, currentNode.Sprite)
|
||
currentNode = currentNode.Next
|
||
}
|
||
currentGroup = currentGroup.Next
|
||
}
|
||
|
||
return sprites
|
||
}
|
||
|
||
// updateSpriteArray 更新BaseBoard中的Sprites数组以保持兼容性
|
||
func (b *NamedSpriteBoard) updateSpriteArray() {
|
||
b.Sprites = b.GetAllSprites()
|
||
}
|
||
|
||
// RenderToImage 将精灵板渲染为图像
|
||
func (b *NamedSpriteBoard) RenderToImage() *image.RGBA {
|
||
// 计算所有精灵图覆盖的最大区域
|
||
var minX, minY, maxX, maxY int
|
||
|
||
// 初始化为最大/最小可能值，以便于后续比较
|
||
initialized := false
|
||
|
||
// 遍历所有精灵计算边界
|
||
currentGroup := b.indexHead
|
||
for currentGroup != nil {
|
||
currentNode := currentGroup.Head
|
||
for currentNode != nil {
|
||
sprite := currentNode.Sprite
|
||
currentImage := sprite.GetCurrentImage()
|
||
if currentImage != nil {
|
||
srcBounds := currentImage.Bounds()
|
||
spriteMinX := sprite.Position.X
|
||
spriteMinY := sprite.Position.Y
|
||
spriteMaxX := sprite.Position.X + srcBounds.Dx()
|
||
spriteMaxY := sprite.Position.Y + srcBounds.Dy()
|
||
|
||
// 首次初始化边界值或更新边界
|
||
if !initialized {
|
||
minX, minY = spriteMinX, spriteMinY
|
||
maxX, maxY = spriteMaxX, spriteMaxY
|
||
initialized = true
|
||
} else {
|
||
// 更新边界值
|
||
if spriteMinX < minX {
|
||
minX = spriteMinX
|
||
}
|
||
if spriteMinY < minY {
|
||
minY = spriteMinY
|
||
}
|
||
if spriteMaxX > maxX {
|
||
maxX = spriteMaxX
|
||
}
|
||
if spriteMaxY > maxY {
|
||
maxY = spriteMaxY
|
||
}
|
||
}
|
||
}
|
||
currentNode = currentNode.Next
|
||
}
|
||
currentGroup = currentGroup.Next
|
||
}
|
||
|
||
// 如果没有精灵图，则使用默认大小
|
||
if !initialized {
|
||
minX, minY = 0, 0
|
||
maxX, maxY = 1, 1
|
||
}
|
||
|
||
// 确保有最小尺寸
|
||
if maxX <= minX {
|
||
maxX = minX + 1
|
||
}
|
||
if maxY <= minY {
|
||
maxY = minY + 1
|
||
}
|
||
|
||
// 计算画布尺寸，保留负坐标空间
|
||
width := maxX - minX
|
||
height := maxY - minY
|
||
|
||
// 创建画布，大小由精灵图决定
|
||
img := image.NewRGBA(image.Rect(0, 0, width, height))
|
||
|
||
// 按索引排序遍历所有精灵组
|
||
currentGroup = b.indexHead
|
||
for currentGroup != nil {
|
||
currentNode := currentGroup.Head
|
||
for currentNode != nil {
|
||
sprite := currentNode.Sprite
|
||
currentImage := sprite.GetCurrentImage()
|
||
if currentImage != nil {
|
||
// 获取精灵的边界
|
||
srcBounds := currentImage.Bounds()
|
||
|
||
// 计算原始目标区域（相对于minX, minY偏移）
|
||
dstMinX := sprite.Position.X - minX
|
||
dstMinY := sprite.Position.Y - minY
|
||
dstMaxX := dstMinX + srcBounds.Dx()
|
||
dstMaxY := dstMinY + srcBounds.Dy()
|
||
|
||
// 计算源图像的裁剪区域（如果精灵部分在画布外）
|
||
srcMinX := srcBounds.Min.X
|
||
srcMinY := srcBounds.Min.Y
|
||
|
||
// 处理左边界超出
|
||
if dstMinX < 0 {
|
||
srcMinX -= dstMinX // 向右移动源图像起点
|
||
dstMinX = 0
|
||
}
|
||
|
||
// 处理上边界超出
|
||
if dstMinY < 0 {
|
||
srcMinY -= dstMinY // 向下移动源图像起点
|
||
dstMinY = 0
|
||
}
|
||
|
||
// 处理右边界超出
|
||
if dstMaxX > width {
|
||
dstMaxX = width
|
||
}
|
||
|
||
// 处理下边界超出
|
||
if dstMaxY > height {
|
||
dstMaxY = height
|
||
}
|
||
|
||
// 如果裁剪后的区域有效（宽度和高度都大于0）
|
||
if dstMinX < dstMaxX && dstMinY < dstMaxY {
|
||
dstRect := image.Rect(dstMinX, dstMinY, dstMaxX, dstMaxY)
|
||
srcPt := image.Point{X: srcMinX, Y: srcMinY}
|
||
|
||
// 绘制裁剪后的精灵到画布上
|
||
draw.Draw(img, dstRect, currentImage, srcPt, draw.Over)
|
||
}
|
||
}
|
||
|
||
// 移动到下一个精灵
|
||
currentNode = currentNode.Next
|
||
}
|
||
|
||
// 移动到下一个索引组
|
||
currentGroup = currentGroup.Next
|
||
}
|
||
|
||
return img
|
||
}
|
||
|
||
func (b *NamedSpriteBoard) RenderToAnimatedImage() (img []*image.RGBA, delays []int) {
|
||
// 查找所有精灵的最大总时间
|
||
maxTotalTime := 0
|
||
|
||
// 遍历所有精灵查找最大总时间
|
||
currentGroup := b.indexHead
|
||
for currentGroup != nil {
|
||
currentNode := currentGroup.Head
|
||
for currentNode != nil {
|
||
sprite := currentNode.Sprite
|
||
if sprite.FrameCount() > 1 && len(sprite.Delay) > 0 {
|
||
totalTime := sprite.GetTotalTime()
|
||
if totalTime > maxTotalTime {
|
||
maxTotalTime = totalTime
|
||
}
|
||
}
|
||
currentNode = currentNode.Next
|
||
}
|
||
currentGroup = currentGroup.Next
|
||
}
|
||
|
||
// 如果没有动画精灵，返回单帧
|
||
if maxTotalTime == 0 {
|
||
// 渲染一个静态帧
|
||
staticFrame := b.RenderToImage()
|
||
return []*image.RGBA{staticFrame}, []int{10} // 默认延迟100ms
|
||
}
|
||
|
||
// 获取画布边界
|
||
minX, minY, maxX, maxY := b.GetRenderBounds()
|
||
width := maxX - minX
|
||
height := maxY - minY
|
||
|
||
// 初始化结果数组
|
||
img = make([]*image.RGBA, 0)
|
||
delays = make([]int, 0)
|
||
|
||
// 跟踪每个精灵的当前帧索引
|
||
spriteCurrentFrames := make(map[*Sprite]int)
|
||
|
||
// 需要检查的时间点列表 - 初始包含所有精灵的帧变化时间点
|
||
timePoints := make([]int, 0)
|
||
timePoints = append(timePoints, 0) // 起始点
|
||
|
||
// 收集所有精灵的帧变化时间点
|
||
currentGroup = b.indexHead
|
||
for currentGroup != nil {
|
||
currentNode := currentGroup.Head
|
||
for currentNode != nil {
|
||
sprite := currentNode.Sprite
|
||
if sprite.FrameCount() > 1 && len(sprite.Delay) > 0 {
|
||
// 添加每个延迟增量点
|
||
timePoints = append(timePoints, sprite.delayIncreased...)
|
||
}
|
||
currentNode = currentNode.Next
|
||
}
|
||
currentGroup = currentGroup.Next
|
||
}
|
||
|
||
// 对时间点进行排序和去重
|
||
sort.Ints(timePoints)
|
||
uniqueTimePoints := make([]int, 0)
|
||
lastTime := -1
|
||
for _, t := range timePoints {
|
||
if t != lastTime {
|
||
uniqueTimePoints = append(uniqueTimePoints, t)
|
||
lastTime = t
|
||
}
|
||
}
|
||
|
||
// 对每个时间点生成一帧
|
||
lastFrameImage := (*image.RGBA)(nil)
|
||
|
||
for i, timePoint := range uniqueTimePoints {
|
||
// 渲染当前时间点的帧
|
||
currentFrame := image.NewRGBA(image.Rect(0, 0, width, height))
|
||
frameChanged := false
|
||
|
||
// 检查是否有任何精灵的帧发生变化
|
||
currentGroup = b.indexHead
|
||
for currentGroup != nil {
|
||
currentNode := currentGroup.Head
|
||
for currentNode != nil {
|
||
sprite := currentNode.Sprite
|
||
|
||
// 获取当前精灵在当前时间点的帧
|
||
var currentImage image.Image
|
||
var frameIndex int
|
||
|
||
if sprite.FrameCount() > 1 && len(sprite.Delay) > 0 {
|
||
// 使用延迟时间获取当前帧和帧索引
|
||
currentImage, frameIndex = sprite.GetFrameOnDelay(timePoint)
|
||
|
||
// 检查帧是否变化
|
||
oldFrameIndex, exists := spriteCurrentFrames[sprite]
|
||
if !exists || oldFrameIndex != frameIndex {
|
||
frameChanged = true
|
||
spriteCurrentFrames[sprite] = frameIndex
|
||
}
|
||
} else {
|
||
// 静态精灵直接使用当前帧
|
||
currentImage = sprite.GetCurrentImage()
|
||
}
|
||
|
||
if currentImage != nil {
|
||
// 获取精灵的边界
|
||
srcBounds := currentImage.Bounds()
|
||
|
||
// 计算原始目标区域（相对于minX, minY偏移）
|
||
dstMinX := sprite.Position.X - minX
|
||
dstMinY := sprite.Position.Y - minY
|
||
dstMaxX := dstMinX + srcBounds.Dx()
|
||
dstMaxY := dstMinY + srcBounds.Dy()
|
||
|
||
// 计算源图像的裁剪区域（如果精灵部分在画布外）
|
||
srcMinX := srcBounds.Min.X
|
||
srcMinY := srcBounds.Min.Y
|
||
|
||
// 处理左边界超出
|
||
if dstMinX < 0 {
|
||
srcMinX -= dstMinX // 向右移动源图像起点
|
||
dstMinX = 0
|
||
}
|
||
|
||
// 处理上边界超出
|
||
if dstMinY < 0 {
|
||
srcMinY -= dstMinY // 向下移动源图像起点
|
||
dstMinY = 0
|
||
}
|
||
|
||
// 处理右边界超出
|
||
if dstMaxX > width {
|
||
dstMaxX = width
|
||
}
|
||
|
||
// 处理下边界超出
|
||
if dstMaxY > height {
|
||
dstMaxY = height
|
||
}
|
||
|
||
// 如果裁剪后的区域有效（宽度和高度都大于0）
|
||
if dstMinX < dstMaxX && dstMinY < dstMaxY {
|
||
dstRect := image.Rect(dstMinX, dstMinY, dstMaxX, dstMaxY)
|
||
srcPt := image.Point{X: srcMinX, Y: srcMinY}
|
||
|
||
// 绘制裁剪后的精灵到画布上
|
||
draw.Draw(currentFrame, dstRect, currentImage, srcPt, draw.Over)
|
||
}
|
||
}
|
||
|
||
// 移动到下一个精灵
|
||
currentNode = currentNode.Next
|
||
}
|
||
|
||
// 移动到下一个索引组
|
||
currentGroup = currentGroup.Next
|
||
}
|
||
|
||
// 如果是第一帧或者帧内容有变化，则添加该帧
|
||
if i == 0 || frameChanged {
|
||
// 计算这一帧的延迟时间
|
||
delay := 0
|
||
if i < len(uniqueTimePoints)-1 {
|
||
delay = uniqueTimePoints[i+1] - timePoint
|
||
} else {
|
||
delay = 10 // 最后一帧默认延迟100ms
|
||
}
|
||
|
||
// 将当前帧添加到结果中
|
||
img = append(img, currentFrame)
|
||
delays = append(delays, delay)
|
||
lastFrameImage = currentFrame
|
||
} else if lastFrameImage != nil {
|
||
// 如果帧没有变化，则累加到上一帧的延迟中
|
||
if len(delays) > 0 {
|
||
if i < len(uniqueTimePoints)-1 {
|
||
delays[len(delays)-1] += uniqueTimePoints[i+1] - timePoint
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 确保至少有一帧
|
||
if len(img) == 0 {
|
||
staticFrame := b.RenderToImage()
|
||
return []*image.RGBA{staticFrame}, []int{10}
|
||
}
|
||
|
||
return img, delays
|
||
}
|
||
|
||
func (b *NamedSpriteBoard) GetRenderBounds() (minX, minY, maxX, maxY int) {
|
||
// 计算所有精灵图覆盖的最大区域
|
||
|
||
// 初始化为最大/最小可能值，以便于后续比较
|
||
initialized := false
|
||
|
||
// 遍历所有精灵计算边界
|
||
currentGroup := b.indexHead
|
||
for currentGroup != nil {
|
||
currentNode := currentGroup.Head
|
||
for currentNode != nil {
|
||
sprite := currentNode.Sprite
|
||
currentImage := sprite.GetCurrentImage()
|
||
if currentImage != nil {
|
||
srcBounds := currentImage.Bounds()
|
||
spriteMinX := sprite.Position.X
|
||
spriteMinY := sprite.Position.Y
|
||
spriteMaxX := sprite.Position.X + srcBounds.Dx()
|
||
spriteMaxY := sprite.Position.Y + srcBounds.Dy()
|
||
|
||
// 首次初始化边界值或更新边界
|
||
if !initialized {
|
||
minX, minY = spriteMinX, spriteMinY
|
||
maxX, maxY = spriteMaxX, spriteMaxY
|
||
initialized = true
|
||
} else {
|
||
// 更新边界值
|
||
if spriteMinX < minX {
|
||
minX = spriteMinX
|
||
}
|
||
if spriteMinY < minY {
|
||
minY = spriteMinY
|
||
}
|
||
if spriteMaxX > maxX {
|
||
maxX = spriteMaxX
|
||
}
|
||
if spriteMaxY > maxY {
|
||
maxY = spriteMaxY
|
||
}
|
||
}
|
||
}
|
||
currentNode = currentNode.Next
|
||
}
|
||
currentGroup = currentGroup.Next
|
||
}
|
||
|
||
// 如果没有精灵图，则使用默认大小
|
||
if !initialized {
|
||
minX, minY = 0, 0
|
||
maxX, maxY = 1, 1
|
||
}
|
||
|
||
// 确保有最小尺寸
|
||
if maxX <= minX {
|
||
maxX = minX + 1
|
||
}
|
||
if maxY <= minY {
|
||
maxY = minY + 1
|
||
}
|
||
return minX, minY, maxX, maxY
|
||
}
|
||
|
||
// SaveToPng 将精灵板渲染为图像并保存到文件
|
||
func (b *NamedSpriteBoard) SaveToPng(filename string) error {
|
||
// 渲染图像
|
||
img := b.RenderToImage()
|
||
|
||
// 创建文件
|
||
f, err := os.Create(filename)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
defer f.Close()
|
||
|
||
// 将图像编码为PNG并写入文件
|
||
if err := png.Encode(f, img); err != nil {
|
||
return err
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (b *NamedSpriteBoard) SaveToGIF(filename string) error {
|
||
// 获取动画帧
|
||
frames, delays := b.RenderToAnimatedImage()
|
||
if len(frames) == 0 {
|
||
// 如果没有动画帧，则使用单一图像
|
||
img := b.RenderToImage()
|
||
|
||
// 创建文件
|
||
f, err := os.Create(filename)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
defer f.Close()
|
||
|
||
// 将RGBA图像转换为Paletted图像，使用WebSafe调色板
|
||
bounds := img.Bounds()
|
||
palettedImg := image.NewPaletted(bounds, palette.WebSafe)
|
||
draw.Draw(palettedImg, bounds, img, bounds.Min, draw.Src)
|
||
|
||
// 将图像编码为GIF并写入文件
|
||
if err := gif.EncodeAll(f, &gif.GIF{
|
||
Image: []*image.Paletted{palettedImg},
|
||
Delay: []int{0},
|
||
}); err != nil {
|
||
return err
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// 多帧动画情况
|
||
palettedFrames := make([]*image.Paletted, len(frames))
|
||
|
||
// 转换所有帧为Paletted图像
|
||
for i, frame := range frames {
|
||
bounds := frame.Bounds()
|
||
palettedFrames[i] = image.NewPaletted(bounds, palette.WebSafe)
|
||
draw.Draw(palettedFrames[i], bounds, frame, bounds.Min, draw.Src)
|
||
}
|
||
|
||
// 创建文件
|
||
f, err := os.Create(filename)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
defer f.Close()
|
||
|
||
// 将图像编码为GIF并写入文件
|
||
if err := gif.EncodeAll(f, &gif.GIF{
|
||
Image: palettedFrames,
|
||
Delay: delays,
|
||
}); err != nil {
|
||
return err
|
||
}
|
||
|
||
return nil
|
||
}
|