admin/bl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'main' of https://github.com/72wo/blazing

Browse Source
This commit is contained in:
1
2025-10-27 03:07:38 +00:00
parent 75fc0660b5 248a326bb5
commit 225aff42c5
46 changed files with 1079 additions and 250 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
common/data/share/user.go
View File

@@ -46,7 +46,7 @@ func (m *sessionManager) GetSession(sessionID string) (uint32, error) {
// SaveSession 保存会话信息
func (m *sessionManager) SaveSession(sessionID string, userID uint32) error {
return m.sessionStore.Set(gctx.New(), sessionID, userID, time.Hour*24)
return m.sessionStore.Set(gctx.New(), sessionID, userID, time.Hour*1)
}
// DeleteSession 删除会话

10
common/socket/kick.go
View File

@@ -12,9 +12,19 @@ func (h *Server) KickPerson(a int) error {
return player.KickPlayer(uint32(a))
}
// 参数不为0是强制踢出
func (h *Server) QuitSelf(a int) error {
//TODO 这里待退出
fmt.Println("检测到退出请求")
h.quit = true
if a != 0 {
player.Mainplayer.Range(func(key uint32, value *player.Player) bool {
value.Kick()
return true
})
}
return nil
}

10
common/utils/help.go Normal file
View File

@@ -0,0 +1,10 @@
package utils
func FindWithIndex[T any](slice []T, predicate func(item T) bool) (int, *T, bool) {
for i := range slice {
if predicate(slice[i]) {
return i, &slice[i], true
}
}
return -1, nil, false
}

201
common/utils/limit/LICENSE Normal file
View File

@@ -0,0 +1,201 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2025 肖其顿
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

13
common/utils/limit/NOTICE Normal file
View File

@@ -0,0 +1,13 @@
Copyright 2025 肖其顿
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

42
common/utils/limit/README.md Normal file
View File

@@ -0,0 +1,42 @@
# limit [![PkgGoDev](https://pkg.go.dev/badge/github.com/xiaoqidun/limit)](https://pkg.go.dev/github.com/xiaoqidun/limit)
一个高性能、并发安全的 Go 语言动态速率限制器
# 安装指南
```shell
go get -u github.com/xiaoqidun/limit
```
# 快速开始
```go
package main
import (
"fmt"
"github.com/xiaoqidun/limit"
"golang.org/x/time/rate"
)
func main() {
// 1. 创建一个新的 Limiter 实例
limiter := limit.New()
// 2. 确保在程序退出前优雅地停止后台任务，这非常重要
defer limiter.Stop()
// 3. 为任意键 "some-key" 获取一个速率限制器
// - rate.Limit(2): 表示速率为 "每秒2个请求"
// - 2: 表示桶的容量 (Burst)，允许瞬时处理2个请求
rateLimiter := limiter.Get("some-key", rate.Limit(2), 2)
// 4. 模拟3次连续的突发请求
// 由于速率和容量都为2，只有前两次请求能立即成功
for i := 0; i < 3; i++ {
if rateLimiter.Allow() {
fmt.Printf("请求 %d: 已允许\n", i+1)
} else {
fmt.Printf("请求 %d: 已拒绝\n", i+1)
}
}
}
```
# 授权协议
本项目使用 [Apache License 2.0](https://github.com/xiaoqidun/limit/blob/main/LICENSE) 授权协议

68
common/utils/limit/example_test.go Normal file
View File

@@ -0,0 +1,68 @@
// Copyright 2025 肖其顿
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package limit_test
import (
"fmt"
"time"
"github.com/xiaoqidun/limit"
"golang.org/x/time/rate"
)
// ExampleLimiter 演示了 limit 包的基本用法。
func ExampleLimiter() {
// 创建一个使用默认配置的 Limiter 实例
limiter := limit.New()
// 程序退出前，优雅地停止后台任务，这非常重要
defer limiter.Stop()
// 为一个特定的测试键获取一个速率限制器
// 限制为每秒2个请求，最多允许3个并发（桶容量）
testKey := "testKey"
rateLimiter := limiter.Get(testKey, rate.Limit(2), 3)
// 模拟连续的请求
for i := 0; i < 5; i++ {
if rateLimiter.Allow() {
fmt.Printf("请求 %d: 已允许\n", i+1)
} else {
fmt.Printf("请求 %d: 已拒绝\n", i+1)
}
time.Sleep(100 * time.Millisecond)
}
// 手动移除一个不再需要的限制器
limiter.Del(testKey)
// Output:
// 请求 1: 已允许
// 请求 2: 已允许
// 请求 3: 已允许
// 请求 4: 已拒绝
// 请求 5: 已拒绝
}
// ExampleNewWithConfig 展示了如何使用自定义配置。
func ExampleNewWithConfig() {
// 自定义配置
config := limit.Config{
ShardCount: 64, // 分片数量，必须是2的幂
GCInterval: 5 * time.Minute, // GC 检查周期
Expiration: 15 * time.Minute, // 限制器过期时间
}
// 使用自定义配置创建一个 Limiter 实例
customLimiter := limit.NewWithConfig(config)
defer customLimiter.Stop()
fmt.Println("使用自定义配置的限制器已成功创建")
// Output:
// 使用自定义配置的限制器已成功创建
}

5
common/utils/limit/go.mod Normal file
View File

@@ -0,0 +1,5 @@
module github.com/xiaoqidun/limit
go 1.18
require golang.org/x/time v0.8.0

2
common/utils/limit/go.sum Normal file
View File

@@ -0,0 +1,2 @@
golang.org/x/time v0.8.0 h1:9i3RxcPv3PZnitoVGMPDKZSq1xW1gK1Xy3ArNOGZfEg=
golang.org/x/time v0.8.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=

278
common/utils/limit/limit.go Normal file
View File

@@ -0,0 +1,278 @@
// Copyright 2025 肖其顿
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package limit 提供了一个高性能、并发安全的动态速率限制器。
// 它使用分片锁来减少高并发下的锁竞争，并能自动清理长期未使用的限制器。
package limit
import (
"hash"
"hash/fnv"
"sync"
"sync/atomic"
"time"
"golang.org/x/time/rate"
)
// defaultShardCount 是默认的分片数量，设为2的幂可以优化哈希计算。
const defaultShardCount = 32
// Config 定义了 Limiter 的可配置项。
type Config struct {
// ShardCount 指定分片数量，必须是2的幂。如果为0或无效值，则使用默认值32。
ShardCount int
// GCInterval 指定GC周期，即检查并清理过期限制器的间隔。如果为0，则使用默认值10分钟。
GCInterval time.Duration
// Expiration 指定过期时间，即限制器在最后一次使用后能存活多久。如果为0，则使用默认值30分钟。
Expiration time.Duration
}
// Limiter 是一个高性能、分片实现的动态速率限制器。
// 它的实例在并发使用时是安全的。
type Limiter struct {
// 存储所有分片
shards []*shard
// 配置信息
config Config
// 标记限制器是否已停止
stopped atomic.Bool
// 确保Stop方法只执行一次
stopOnce sync.Once
}
// New 使用默认配置创建一个新的 Limiter 实例。
func New() *Limiter {
return NewWithConfig(Config{})
}
// NewWithConfig 根据提供的配置创建一个新的 Limiter 实例。
func NewWithConfig(config Config) *Limiter {
// 如果未设置，则使用默认值
if config.ShardCount == 0 {
config.ShardCount = defaultShardCount
}
if config.GCInterval == 0 {
config.GCInterval = 10 * time.Minute
}
if config.Expiration == 0 {
config.Expiration = 30 * time.Minute
}
// 确保分片数量是2的幂，以便进行高效的位运算
if config.ShardCount <= 0 || (config.ShardCount&(config.ShardCount-1)) != 0 {
config.ShardCount = defaultShardCount
}
l := &Limiter{
shards: make([]*shard, config.ShardCount),
config: config,
}
// 初始化所有分片
for i := 0; i < config.ShardCount; i++ {
l.shards[i] = newShard(config.GCInterval, config.Expiration)
}
return l
}
// Get 获取或创建一个与指定键关联的速率限制器。
// 如果限制器已存在，它会根据传入的 r (速率) 和 b (并发数) 更新其配置。
// 如果 Limiter 实例已被 Stop 方法关闭，此方法将返回 nil。
func (l *Limiter) Get(k string, r rate.Limit, b int) *rate.Limiter {
// 快速路径检查，避免在已停止时进行哈希和查找
if l.stopped.Load() {
return nil
}
// 定位到具体分片进行操作
return l.getShard(k).get(k, r, b)
}
// Del 手动移除一个与指定键关联的速率限制器。
// 如果 Limiter 实例已被 Stop 方法关闭，此方法不执行任何操作。
func (l *Limiter) Del(k string) {
// 快速路径检查
if l.stopped.Load() {
return
}
// 定位到具体分片进行操作
l.getShard(k).del(k)
}
// Stop 停止 Limiter 的所有后台清理任务，并释放相关资源。
// 此方法对于并发调用是安全的，并且可以被多次调用。
func (l *Limiter) Stop() {
l.stopOnce.Do(func() {
l.stopped.Store(true)
for _, s := range l.shards {
s.stop()
}
})
}
// getShard 根据key的哈希值获取对应的分片。
func (l *Limiter) getShard(key string) *shard {
hasher := fnvHasherPool.Get().(hash.Hash32)
defer func() {
hasher.Reset()
fnvHasherPool.Put(hasher)
}()
_, _ = hasher.Write([]byte(key)) // FNV-1a never returns an error.
// 使用位运算代替取模，提高效率
return l.shards[hasher.Sum32()&(uint32(l.config.ShardCount)-1)]
}
// shard 代表 Limiter 的一个分片，它包含独立的锁和数据，以减少全局锁竞争。
type shard struct {
mutex sync.Mutex
stopCh chan struct{}
limiter map[string]*session
stopOnce sync.Once
waitGroup sync.WaitGroup
}
// newShard 创建一个新的分片实例，并启动其gc任务。
func newShard(gcInterval, expiration time.Duration) *shard {
s := &shard{
// mutex 会被自动初始化为其零值（未锁定状态）
stopCh: make(chan struct{}),
limiter: make(map[string]*session),
}
s.waitGroup.Add(1)
go s.gc(gcInterval, expiration)
return s
}
// gc 定期清理分片中过期的限制器。
func (s *shard) gc(interval, expiration time.Duration) {
defer s.waitGroup.Done()
ticker := time.NewTicker(interval)
defer ticker.Stop()
for {
// 优先检查停止信号，确保能快速响应
select {
case <-s.stopCh:
return
default:
}
select {
case <-ticker.C:
s.mutex.Lock()
// 再次检查分片是否已停止，防止在等待锁期间被停止
if s.limiter == nil {
s.mutex.Unlock()
return
}
for k, v := range s.limiter {
// 清理过期的限制器
if time.Since(v.lastGet) > expiration {
// 将 session 对象放回池中前，重置其状态
v.limiter = nil
v.lastGet = time.Time{}
sessionPool.Put(v)
delete(s.limiter, k)
}
}
s.mutex.Unlock()
case <-s.stopCh:
// 收到停止信号，退出goroutine
return
}
}
}
// get 获取或创建一个新的速率限制器，如果已存在则更新其配置。
func (s *shard) get(k string, r rate.Limit, b int) *rate.Limiter {
s.mutex.Lock()
defer s.mutex.Unlock()
// 检查分片是否已停止
if s.limiter == nil {
return nil
}
sess, ok := s.limiter[k]
if !ok {
// 从池中获取 session 对象
sess = sessionPool.Get().(*session)
sess.limiter = rate.NewLimiter(r, b)
s.limiter[k] = sess
} else {
// 如果已存在，则更新其速率和并发数
sess.limiter.SetLimit(r)
sess.limiter.SetBurst(b)
}
sess.lastGet = time.Now()
return sess.limiter
}
// del 从分片中移除一个键的速率限制器。
func (s *shard) del(k string) {
s.mutex.Lock()
defer s.mutex.Unlock()
// 检查分片是否已停止
if s.limiter == nil {
return
}
if sess, ok := s.limiter[k]; ok {
// 将 session 对象放回池中前，重置其状态
sess.limiter = nil
sess.lastGet = time.Time{}
sessionPool.Put(sess)
delete(s.limiter, k)
}
}
// stop 停止分片的gc任务，并同步等待其完成后再清理资源。
func (s *shard) stop() {
// 使用 sync.Once 确保 channel 只被关闭一次，彻底避免并发风险
s.stopOnce.Do(func() {
close(s.stopCh)
})
// 等待 gc goroutine 完全退出
s.waitGroup.Wait()
// 锁定并进行最终的资源清理
// 因为 gc 已经退出，所以此时只有 Get/Del 会竞争锁
s.mutex.Lock()
defer s.mutex.Unlock()
// 检查是否已被清理，防止重复操作
if s.limiter == nil {
return
}
// 将所有 session 对象放回对象池
for _, sess := range s.limiter {
sess.limiter = nil
sess.lastGet = time.Time{}
sessionPool.Put(sess)
}
// 清理map，释放内存，并作为停止标记
s.limiter = nil
}
// session 存储每个键的速率限制器实例和最后访问时间。
type session struct {
// 最后一次访问时间
lastGet time.Time
// 速率限制器
limiter *rate.Limiter
}
// sessionPool 使用 sync.Pool 来复用 session 对象，以减少 GC 压力。
var sessionPool = sync.Pool{
New: func() interface{} {
return new(session)
},
}
// fnvHasherPool 使用 sync.Pool 来复用 FNV-1a 哈希对象，以减少高并发下的内存分配。
var fnvHasherPool = sync.Pool{
New: func() interface{} {
return fnv.New32a()
},
}

95
common/utils/limit/limit_test.go Normal file
View File

@@ -0,0 +1,95 @@
// Copyright 2025 肖其顿
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package limit
import (
"fmt"
"sync"
"testing"
"time"
"golang.org/x/time/rate"
)
// TestLimiter 覆盖了 Limiter 的主要功能。
func TestLimiter(t *testing.T) {
// 子测试：验证基本的允许/拒绝逻辑
t.Run("基本功能测试", func(t *testing.T) {
limiter := New()
defer limiter.Stop()
key := "测试键"
// 创建一个每秒2个令牌，桶容量为1的限制器
rl := limiter.Get(key, rate.Limit(2), 1)
if rl == nil {
t.Fatal("limiter.Get() 意外返回 nil，测试无法继续")
}
if !rl.Allow() {
t.Error("rl.Allow(): 首次调用应返回 true, 实际为 false")
}
if rl.Allow() {
t.Error("rl.Allow(): 超出突发容量的调用应返回 false, 实际为 true")
}
time.Sleep(500 * time.Millisecond)
if !rl.Allow() {
t.Error("rl.Allow(): 令牌补充后的调用应返回 true, 实际为 false")
}
})
// 子测试：验证 Del 方法的功能
t.Run("删除功能测试", func(t *testing.T) {
limiter := New()
defer limiter.Stop()
key := "测试键"
rl1 := limiter.Get(key, rate.Limit(2), 1)
if !rl1.Allow() {
t.Fatal("获取限制器后的首次 Allow() 调用失败")
}
limiter.Del(key)
rl2 := limiter.Get(key, rate.Limit(2), 1)
if !rl2.Allow() {
t.Error("Del() 后重新获取的限制器未能允许请求")
}
})
// 子测试：验证 Stop 方法的功能
t.Run("停止功能测试", func(t *testing.T) {
limiter := New()
limiter.Stop()
if rl := limiter.Get("任意键", 1, 1); rl != nil {
t.Error("Stop() 后 Get() 应返回 nil, 实际返回了有效实例")
}
// 多次调用 Stop 不应引发 panic
limiter.Stop()
})
// 子测试：验证并发安全性
t.Run("并发安全测试", func(t *testing.T) {
limiter := New()
defer limiter.Stop()
var wg sync.WaitGroup
numGoroutines := 100
for i := 0; i < numGoroutines; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
key := fmt.Sprintf("并发测试键-%d", i)
if limiter.Get(key, rate.Limit(10), 5) == nil {
t.Errorf("并发获取键 '%s' 时, Get() 意外返回 nil", key)
}
}(i)
}
wg.Wait()
})
}

1
go.work
View File

@@ -13,6 +13,7 @@ use (
./common/utils/go-jsonrpc
./common/utils/go-sensitive-word-1.3.3
./common/utils/goja
./common/utils/limit
./common/utils/log
./common/utils/sturc
./common/utils/xml

6
logic/controller/fight.go
View File

@@ -157,13 +157,13 @@ func (h Controller) ChangePet(data *fight.ChangePetInboundInfo, c *player.Player
// 切换精灵
func (h Controller) Capture(data *fight.CatchMonsterInboundInfo, c *player.Player) (result *info.CatchMonsterOutboundInfo, err errorcode.ErrorCode) {
c.FightC.Capture(c, (data.CapsuleId))
c.FightC.Capture(c, data.CapsuleId)
return nil, -1
}
// 切换精灵
// 加载进度
func (h Controller) LoadPercent(data *fight.LoadPercentInboundInfo, c *player.Player) (result *info.LoadPercentOutboundInfo, err errorcode.ErrorCode) {
c.FightC.LoadPercent(c, (int32(data.Percent)))
c.FightC.LoadPercent(c, int32(data.Percent))
return nil, -1
}

41
logic/controller/item.go
View File

@@ -50,13 +50,16 @@ func (h Controller) BuyItem(data *item.BuyInboundInfo, c *player.Player) (result
if (data.Count * uint32(tt.Price)) <= c.Info.Coins {
c.Info.Coins -= data.Count * uint32(tt.Price)
c.ItemAdd(model.SingleItemInfo{ItemId: data.ItemId, ItemCnt: data.Count})
return &item.BuyOutboundInfo{
ItemId: data.ItemId,
Level: 1,
Count: data.Count,
Coins: c.Info.Coins,
}, 0
r := c.ItemAdd(model.SingleItemInfo{ItemId: data.ItemId, ItemCnt: data.Count})
if len(r) != 0 {
return &item.BuyOutboundInfo{
ItemId: data.ItemId,
Level: 1,
Count: data.Count,
Coins: c.Info.Coins,
}, 0
}
}
}
@@ -77,7 +80,7 @@ func (h Controller) ChangePlayerCloth(data *item.ChangePlayerClothInboundInfo, c
result.ClothList = append(result.ClothList, model.PeopleItemInfo{ID: v, Level: 1})
}
c.Info.Clothes = result.ClothList
defer space.GetSpace(c.Info.MapID).User.IterCb(func(playerID uint32, player common.PlayerI) {
space.GetSpace(c.Info.MapID).User.IterCb(func(playerID uint32, player common.PlayerI) {
// fmt.Println("ChangePlayerCloth", playerID, data.Head.Pack(result))
data.Head.Result = 0
player.SendPack(data.Head.Pack(result))
@@ -140,3 +143,25 @@ func (h Controller) TalkCate(data *item.TalkCateInboundInfo, c *player.Player) (
return result, 0
}
func (h Controller) BuyMItem(data *item.BuyMultiInboundInfo, c *player.Player) (result *item.BuyMultiOutboundInfo, err errorcode.ErrorCode) {
var rrr []model.SingleItemInfo
for _, v := range data.ItemIds {
_, ok := xmlres.ItemsMAP[int(v)]
if ok {
rrr = append(rrr, model.SingleItemInfo{ItemId: uint32(v), ItemCnt: 1})
}
}
r := c.ItemAdd(rrr...)
if len(r) != 0 {
return &item.BuyMultiOutboundInfo{
Coins: c.Info.Coins,
}, 0
}
return &item.BuyMultiOutboundInfo{
Coins: c.Info.Coins,
}, 0
}

18
logic/controller/pet.go
View File

@@ -3,6 +3,7 @@ package controller
import (
"blazing/common/data/xmlres"
"blazing/common/socket/errorcode"
"blazing/common/utils"
"blazing/logic/service/pet"
"blazing/logic/service/player"
@@ -122,7 +123,7 @@ func (h *Controller) PlayerShowPet(
func (h *Controller) PetOneCure(
data *pet.PetOneCureInboundInfo, c *player.Player) (result *pet.PetOneCureOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
_, onpet, ok := FindWithIndex(c.Info.PetList, func(item model.PetInfo) bool {
_, onpet, ok := utils.FindWithIndex(c.Info.PetList, func(item model.PetInfo) bool {
return item.CatchTime == data.CatchTime
})
if ok {
@@ -158,16 +159,9 @@ func (h *Controller) PetFirst(
// FindWithIndex 遍历slice，找到第一个满足条件的元素
// 返回：索引、元素指针、是否找到
func FindWithIndex[T any](slice []T, predicate func(item T) bool) (int, *T, bool) {
for i := range slice {
if predicate(slice[i]) {
return i, &slice[i], true
}
}
return -1, nil, false
}
func (h Controller) SetPetExp(data *pet.PetSetExpInboundInfo, c *player.Player) (result *pet.PetSetExpOutboundInfo, err errorcode.ErrorCode) {
_, onpet, ok := FindWithIndex(c.Info.PetList, func(item model.PetInfo) bool {
_, onpet, ok := utils.FindWithIndex(c.Info.PetList, func(item model.PetInfo) bool {
return item.CatchTime == data.CatchTime
})
if ok {
@@ -180,11 +174,11 @@ func (h Controller) SetPetExp(data *pet.PetSetExpInboundInfo, c *player.Player)
}, 0
}
func (h Controller) SetPetSkill(data *pet.ChangeSkillInfo, c *player.Player) (result *pet.ChangeSkillOutInfo, err errorcode.ErrorCode) {
_, onpet, ok := FindWithIndex(c.Info.PetList, func(item model.PetInfo) bool {
_, onpet, ok := utils.FindWithIndex(c.Info.PetList, func(item model.PetInfo) bool {
return item.CatchTime == data.CatchTime
})
if ok {
for i := 0; i < 4; i++ {
for i := 0; i < len(onpet.SkillList); i++ {
if onpet.SkillList[i].ID == data.HasSkill {
onpet.SkillList[i].ID = data.ReplaceSkill
onpet.SkillList[i].PP = uint32(xmlres.SkillMap[int(onpet.SkillList[i].ID)].MaxPP)

15
logic/controller/task.go
View File

@@ -104,7 +104,7 @@ func (h Controller) Complete_Task(data *task.CompleteTaskInboundInfo, c *player.
// out_id=1的奖励物品
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 300001, ItemCount: 5}, // 普通胶囊x5
task.ItemInfo{ItemId: 300011, ItemCount: 3}, // 初级体力药剂x3
task.ItemInfo{ItemId: 300011, ItemCount: 5}, // 初级体力药剂x3
)
// 新手任务4
@@ -548,7 +548,18 @@ func (h Controller) Complete_Task(data *task.CompleteTaskInboundInfo, c *player.
for _, v := range result.ItemList {
ttt = append(ttt, model.SingleItemInfo{ItemId: v.ItemId, ItemCnt: v.ItemCount})
}
c.ItemAdd(ttt...)
r := c.ItemAdd(ttt...)
tempItemList := make([]task.ItemInfo, 0)
for _, v := range result.ItemList {
for _, v1 := range r {
if v1.ItemId == v.ItemId {
tempItemList = append(tempItemList, task.ItemInfo{ItemId: v.ItemId, ItemCount: v.ItemCount})
}
}
}
result.ItemList = tempItemList //临时变量为了防止报错的时候返回数据没问题
return result, 0
}

7
logic/main.go
View File

@@ -10,6 +10,7 @@ import (
_ "blazing/contrib/drivers/pgsql"
"blazing/logic/service/fight"
"blazing/logic/service/player"
"blazing/cool"
@@ -30,6 +31,12 @@ func PprofWeb() {
}
func signalHandlerForMain(sig os.Signal) {
fight.Fightpool.Release()
player.Mainplayer.Range(func(key uint32, value *player.Player) bool {
value.Save()
return true
})
fmt.Println("MainProcess is shutting down due to signal:", sig.String())
}

3
logic/service/fight/action/BattleAction.go
View File

@@ -32,9 +32,8 @@ type BattleActionI interface {
// SelectSkillAction 选择技能的战斗动作
type SelectSkillAction struct {
ID uint32 //技能ID
BaseAction
Skill *info.SkillEntity // 使用的技能
*info.SkillEntity // 使用的技能
//PetInfo *info.BattlePetEntity // 使用技能的宠物
Attack info.AttackValue
}

11
logic/service/fight/action/help.go Normal file
View File

@@ -0,0 +1,11 @@
package action
func CanUse(s *SelectSkillAction) bool {
if s == nil {
return false
}
return s.Info.PP > 0
}

10
logic/service/fight/effect/effect_1.go
View File

@@ -2,7 +2,6 @@ package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
@@ -18,16 +17,19 @@ type Effect1 struct {
func init() {
ret := &Effect1{}
ret.Effect = ret
input.InitEffect(input.EffectType.Skill, 1, ret)
}
// 命中之后
func (e *Effect1) OnHit(opp *input.Input, skill *info.SkillEntity) {
func (e *Effect1) OnSkill(ctx input.Ctx) bool {
if !e.Hit() {
return true
}
e.Input.Heal(
&action.SelectSkillAction{}, e.Input.DamageZone.Damage.Div(decimal.NewFromInt(2)),
)
return true
}

7
logic/service/fight/effect/effect_10-16_94_99_114.go
View File

@@ -16,7 +16,6 @@ func newp(t1 info.EnumBattleStatus) *Effect10 {
Status: t1,
}
t.Effect = t
return t
}
@@ -51,7 +50,7 @@ func init() {
input.InitEffect(input.EffectType.Skill, 114, newp(info.PetStatus.Flammable))
}
func (e *Effect10) OnHit(opp *input.Input, skill *info.SkillEntity) {
func (e *Effect10) OnSkill(ctx input.Ctx) bool {
t, _, _ := e.Input.Player.Roll(e.EffectNode.SideEffectArgs[0], 100)
if t {
@@ -61,11 +60,11 @@ func (e *Effect10) OnHit(opp *input.Input, skill *info.SkillEntity) {
if eff.ID != 0 {
eff.Effect.Duration(int(t1))
opp.AddEffect(eff)
ctx.AddEffect(eff)
}
}
return true
}
func (e *Effect10) OnMiss(opp *input.Input, skill *info.SkillEntity) {

14
logic/service/fight/effect/effect_3_33_63__85_145.go
View File

@@ -13,16 +13,20 @@ type Effect3 struct {
Etype info.EnumAbilityOpType
}
func (e *Effect3) OnHit(opp *input.Input, skill *info.SkillEntity) {
func (e *Effect3) OnSkill(ctx input.Ctx) bool {
if !e.Hit() {
return true
}
for i := 0; i < 6; i++ {
if e.Rev {
opp.SetProp(e.Input, int8(i), e.Level, e.Etype)
ctx.SetProp(e.Input, int8(i), e.Level, e.Etype)
} else {
e.Input.SetProp(opp, int8(i), e.Level, e.Etype)
e.Input.SetProp(ctx.Input, int8(i), e.Level, e.Etype)
}
}
return true
}
func neweffect3(rev bool, level int8, etype info.EnumAbilityOpType) *Effect3 {
@@ -31,7 +35,7 @@ func neweffect3(rev bool, level int8, etype info.EnumAbilityOpType) *Effect3 {
Level: level,
Etype: etype,
}
ret.Effect = ret
return ret
}
func init() {

14
logic/service/fight/effect/effect_4_5.go
View File

@@ -20,7 +20,7 @@ func NewEffectStat(b bool) input.Effect {
EffectNode: node.EffectNode{},
Etype: b,
}
ret.Effect = ret
return ret
}
@@ -40,11 +40,13 @@ type EffectStat struct {
// addrA := unsafe.Pointer(baseAddr + 4) //根据攻击算其他字段
// *(*uint32)(addrA) = 100
// }
func (e *EffectStat) OnHit(opp *input.Input, skill *info.SkillEntity) {
func (e *EffectStat) OnSkill(ctx input.Ctx) bool {
if !e.Hit() {
return true
}
t, _, _ := e.Input.Player.Roll(e.EffectNode.SideEffectArgs[1], 100)
if !t { //没触发
return
return true
}
ptype := info.AbilityOpType.ADD
if e.EffectNode.SideEffectArgs[2] < 0 {
@@ -54,7 +56,7 @@ func (e *EffectStat) OnHit(opp *input.Input, skill *info.SkillEntity) {
e.Input.SetProp(e.Input, int8(e.EffectNode.SideEffectArgs[0]), int8(e.EffectNode.SideEffectArgs[2]), ptype)
} else { //对方
opp.SetProp(e.Input, int8(e.EffectNode.SideEffectArgs[0]), int8(e.EffectNode.SideEffectArgs[2]), ptype)
ctx.SetProp(e.Input, int8(e.EffectNode.SideEffectArgs[0]), int8(e.EffectNode.SideEffectArgs[2]), ptype)
}
return true
}

10
logic/service/fight/effect/effect_62.go
View File

@@ -1,7 +1,6 @@
package effect
import (
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
)
@@ -21,12 +20,15 @@ func init() {
Owner: true,
},
}
t.Effect = t
input.InitEffect(input.EffectType.Skill, 62, t)
}
func (e *Effect62) OnHit(*input.Input, *info.SkillEntity) {
func (e *Effect62) OnSkill(ctx input.Ctx) bool {
if !e.Hit() {
return true
}
if e.Duration() != 1 { //说明还没到生效节点
e.Hide = true //隐藏效果
} else {
@@ -42,7 +44,7 @@ func (e *Effect62) OnHit(*input.Input, *info.SkillEntity) {
//否则触发秒杀 在对面使用技能后
//return true
}
return false
}
// 默认添加回合

29
logic/service/fight/effect/effect_status.go
View File

@@ -19,11 +19,28 @@ type StatusNotSkill struct {
}
// 不能出手
func (e *StatusNotSkill) Skill_Hit_Pre(input.Ctx) bool {
func (e *StatusNotSkill) Skill_Hit_Pre(ctx input.Ctx) bool {
if e.EffectStatus.Status == info.PetStatus.Sleep {
ctx.AddEffect(&input.EffectID{ //对对方添加出手解除效果
ID: -1,
Effect: &StatusSleep{},
})
}
return false
}
type StatusSleep struct { //睡眠不能出手 ,这个挂载到对面来实现对方攻击后解除睡眠效果
node.EffectNode
}
func (e *StatusSleep) Skill_Useed(input.Ctx) bool {
return true
}
// 扣血类
type DrainHP struct {
EffectStatus
@@ -65,9 +82,9 @@ func init() {
}
input.InitEffect(input.EffectType.Status, int(info.PetStatus.DrainHP), &EffectStatus{}) //寄生种子
tt(info.PetStatus.Paralysis, &StatusNotSkill{})
tt(info.PetStatus.Tired, &StatusNotSkill{})
tt(info.PetStatus.Fear, &StatusNotSkill{})
tt(info.PetStatus.Petrified, &StatusNotSkill{})
tt(info.PetStatus.Paralysis, &StatusNotSkill{}) //麻痹
tt(info.PetStatus.Tired, &StatusNotSkill{}) //疲惫
tt(info.PetStatus.Fear, &StatusNotSkill{}) //害怕
tt(info.PetStatus.Petrified, &StatusNotSkill{}) //石化
input.InitEffect(input.EffectType.Status, 8, &StatusSleep{}) //睡眠
}

170
logic/service/fight/fightc.go
View File

@@ -1,11 +1,13 @@
package fight
import (
"blazing/common/utils"
"blazing/logic/service/common"
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/player"
"blazing/modules/blazing/model"
"fmt"
"math/rand"
"reflect"
@@ -329,27 +331,12 @@ func (f *FightC) battleLoop() {
// 如果后手不是技能，替换成空技能（放弃出手）
if _, ok := BattleActionI[1].(*action.SelectSkillAction); !ok {
BattleActionI[1] = &action.SelectSkillAction{
ID: 0,
BaseAction: action.NewBaseAction(BattleActionI[1].GetPlayerID()),
}
f.enterturn(&action.SelectSkillAction{ //双方均放弃出手
ID: 0,
BaseAction: action.NewBaseAction(BattleActionI[1].GetPlayerID()),
},
&action.SelectSkillAction{
ID: 0,
BaseAction: action.NewBaseAction(BattleActionI[0].GetPlayerID()),
})
f.enterturn(nil, nil) //双方都不出手
} else {
f.enterturn(BattleActionI[1].(*action.SelectSkillAction), //后手方先手,先手方放弃出手
&action.SelectSkillAction{
ID: 0,
BaseAction: action.NewBaseAction(BattleActionI[0].GetPlayerID()),
})
//后手方先手,先手方放弃出手
f.enterturn(BattleActionI[1].(*action.SelectSkillAction), nil)
}
@@ -385,45 +372,15 @@ func (f *FightC) battleLoop() {
fmt.Println("ItemID 不在指定范围内")
}
// 回合逻辑：另一方只要不是技能，也放弃出手
leftAction := BattleActionI[0]
rightAction := BattleActionI[1]
if _, ok := rightAction.(*action.SelectSkillAction); !ok {
rightAction = &action.SelectSkillAction{
ID: 0,
BaseAction: action.NewBaseAction(rightAction.GetPlayerID()),
}
if _, ok := BattleActionI[1].(*action.SelectSkillAction); !ok {
f.enterturn(nil, nil)
} else {
f.enterturn(BattleActionI[1].(*action.SelectSkillAction), nil)
}
if _, ok := leftAction.(*action.SelectSkillAction); !ok {
leftAction = &action.SelectSkillAction{
ID: 0,
BaseAction: action.NewBaseAction(leftAction.GetPlayerID()),
}
}
f.enterturn(leftAction.(*action.SelectSkillAction), rightAction.(*action.SelectSkillAction))
default: // 双方都是技能或者默认情况
leftAction := BattleActionI[0]
rightAction := BattleActionI[1]
// 双方只要不是技能，就放弃出手
if _, ok := leftAction.(*action.SelectSkillAction); !ok {
leftAction = &action.SelectSkillAction{
ID: 0,
BaseAction: action.NewBaseAction(leftAction.GetPlayerID()),
}
}
if _, ok := rightAction.(*action.SelectSkillAction); !ok {
rightAction = &action.SelectSkillAction{
ID: 0,
BaseAction: action.NewBaseAction(rightAction.GetPlayerID()),
}
}
f.enterturn(leftAction.(*action.SelectSkillAction), rightAction.(*action.SelectSkillAction))
f.enterturn(BattleActionI[0].(*action.SelectSkillAction), BattleActionI[1].(*action.SelectSkillAction))
}
}
@@ -436,28 +393,28 @@ func (f *FightC) processSkillAttack(attacker, defender *input.Input, a *action.S
attacker.Exec(func(t input.Effect) bool { //计算命中 miss改命中
t.Skill_Hit_Pre(input.Ctx{ //调基础命中
Input: defender,
SkillEntity: a.Skill,
Input: defender,
SelectSkillAction: a,
}) //相当于先调整基础命中,不光调整命中，这里还能调整技能属性，暴击率
return true
})
a.Skill.AttackTimeC(attacker.GetProp(5, true)) //计算命中
defender.Exec(func(t input.Effect) bool { //计算闪避 ,然后修改对方命中),同时相当于计算属性无效这种
a.AttackTimeC(attacker.GetProp(5, true)) //计算命中
defender.Exec(func(t input.Effect) bool { //计算闪避 ,然后修改对方命中),同时相当于计算属性无效这种
t.Skill_Hit_to(input.Ctx{ //计算命中后,我方强制改命中效果
Input: attacker,
SkillEntity: a.Skill,
Input: attacker,
SelectSkillAction: a,
})
return true
})
attacker.AttackValue.AttackTime = a.Skill.AttackTime //是否命中赋值
attacker.Exec(func(t input.Effect) bool { //计算命中 miss改命中
attacker.AttackValue.AttackTime = a.AttackTime //是否命中赋值
attacker.Exec(func(t input.Effect) bool { //计算命中 miss改命中
t.Skill_Hit(input.Ctx{ //计算变威力
Input: attacker,
SkillEntity: a.Skill,
Input: attacker,
SelectSkillAction: a,
}) //相当于先调整基础命中,不光调整命中，这里还能调整技能属性，暴击率
return true
@@ -466,20 +423,20 @@ func (f *FightC) processSkillAttack(attacker, defender *input.Input, a *action.S
//技能miss+效果生效 这里属于强制改命中效果,但是正常来说,技能miss掉后效果也应该失效
//技能失效+效果失效
// 记录技能信息
attacker.AttackValue.SkillID = uint32(a.Skill.ID) //获取技能ID
if attacker.AttackValue.AttackTime > 0 { //如果命中
attacker.UseSkill(defender, a.Skill) //暴击计算
attacker.AttackValue.IsCritical = a.Skill.Crit
attacker.AttackValue.SkillID = uint32(a.ID) //获取技能ID
if attacker.AttackValue.AttackTime > 0 { //如果命中
attacker.UseSkill(defender, a) //暴击计算
attacker.AttackValue.IsCritical = a.Crit
attacker.Exec(func(t input.Effect) bool { //计算命中 miss改命中
t.Calculate_Pre(input.Ctx{ //计算视为效果
Input: defender,
SkillEntity: a.Skill,
Input: defender,
SelectSkillAction: a,
}) //相当于先调整基础命中,不光调整命中，这里还能调整技能属性，暴击率
return true
})
attacker.DamageZone.Damage = attacker.CalculatePower(defender, a.Skill)
attacker.DamageZone.Damage = attacker.CalculatePower(defender, a.SkillEntity)
if attacker.AttackValue.IsCritical == 1 {
@@ -488,16 +445,14 @@ func (f *FightC) processSkillAttack(attacker, defender *input.Input, a *action.S
}
} else {
}
for _, e := range attacker.EffectCache {
//这里实现应该参考本地技能是否命中,然后
e.Hit(a.Skill.AttackTime != 0) //我方效果命中
e.Hit(a.AttackTime != 0) //我方效果命中
}
for _, t := range defender.EffectCache {
if t.GetInput() == attacker { //如果取反,说明是给对方添加的回合效果
t.Hit(a.Skill.AttackTime != 0)
t.Hit(a.AttackTime != 0)
}
}
@@ -505,8 +460,8 @@ func (f *FightC) processSkillAttack(attacker, defender *input.Input, a *action.S
attacker.Exec(func(t input.Effect) bool {
t.OnSkill(input.Ctx{
Input: defender,
SkillEntity: a.Skill,
Input: defender,
SelectSkillAction: a,
}) //调用伤害计算
return true
@@ -516,7 +471,7 @@ func (f *FightC) processSkillAttack(attacker, defender *input.Input, a *action.S
Input: attacker,
SkillEntity: a.Skill,
SelectSkillAction: a,
DamageZone: &info.DamageZone{
Type: info.DamageType.Red,
Damage: attacker.DamageZone.Damage,
@@ -533,6 +488,12 @@ func IsNil(x interface{}) bool {
rv := reflect.ValueOf(x)
return rv.Kind() == reflect.Ptr && rv.IsNil()
}
func copyskill(t *action.SelectSkillAction) *action.SelectSkillAction {
oldskill, _ := deepcopy.Anything(t) //备份技能
return oldskill.(*action.SelectSkillAction)
}
//回合有先手方和后手方,同时有攻击方和被攻击方
@@ -554,10 +515,9 @@ func (f *FightC) enterturn(fattack, sattack *action.SelectSkillAction) {
}
f.First.InitAttackValue()
f.Second.InitAttackValue()
fmt.Println("房主", fattack.ID, "挑战者", sattack.ID)
switch {
case sattack.ID != 0:
case sattack != nil:
f.Second.Parseskill(f.Second, sattack) //解析到临时数据
@@ -568,7 +528,7 @@ func (f *FightC) enterturn(fattack, sattack *action.SelectSkillAction) {
return true
})
switch {
case fattack.ID != 0: //房主也放弃出手
case fattack != nil: //房主也放弃出手
//是否miss都应该施加解析effect
f.First.Parseskill(f.Second, fattack) //解析到临时数据
@@ -580,11 +540,11 @@ func (f *FightC) enterturn(fattack, sattack *action.SelectSkillAction) {
})
switch {
case fattack.Skill.Priority < sattack.Skill.Priority:
case fattack.SkillEntity.Priority < sattack.SkillEntity.Priority:
fattack, sattack = sattack, fattack //互换先手权
f.First, f.Second = f.Second, f.First
case fattack.Skill.Priority == sattack.Skill.Priority:
case fattack.SkillEntity.Priority == sattack.SkillEntity.Priority:
if f.Second.GetProp(4, false) > f.First.GetProp(4, false) {
fattack, sattack = sattack, fattack //互换先手权
@@ -615,25 +575,28 @@ func (f *FightC) enterturn(fattack, sattack *action.SelectSkillAction) {
})
//开始回合操作
for i := 0; i < 2; i++ {
var oldskill interface{}
if i == 0 { //
var oldskill *action.SelectSkillAction //原始技能
var currentskill *action.SelectSkillAction //当前技能
if i == 0 { //
attacker, defender = f.First, f.Second
oldskill = copyskill(fattack)
currentskill = fattack
oldskill, _ = deepcopy.Anything(fattack.Skill) //备份技能
} else {
attacker, defender = f.Second, f.First
oldskill, _ = deepcopy.Anything(sattack.Skill) //备份技能
oldskill = copyskill(sattack)
currentskill = sattack
}
canuseskill := true
// 实际上攻击方 还有系统选择放弃出手的
if IsNil(oldskill) || attacker.CurrentPet.Info.Hp <= 0 {
if IsNil(currentskill) || attacker.CurrentPet.Info.Hp <= 0 {
// attacker.AttackValue.SkillID = 0
canuseskill = false
} else {
if !oldskill.(*info.SkillEntity).CanUse() {
if !action.CanUse(currentskill) {
// attacker.AttackValue.SkillID = 0
canuseskill = false
}
@@ -643,20 +606,21 @@ func (f *FightC) enterturn(fattack, sattack *action.SelectSkillAction) {
//结算状态
//然后这里还可以处理自爆类
return t.Skill_Hit_Pre(input.Ctx{
Input: attacker,
SkillEntity: fattack.Skill,
Input: defender,
SelectSkillAction: currentskill,
}) //返回本身结算,如果false,说明不能使用技能了
})
if canuseskill && canuseskillok { //可以使用技能
if i == 0 { //
f.processSkillAttack(attacker, defender, fattack)
fattack.Skill = oldskill.(*info.SkillEntity) //还原技能效果
fattack.Skill.Info.PP-- //减少PP
} else {
f.processSkillAttack(attacker, defender, sattack)
sattack.Skill = oldskill.(*info.SkillEntity) //还原技能效果
sattack.Skill.Info.PP-- //减少PP
f.processSkillAttack(attacker, defender, currentskill)
currentskill = oldskill
_, skill, ok := utils.FindWithIndex(attacker.CurrentPet.Info.SkillList, func(item model.SkillInfo) bool {
return item.ID == currentskill.Info.ID
})
if ok {
skill.PP--
}
}
@@ -668,6 +632,13 @@ func (f *FightC) enterturn(fattack, sattack *action.SelectSkillAction) {
return true
})
//技能使用后
attacker.Exec(func(t input.Effect) bool { //技能使用后的我方效果
t.Skill_Useed(input.Ctx{Input: defender, SelectSkillAction: currentskill})
return true
})
fmt.Println(i,
// "玩家技能:", oldskill.(*info.SkillEntity).ID,
"玩家技能伤害:", attacker.DamageZone.Damage,
@@ -715,6 +686,9 @@ func (f *FightC) enterturn(fattack, sattack *action.SelectSkillAction) {
return true
})
f.First.AttackValue.RemainHp = int32(f.First.CurrentPet.Info.Hp)
f.First.AttackValue.SkillList = f.First.CurrentPet.Info.SkillList
f.Second.AttackValue.SkillList = f.Second.CurrentPet.Info.SkillList
f.Second.AttackValue.RemainHp = int32(f.Second.CurrentPet.Info.Hp)
ret := info.AttackValueS{
FAttack: *f.First.AttackValue,

4
logic/service/fight/info/BattlePetEntity.go
View File

@@ -40,9 +40,11 @@ func CreateBattlePetEntity(info *model.PetInfo, rand *rand.Rand) *BattlePetEntit
ret.PetInfo = xmlres.PetMAP[int(info.ID)] //注入精灵信息
ret.Info = info
for i := 0; i < 4; i++ {
for i := 0; i < len(info.SkillList); i++ {
//todo 技能信息应该每回合进行深拷贝,保证每次的技能效果都是不一样的
ret.Skills[i] = CreateSkill(&info.SkillList[i], rand, ret)
}
return ret

3
logic/service/fight/info/BattleSkillEntity.go
View File

@@ -71,7 +71,7 @@ func CreateSkill(skill *model.SkillInfo, rand *rand.Rand, pet *BattlePetEntity)
}
ret.Info = skill
fmt.Printf("技能2 %p\n", ret.Info)
return &ret
}
@@ -189,7 +189,6 @@ func (s *SkillEntity) Criticalrandom() decimal.Decimal {
// Accuracy 优化版命中率计算（用绝对值和正负判断处理等级）
func (a *SkillEntity) GetAccuracy(level int) uint32 {
// 基础参数校验
if level >= 0 { //强化等级
return uint32(CalculateRealValue((a.Accuracy), level))

4
logic/service/fight/info/info.go
View File

@@ -238,10 +238,10 @@ type ReadyFightPetInfo struct {
// 精灵最大HP，@UInt long
MaxHp uint32 `fieldDesc:"最大HP" `
SkillListLen uint32
SkillListLen uint32 `struc:"sizeof=SkillList"`
// 技能信息列表（固定4个元素，技能ID和剩余PP，无技能则为0）
// List<SkillInfo>，初始化容量为4
SkillList [4]model.SkillInfo `fieldDesc:"技能信息 技能ID跟剩余PP 固定32字节 没有给0" serialize:"fixedLength=4,type=structArray"`
SkillList []model.SkillInfo `fieldDesc:"技能信息 技能ID跟剩余PP 固定32字节 没有给0" serialize:"fixedLength=4,type=structArray"`
// 精灵捕获时间，@UInt long
CatchTime uint32 `fieldDesc:"精灵捕获时间" `

8
logic/service/fight/input/ctx.go
View File

@@ -6,8 +6,8 @@ import (
)
type Ctx struct {
*Input //施加方
*action.BaseAction //action本身
*info.SkillEntity //技能
*info.DamageZone //伤害
*Input //施加方
*action.SelectSkillAction //action本身
*info.DamageZone //伤害
}

2
logic/service/fight/input/fight.go
View File

@@ -10,7 +10,7 @@ import (
"github.com/shopspring/decimal"
)
func (u *Input) UseSkill(opp *Input, skill *info.SkillEntity) {
func (u *Input) UseSkill(opp *Input, skill *action.SelectSkillAction) {
skill.Crit = 0
if skill.Category() == info.Category.STATUS { //属性技能不用算暴击

5
logic/service/fight/input/input.go
View File

@@ -67,6 +67,7 @@ func (i *Input) InitAttackValue() {
if old != nil {
i.AttackValue.Prop = old.Prop
i.AttackValue.Status = old.Status
i.AttackValue.SkillList = old.SkillList
}
}
@@ -113,9 +114,9 @@ func (i *Input) GetStatusBonus() float64 {
// 解析并 施加effect
func (i *Input) Parseskill(defender *Input, skill *action.SelectSkillAction) {
i.EffectCache = make([]Effect, 0) //先把上一回合数据清空
temparg := skill.Skill.SideEffectArgS
temparg := skill.SideEffectArgS
for _, v := range skill.Skill.SideEffectS {
for _, v := range skill.SideEffectS {
t := Geteffect(EffectType.Skill, v)

2
logic/service/fight/node/PetSwitch.go
View File

@@ -21,7 +21,9 @@ func (e *EffectNode) OnOwnerSwitchIn(ctx input.Ctx) bool {
return true
}
//自身下场,清除掉技能效果
func (e *EffectNode) OnOwnerSwitchOut(ctx input.Ctx) bool {
e.Input.AttackValue = nil
//自身下场清除掉自身的回合效果
//this.GetBattle().Effects[this.GetInput().UserID].RemoveEffect(this)
e.NotALive()

1
logic/service/fight/node/node.go
View File

@@ -8,7 +8,6 @@ import (
// 检查，激活，延后
// /基础节点
type EffectNode struct {
Effect
duration int // 默认为-1 持续回合/次（0 = 即时生效，>0 = 回合数 ,负数是永久） \
Input *input.Input

29
logic/service/fight/node/skill.go
View File

@@ -22,13 +22,13 @@ func (e *EffectNode) Skill_Hit_to(ctx input.Ctx) bool {
return true
}
func (e *EffectNode) OnSkill(ctx input.Ctx) bool {
if e.Effect != nil {
if e.Hit() { //没命中
e.Effect.OnHit(ctx.Input, ctx.SkillEntity)
} else {
e.Effect.OnMiss(ctx.Input, ctx.SkillEntity)
}
}
// if e.Effect != nil {
// if e.Hit() { //没命中
// e.Effect.OnHit(ctx.Input, ctx.SkillEntity)
// } else {
// e.Effect.OnMiss(ctx.Input, ctx.SkillEntity)
// }
// }
return true
}
@@ -41,15 +41,16 @@ func (e *EffectNode) Skill_Use(ctx input.Ctx) bool {
return true
}
func (e *EffectNode) Skill_Useed(ctx input.Ctx) bool {
if e.Effect != nil {
if e.Input.CurrentPet.Info.Hp == 0 {
e.OnDefeat(ctx.Input, ctx.SkillEntity) //死亡
// if e.Effect != nil {
// if e.Input.CurrentPet.Info.Hp == 0 {
// e.OnDefeat(ctx.Input, ctx.SkillEntity) //死亡
} else {
e.OnAlive(ctx.Input, ctx.SkillEntity) //存活
}
// } else {
// e.OnAlive(ctx.Input, ctx.SkillEntity) //存活
// }
}
// }
// return true
return true
}

4
logic/service/fight/playeraction.go
View File

@@ -93,11 +93,11 @@ func (f *FightC) UseSkill(c common.PlayerI, id int32) {
BaseAction: action.NewBaseAction(c.GetInfo().UserID),
}
//ret.PetInfo = f.GetInputByPlayer(c, false).CurrentPet
ret.ID = uint32(id)
for _, v := range f.GetInputByPlayer(c, false).CurrentPet.Skills {
if v != nil && v.ID == int(id) {
ret.Skill = v
ret.SkillEntity = v
break
}

9
logic/service/item/buy.go
View File

@@ -19,3 +19,12 @@ type BuyOutboundInfo struct {
//购买的物品等级
Level uint32
}
type BuyMultiInboundInfo struct {
Head player.TomeeHeader `cmd:"2606" struc:"[0]pad"`
ItemListLen uint32 `struc:"sizeof=ItemIds"`
ItemIds []uint32 `json:"itemIds" description:"购买的物品ID列表"` // @UInt Long对应uint64，List对应切片
}
type BuyMultiOutboundInfo struct {
//剩余的数量
Coins uint32
}

18
logic/service/player/pet.go
View File

@@ -57,19 +57,19 @@ func (p *Player) AddPetExp(petinfo *model.PetInfo, addExp uint32, bro bool) {
for i := 0; i < 4; i++ {
if petinfo.SkillList[i].ID == 0 {
if len(canLearnSkillList) != 0 {
skid := canLearnSkillList[len(canLearnSkillList)-1]
petinfo.SkillList[i].ID = skid
petinfo.SkillList[i].PP = uint32(xmlres.SkillMap[int(skid)].MaxPP)
petinfo.SkillListLen += 1
canLearnSkillList = canLearnSkillList[:len(canLearnSkillList)-1]
}
if len(canLearnSkillList) != 0 {
skid := canLearnSkillList[len(canLearnSkillList)-1]
petinfo.SkillList = append(petinfo.SkillList, model.SkillInfo{
ID: skid,
PP: uint32(xmlres.SkillMap[int(skid)].MaxPP),
})
canLearnSkillList = canLearnSkillList[:len(canLearnSkillList)-1]
}
}
petinfo.SkillList = petinfo.SkillList[:4] //归正到4
//todo 待实现
// // 发送技能更新消息
// updateSkillInfo := UpdateSkillInfo{

64
logic/service/player/player.go
View File

@@ -3,7 +3,9 @@ package player
import (
"blazing/common/data/share"
"blazing/common/data/xmlres"
"blazing/common/socket/errorcode"
"blazing/common/utils"
"blazing/cool"
"fmt"
"math/rand"
"strings"
@@ -212,24 +214,82 @@ func replaceOneNumber(original [3]int) ([3]int, int, int) {
}
// 添加物品
func (p *Player) ItemAdd(t ...model.SingleItemInfo) {
func (p *Player) ItemAdd(t ...model.SingleItemInfo) (result []model.SingleItemInfo) {
var ttt []model.SingleItemInfo
for _, v := range t {
switch v.ItemId {
case 1: //塞尔豆
p.Info.Coins = p.Info.Coins + v.ItemCnt
case 3: //累计经验
p.Info.ExpPool = p.Info.ExpPool + v.ItemCnt
case 5: //金豆ItemAdd
p.Info.GoldBean = p.Info.GoldBean + v.ItemCnt
default:
ttt = append(ttt, v)
}
}
p.Service.ItemAdd(ttt...)
p.Service.Item(func(rer map[uint32]model.SingleItemInfo) bool {
for _, v := range ttt {
itemx, ok := xmlres.ItemsMAP[int(v.ItemId)]
if !ok {
cool.Loger.Error(context.TODO(), "物品不存在", v.ItemId)
t1 := NewTomeeHeader(2601, p.Info.UserID)
t1.Result = uint32(errorcode.ErrorCodes.ErrBaseItemTypeLimit)
p.SendPack(t1.Pack(nil)) //准备包由各自发,因为协议不一样
continue
}
itemm, ok := rer[v.ItemId]
if !ok {
rer[v.ItemId] = v
result = append(result, v)
continue
}
itemm.ItemCnt += v.ItemCnt
if itemm.ItemCnt > uint32(itemx.Max) {
cool.Loger.Error(context.TODO(), "物品超过拥有最大限制", v.ItemId)
t1 := NewTomeeHeader(2601, p.Info.UserID)
t1.Result = uint32(errorcode.ErrorCodes.ErrTooManyOfItem)
p.SendPack(t1.Pack(nil)) //准备包由各自发,因为协议不一样
continue
}
result = append(result, v)
rer[v.ItemId] = itemm
}
return true
})
return
}
func (player1 *Player) Kick() {
if player1.IsLogin {
//取成功,否则创建
//player1.Save() //先保存数据再返回
head := NewTomeeHeader(1001, player1.Info.UserID)
head.Result = uint32(errorcode.ErrorCodes.ErrAccountLoggedInElsewhere)
//实际上这里有个问题,会造成重复保存问题
player1.SendPack(head.Pack(nil))
player1.MainConn.Context().(*ClientData).CloseChan = make(chan struct{})
player1.MainConn.Context().(*ClientData).Mu.Lock()
player1.MainConn.Close()
player1.MainConn.Context().(*ClientData).Mu.Unlock()
// clientdata.Player = player
<-player1.MainConn.Context().(*ClientData).CloseChan
}
}
func (p *Player) SendPack(b []byte) error {
if _, ok := p.MainConn.Context().(*ClientData); !ok {
return fmt.Errorf("链接错误,取消发包")

19
logic/service/player/server.go
View File

@@ -1,8 +1,6 @@
package player
import (
"blazing/common/socket/errorcode"
"github.com/panjf2000/gnet/v2"
)
@@ -33,22 +31,7 @@ func KickPlayer(userid uint32) error { //踢出玩家
//TODO 返回错误码
//var player *entity.Player
if player1, ok := Mainplayer.Load(userid); ok {
if player1.IsLogin {
//取成功,否则创建
//player1.Save() //先保存数据再返回
head := NewTomeeHeader(1001, userid)
head.Result = uint32(errorcode.ErrorCodes.ErrAccountLoggedInElsewhere)
//实际上这里有个问题,会造成重复保存问题
player1.SendPack(head.Pack(nil))
player1.MainConn.Context().(*ClientData).CloseChan = make(chan struct{})
player1.MainConn.Context().(*ClientData).Mu.Lock()
player1.MainConn.Close()
player1.MainConn.Context().(*ClientData).Mu.Unlock()
// clientdata.Player = player
<-player1.MainConn.Context().(*ClientData).CloseChan
}
player1.Kick()
}

9
login/go.sum
View File

@@ -107,6 +107,7 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
<<<<<<< HEAD
github.com/tencent-connect/botgo v0.2.1 h1:+BrTt9Zh+awL28GWC4g5Na3nQaGRWb0N5IctS8WqBCk=
github.com/tencent-connect/botgo v0.2.1/go.mod h1:oO1sG9ybhXNickvt+CVym5khwQ+uKhTR+IhTqEfOVsI=
github.com/tidwall/gjson v1.9.3 h1:hqzS9wAHMO+KVBBkLxYdkEeeFHuqr95GfClRLKlgK0E=
@@ -117,6 +118,10 @@ github.com/tidwall/pretty v1.2.0 h1:RWIZEg2iJ8/g6fDDYzMpobmaoGh5OLl4AXtGUGPcqCs=
github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
=======
github.com/xiaoqidun/limit v1.0.1 h1:tJBDRv+JkziRghRCKHUVyxLGSL1CkkY+aPKMorWZJ20=
github.com/xiaoqidun/limit v1.0.1/go.mod h1:9blqqk5PcsnkWyIBwkkPHUQJjlx2p+Cf0TxVGz0MDFg=
>>>>>>> 248a326bb5cc8fb68085c2534a10a1c7e3935d46
go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo=
go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo=
go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI=
@@ -192,6 +197,7 @@ golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
golang.org/x/time v0.8.0 h1:9i3RxcPv3PZnitoVGMPDKZSq1xW1gK1Xy3ArNOGZfEg=
golang.org/x/time v0.8.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
<<<<<<< HEAD
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
@@ -209,6 +215,9 @@ google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzi
google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
=======
>>>>>>> 248a326bb5cc8fb68085c2534a10a1c7e3935d46
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=

10
login/internal/cmd/cmd.go
View File

@@ -12,11 +12,13 @@ import (
"github.com/gogf/gf/v2/net/ghttp"
"github.com/gogf/gf/v2/os/gcmd"
"github.com/gogf/gf/v2/os/gfile"
"github.com/xiaoqidun/limit"
"golang.org/x/time/rate"
)
var (
Main = gcmd.Command{
limiter = limit.New()
Main = gcmd.Command{
Name: "main",
Usage: "main",
Brief: "start http server",
@@ -52,12 +54,12 @@ func beforeServeHook(r *ghttp.Request) {
r.Response.CORSDefault()
}
var limiter = rate.NewLimiter(rate.Limit(10), 1)
// Limiter is a middleware that implements rate limiting for all HTTP requests.
// It returns HTTP 429 (Too Many Requests) when the rate limit is exceeded.
func Limiter(r *ghttp.Request) {
if !limiter.Allow() {
rateLimiter := limiter.Get(r.GetClientIp(), rate.Limit(10), 2)
if !rateLimiter.Allow() {
r.Response.WriteStatusExit(429) // Return 429 Too Many Requests
r.ExitAll()
}

1
login/main.go
View File

@@ -30,7 +30,6 @@ import (
)
func main() {
//Test_kick()
cmd.Main.Run(gctx.New())
}

4
modules/base/service/base_sys_login.go
View File

@@ -42,7 +42,7 @@ func (s *BaseSysLoginService) Login(ctx context.Context, req *v1.BaseOpenLoginRe
baseSysUser = model.NewBaseSysUser()
)
vcode, _ := cool.CacheManager.Get(ctx, captchaId)
vcode, _ := cool.CacheManager.Get(ctx, "login:"+captchaId)
if vcode.String() != verifyCode {
err = gerror.New("验证码错误")
return
@@ -82,7 +82,7 @@ func (*BaseSysLoginService) Captcha(req *v1.BaseOpenCaptchaReq) (interface{}, er
result.Data = `data:image/svg+xml;base64,` + svgbase64
result.CaptchaId = guid.S()
cool.CacheManager.Set(ctx, result.CaptchaId, captchaText, 1800*time.Second)
cool.CacheManager.Set(ctx, "login:"+result.CaptchaId, captchaText, 1800*time.Second)
cool.Loger.Debug(ctx, "验证码", result.CaptchaId, captchaText)
return result, err
}

34
modules/blazing/model/pet.go
View File

@@ -95,9 +95,10 @@ type PetInfo struct {
// 速度学习力（@UInt long → uint32）
EvSpeed uint32 `fieldDesc:"速度学习力" `
SkillListLen uint32
SkillListLen uint32 `struc:"sizeof=SkillList"`
// 技能信息：固定4条，空则赋值0（固定长度List → [4]SkillInfo，零值即符合“赋值0”）
SkillList [4]SkillInfo
SkillList []SkillInfo
// 捕捉时间（@UInt long → 若为时间戳用uint32；若需时间类型可改为time.Time，需配合序列化处理）
CatchTime uint32 `fieldDesc:"捕捉时间" `
@@ -124,7 +125,7 @@ type PetInfo struct {
func (pet *PetInfo) Cure() {
pet.Hp = pet.MaxHp
for i := 0; i < 4; i++ {
for i := 0; i < len(pet.SkillList); i++ {
maxPP, ok := xmlres.SkillMap[int(pet.SkillList[i].ID)]
// 恢复至最大PP值（从配置表获取）
if pet.SkillList[i].ID != 0 && ok {
@@ -133,15 +134,21 @@ func (pet *PetInfo) Cure() {
}
}
}
func (petinfo *PetInfo) Update() {
// 传入bool则不升级
func (petinfo *PetInfo) Update(t ...bool) {
basic := xmlres.PetMAP[int(petinfo.ID)]
// 检查是否可以进化
if basic.EvolvesTo != 0 && // 有明确的进化
int(petinfo.Level) >= basic.EvolvingLv && // 有明确的进化等级
basic.IsLarge == 0 { // 非最终形态
petinfo.ID = uint32(basic.EvolvesTo)
if len(t) == 0 {
// 检查是否可以进化
if basic.EvolvesTo != 0 && // 有明确的进化
int(petinfo.Level) >= basic.EvolvingLv && // 有明确的进化等级
basic.IsLarge == 0 { // 非最终形态
petinfo.ID = uint32(basic.EvolvesTo)
basic = xmlres.PetMAP[int(petinfo.ID)] //重新计算
}
}
petinfo.LvExp = petinfo.NextLvExp
@@ -289,13 +296,12 @@ func GenPetInfo(
// ---- 技能学习 ----
skills := LastFourElements(p.GetLevelRangeCanLearningSkills(0, p.Level)) // 最后四个技能
p.SkillListLen = uint32(len(skills))
for i := 0; i < len(skills) && i < len(p.SkillList); i++ {
for i := 0; i < len(skills) && i < 4; i++ {
skillID := skills[i]
if info, ok := xmlres.SkillMap[int(skillID)]; ok {
p.SkillList[i].ID = skillID
p.SkillList[i].PP = uint32(info.MaxPP)
p.SkillList = append(p.SkillList, SkillInfo{ID: skillID, PP: uint32(info.MaxPP)})
}
}
@@ -303,7 +309,7 @@ func GenPetInfo(
p.CalculatePetPane()
p.Hp = p.MaxHp
p.Update()
p.Update(true)
return p
}

17
modules/blazing/service/item.go
View File

@@ -29,20 +29,5 @@ func (s *UserService) Item(t func(map[uint32]model.SingleItemInfo) bool) {
panic(err)
}
}
func (s *UserService) ItemAdd(t ...model.SingleItemInfo) {
s.Item(func(rer map[uint32]model.SingleItemInfo) bool {
for _, v := range t {
tt, ok := rer[v.ItemId]
if ok {
tt.ItemCnt += v.ItemCnt
rer[v.ItemId] = tt
} else {
rer[v.ItemId] = v
}
}
return true
})
}
// /添加进来的物品一定是保证存在的