1. 需求
实现一个工具能准确判断英雄能秒人的技能伤害！方便开挂时选择最优技能，直接秒人，有的英雄现如今只有三个技能，但也不排除之后重做会有四个技能，要求实现简单上手，易扩展！
技能 2 进来了
技能 2 满足条件释放 造成 9000 伤害
技能 3 进来了
技能 3 满足条件释放 造成 10000 伤害
2023/5/10 10:26:31 技能1,伤害7000有点低不太行啊!推荐你换其他技能
2023/5/10 10:26:31 技能1,伤害7000有点低不太行啊!推荐你换其他技能
职责: 判断能秒人的伤害技能
链：技能链
Golang实现职责链模式时候，因为没有继承的支持，使用链对象包涵职责的方式，即：
- 链对象包含当前职责对象以及下一个职责链。
- 职责对象提供接口表示是否能处理对应请求。
- 职责对象提供处理函数处理相关职责。
2. 代码实现
1. manager.go
下面是先定义一个职责链管理器,来帮助每个对象判断它是否符合职责
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
package mainimport "log"// 职责链模式type Manager interface { HaveKill(attack int) bool // 是否击杀 HandleAttackRequest(skillId int, attack int) bool // 连招}// 连招type SkillChain struct { Manager successor *SkillChain}func (r *SkillChain) SetSuccessor(m *SkillChain) { r.successor = m}func (r *SkillChain) HandleAttackRequest(skillId int, attack int) bool { // 伤害是否满足击杀 if r.Manager.HaveKill(attack) { return r.Manager.HandleAttackRequest(skillId, attack) // 释放连招把并且播报 } if r.successor != nil { log.Printf("技能%d,伤害%d有点低不太行啊!推荐你换其他技能\n", skillId, attack) return r.successor.HandleAttackRequest(skillId, attack) } return false}func (r *SkillChain) HaveKill(attack int) bool { return true} |
2. skill1_manager.go
给英雄技能一对象实现对应的职责
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
package mainimport ( "fmt")const ( Hp = 8000 SkillOne =1 SkillTwo =2 SkillThree =3)type SkillOneManager struct {}func NewSkillOneManager() *SkillChain { return &SkillChain{ Manager:&SkillOneManager{}, }}func (s SkillOneManager) HaveKill(attack int) bool { return attack>Hp}func (s SkillOneManager) HandleAttackRequest(skillId int, attack int) bool { fmt.Printf("技能 %d 进来了\n",skillId) if skillId==SkillOne{ fmt.Printf("技能 %d满足条件释放 造成 %d 伤害\n", skillId, attack) return true } fmt.Printf("技能 %d 满足条件释放 造成 %d 伤害\n", skillId, attack) return false} |
3. skill2_manager.go
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package mainimport ( "fmt")type SkillTwoManager struct {}func NewSkillTwoManager() *SkillChain { return &SkillChain{ Manager:&SkillTwoManager{}, }}func (s SkillTwoManager) HaveKill(attack int) bool { return attack>Hp}func (s SkillTwoManager) HandleAttackRequest(skillId int, attack int) bool { if skillId==SkillTwo{ fmt.Printf("技能 %d 满足条件释放 造成 %d 伤害\n", skillId, attack) return true } fmt.Printf("技能 %d不 满足条件释放 造成 %d 伤害\n", skillId, attack) return false} |
4. skill3_manager.go
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package mainimport ( "fmt")type SkillThreeManager struct {}func NewSkillThreeManager() *SkillChain { return &SkillChain{ Manager:&SkillThreeManager{}, }}func (s SkillThreeManager) HaveKill(attack int) bool { return attack>Hp}func (s SkillThreeManager) HandleAttackRequest(skillId int, attack int) bool { if skillId==SkillThree{ fmt.Printf("技能 %d 满足条件释放 造成 %d 伤害\n", skillId, attack) return true } fmt.Printf("技能 %d不 满足条件释放 造成 %d 伤害\n", skillId, attack) return false} |
5. mian.go
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
package maintype ( HeroId = int SkillId = int Attack = int)type DaJi struct { HeroId HeroId Name string SkillInfo map[SkillId]Attack}func NewDaJi(skillInfo map[SkillId]Attack) *DaJi { return &DaJi{HeroId: 1, Name: "妲己", SkillInfo: skillInfo}}func main() { c1 := NewSkillOneManager() c2 := NewSkillTwoManager() c3 := NewSkillThreeManager() c1.SetSuccessor(c2) c2.SetSuccessor(c3) var c Manager = c1 skillInfo := make(map[SkillId]Attack, 3) skillInfo[SkillOne] = 7000 // 技能一 伤害 skillInfo[SkillTwo] = 9000 // 技能一 伤害 skillInfo[SkillThree] = 10000 // 大招 伤害 daji:=NewDaJi(skillInfo) c.HandleAttackRequest(SkillOne, daji.SkillInfo[SkillOne]) c.HandleAttackRequest(SkillTwo, daji.SkillInfo[SkillTwo]) c.HandleAttackRequest(SkillThree, daji.SkillInfo[SkillThree])} |
总结
职责链模式算是迭代器模式的一个延伸，里面的思想与迭代器模式有些相似之处。迭代器是把队列每个元素作为输入，然后用户自己定义处理逻辑，而职责链是用户指定多个处理逻辑，处理同一个输入，只有满足条件的那个处理逻辑才能真正输出，而其他处理逻辑只是把输入传递给下一个处理逻辑。
到此这篇关于GoLang职责链模式分离组合职责的文章就介绍到这了,更多相关GoLang职责链模式内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.csdn.net/jiohfgj/article/details/122257802
