battleserver

最新推荐文章于 2023-07-11 11:07:24 发布
最新推荐文章于 2023-07-11 11:07:24 发布
阅读量328 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011762115/article/details/82732622
版权

Package:BattleServer

1.AI:

 

AI 结构：

type AI struct {
    Owner *Unit  //拥有的单元
    pause bool   //是否暂停
    ppSkillCDOnly bool
    notUsePPSkill bool
    currentAction AIActionInterface 
    notUseAnySkill bool
}

 

AIInterface结构：

type AIInterface interface {
    Update()  //更新
    Pause()   //暂停
    Resume()  //重新启动
    SetForceTarget(target *Target) 
    SetAttackTarget(*Target) //设置攻击目标
    GetAttackTarget() *Target //获取攻击目标
    ManualCastSkill(skill *Skill)
    FinishCurrentAction()
    //NotUseAnySkill(v bool)
}

AIAtction结构：

type AIAction struct {
    Owner *Unit
    finished bool
}

 

AIActionInterface结构：

type AIActionInterface interface {
    Update() (end bool) //更新
    IsFinished() bool   //是否结束
}

 

AIActionSkill结构：

type AIActionSkill struct {
    AIAction
    nowChooseSkill *Skill
    attackTarget *Target
}

AISimpleBattle结构：

type AISimpleBattle struct {
   AI
   nowChooseSkill *Skill
   attackTarget *Target
   forceTarget *Target
}

 

2.BattleGround:

 

BattleGround结构：

type BattleGround struct {
    Id        int64
    Type      BattleType
    ConfigId  int32     //根据type不同，fb是明雷id
    haveTrigger bool
​
    Now       int64
    DeltaTime int64
    startTime int64
    allLoadedTime int64
​
    serial int64
    //stoped bool
    bgState BGState
    pause  bool
​
    powerpoint              float64
    teamPlayerCount         int32
    skills                  []*Skill
​
    MutexPacks               sync.Mutex
    SessionPackets           []*ClientPacket
    SessionPacketsProcessing []*ClientPacket
    ClientPacketHandlers     map[pbID.Message]FightRolePacketHandler
    Clients                  map[int64]*Session
​
    FightRoles map[int64]*FightRole //id就是userid
    Units     []*Unit
    UnitsById  map[int64]*Unit
    Missiles []*Missile
    BUFFs []BUFFInterface
    BUFFsForTrigger map[BUFF_Occation][]BUFFInterface
    ch_Packet chan *ClientPacket
    currentWave int32
    maxTeam int32
​
    mapRefId int64
    mapRefProtoId int32
    captureTimeout <-chan time.Time
    captureCourse *PetCaptureCourse
​
    killMonsters map[int32]int32
    loser int32
    finishTimeout <-chan time.Time
    leaderLv int32
    center  Vector3
​
    isLeaderFieldCaped bool //队长是否曾在该field抓过宠
    hasTriggedCap bool
    ChangedAttrs  map[int64]map[int32]float64  //记录每一帧单位的属性变化 广播给前端
}

BattleGroundApI:

1.特效API

//从单位到单位的特效
func (self *BattleGround) EffectFromUnitToUnit(effectid int32, source *Unit, target *Unit, movetime int64) int64 {
    newpbmsg := &pb.Fight_PlayEffect{
        Time:        self.Now,
        Id:          self.GetNextSerial(),
        Effid:       int64(effectid),
        Duration:    movetime + 50,
        HangPos:     source.Pos.ToPB(),
        HangId:      source.Id,
        TriggerType: 1,
        //MoveSpeed:speed.ToPB(),
        MoveTime: movetime,
        MoveTarget: &pb.Fight_Target{
            Type:    TARTGET_UNIT,
            Poses:   []*pb.Vector3{target.Pos.ToPB()},
            UnitIds: []int64{target.Id},
        },
    }
    self.BroadCast(pbID.Message_Battle_PlayEffect, 0, newpbmsg)
    return newpbmsg.Id
}
//从单位到位置的特效
func (self *BattleGround) EffectFromUnitToPos(effectid int32, source *Unit, target Vector3, movetime int64) int64 {
    newpbmsg := &pb.Fight_PlayEffect{
        Time:        self.Now,
        Id:          self.GetNextSerial(),
        Effid:       int64(effectid),
        Duration:    movetime + 50,
        HangPos:     source.Pos.ToPB(),
        HangId:      source.Id,
        TriggerType: 1,
        //MoveSpeed:speed.ToPB(),
        MoveTime: movetime,
        MoveTarget: &pb.Fight_Target{
            Type:  TARTGET_POINT,
            Poses: []*pb.Vector3{target.ToPB()},
        },
    }
    self.BroadCast(pbID.Message_Battle_PlayEffect, 0, newpbmsg)
    return newpbmsg.Id
}
​
//从位置到位置的特效
func (self *BattleGround) EffectFromPosToPos(effectid int32, source Vector3, target Vector3, movetime int64) int64 {
    newpbmsg := &pb.Fight_PlayEffect{
        Time:        self.Now,
        Id:          self.GetNextSerial(),
        Effid:       int64(effectid),
        Duration:    movetime + 50,
        HangPos:     source.ToPB(),
        HangId:      0,
        TriggerType: 1,
        //MoveSpeed:speed.ToPB(),
        MoveTime: movetime,
        MoveTarget: &pb.Fight_Target{
            Type:  TARTGET_POINT,
            Poses: []*pb.Vector3{target.ToPB()},
        },
    }
    self.BroadCast(pbID.Message_Battle_PlayEffect, 0, newpbmsg)
    return newpbmsg.Id
}
​
//作用在单位上的特效
func (self *BattleGround) EffectOnUnit(effectid int32, target *Unit, duration int64) int64 {
    newpbmsg := &pb.Fight_PlayEffect{
        Time:        self.Now,
        Id:          self.GetNextSerial(),
        Effid:       int64(effectid),
        Duration:    duration,
        HangPos:     target.Pos.ToPB(),
        HangId:      target.Id,
        TriggerType: 1,
    }
    self.BroadCast(pbID.Message_Battle_PlayEffect, 0, newpbmsg)
    return newpbmsg.Id
}
//作用在位置上的特效
func (self *BattleGround) EffectOnPos(effectid int32, target Vector3, duration int64, rotation Vector3) int64 {
    newpbmsg := &pb.Fight_PlayEffect{
        Time:        self.Now,
        Id:          self.GetNextSerial(),
        Effid:       int64(effectid),
        Duration:    duration,
        HangPos:     target.ToPB(),
        TriggerType: 1,
        Rotation:    rotation.ToPB(),
    }
    self.BroadCast(pbID.Message_Battle_PlayEffect, 0, newpbmsg)
    return newpbmsg.Id
}
//在特效上的特效
func (self *BattleGround) EffectOnEffect(effectid int32, hangeffectid int64, hangpos Vector3) int64 {
    newpbmsg := &pb.Fight_PlayEffect{
        Time:        self.Now,
        Id:          self.GetNextSerial(),
        Effid:       int64(effectid),
        HangPos:     hangpos.ToPB(),
        HangId:      hangeffectid,
        TriggerType: 1,
    }
    self.BroadCast(pbID.Message_Battle_PlayEffect, 0, newpbmsg)
    return newpbmsg.Id
}

2.获取单位API

//获取前方90度范围内的目标
func (self *BattleGround) GetUnitsInfront90(center *Unit, len float32) []*Unit {
    lenpower2 := len * len
    units := make([]*Unit, 0)
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 || unit.Team == 0 {
            continue
        }
        if center.Dir.IsFront90(unit.Pos.Sub(center.Pos)) && center.Pos.Distance2DSqr(unit.Pos) < lenpower2 {
            units = append(units, unit)
        }
    }
    return units
}
​
//获取最近的目标
func (self *BattleGround) GetClosestEnemy(me *Unit) (*Unit, float32) {
    var choosed *Unit = nil
    var mindist float32 = 999999999
    var dist float32 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 || unit.GetAttr(ATTR_Invisible) > 0 {
            continue
        }
        if unit.Team == me.Team || unit.Team == 0 {
            continue
        }
        dist = me.Pos.Distance2DSqr(unit.Pos)
        if dist < mindist {
            mindist = dist
            choosed = unit
        }
    }
    return choosed, mindist
}
//获取某个位置范围内的单位
func (self *BattleGround) GetCicleMulEnemyAtPos(me *Unit, distance float32, pos Vector3) []*Unit {
    units := make([]*Unit, 0)
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 || unit.Team == me.Team || unit.Team == 0 {
            continue
        }
        var dist float32 = pos.Distance2DSqr(unit.Pos)
        if dist < distance*distance {
            units = append(units, unit)
        }
    }
    return units
}
​
//获取最近的多个单位
func (self *BattleGround) GetCloseMulEnemy(me *Unit, count int) []*Unit {
    units := make([]*Unit, 0)
    var maxDisUnit *Unit = nil
    var maxDist float32 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 || unit.Team == me.Team || unit.Team == 0 {
            continue
        }
        if len(units) < count {
            units = append(units, unit)
            var dist float32 = me.Pos.Distance2DSqr(unit.Pos)
            if dist > maxDist {
                maxDist = dist
                maxDisUnit = unit
            }
        } else {
            var dist float32 = me.Pos.Distance2DSqr(unit.Pos)
            var tmpUnit *Unit = nil
            maxDist = 0
            if dist < maxDist {
                for i, tmpunit := range units {
                    if tmpunit.Id == maxDisUnit.Id {
                        units[i] = unit
                    }
                    var dis float32 = me.Pos.Distance2DSqr(tmpunit.Pos)
                    if dis > maxDist {
                        maxDist = dis
                        tmpUnit = tmpunit
                    }
                }
                maxDisUnit = tmpUnit
            }
        }
    }
    return units
}
​
//获取最近的多个友方单位
func (self *BattleGround) GetCloseMulTeammate(me *Unit, count int) []*Unit {
    units := make([]*Unit, 0)
    var maxDisUnit *Unit = nil
    var maxDist float32 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 || unit.Team != me.Team || unit.Team == 0 {
            continue
        }
        if len(units) < count {
            units = append(units, unit)
            var dist float32 = me.Pos.Distance2DSqr(unit.Pos)
            if dist > maxDist {
                maxDist = dist
                maxDisUnit = unit
            }
        } else {
            var dist float32 = me.Pos.Distance2DSqr(unit.Pos)
            var tmpUnit *Unit = nil
            maxDist = 0
            if dist < maxDist {
                for i, tmpunit := range units {
                    if tmpunit.Id == maxDisUnit.Id {
                        units[i] = unit
                    }
                    var dis float32 = me.Pos.Distance2DSqr(tmpunit.Pos)
                    if dis > maxDist {
                        maxDist = dis
                        tmpUnit = tmpunit
                    }
                }
                maxDisUnit = tmpUnit
            }
        }
    }
    return units
}
​
//获取某个位置的最近范围里的多个敌方单位
​
func (self *BattleGround) GetCloseMulEnemyAtPos(Pos Vector3, me *Unit, count int) []*Unit {
    units := make([]*Unit, 0)
    var maxDisUnit *Unit = nil
    var maxDist float32 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 || unit.Team == me.Team || unit.Team == 0 {
            continue
        }
        if len(units) < count {
            units = append(units, unit)
            var dist float32 = Pos.Distance2DSqr(unit.Pos)
            if dist > maxDist {
                maxDist = dist
                maxDisUnit = unit
            }
        } else {
            var dist float32 = Pos.Distance2DSqr(unit.Pos)
            var tmpUnit *Unit = nil
            maxDist = 0
            if dist < maxDist {
                for i, tmpunit := range units {
                    if tmpunit.Id == maxDisUnit.Id {
                        units[i] = unit
                    }
                    var dis float32 = Pos.Distance2DSqr(tmpunit.Pos)
                    if dis > maxDist {
                        maxDist = dis
                        tmpUnit = tmpunit
                    }
                }
                maxDisUnit = tmpUnit
            }
        }
    }
    return units
}
​
//获取半径范围内的所有敌方目标
func (self *BattleGround) GetCicleMulEnemy(me *Unit, distance float32, pos Vector3) []*Unit {
    units := make([]*Unit, 0)
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 || unit.Team == me.Team || unit.Team == 0 {
            continue
        }
        var dist float32 = pos.Distance2DSqr(unit.Pos)
        if dist < distance*distance {
            units = append(units, unit)
        }
​
    }
    return units
}
​
//根据技能中规定的目标数量，随机攻击他们
//huhao
func (self *BattleGround) GetCicleMulEnemyRand(me *Unit, distance float32, pos Vector3, attckNum int32) []*Unit {
    units := make([]*Unit, 0)
    resultUnits := make([]*Unit, 0)
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 || unit.Team == me.Team || unit.Team == 0 {
            continue
        }
        var dist float32 = pos.Distance2DSqr(unit.Pos)
        if dist < distance*distance {
            units = append(units, unit)
        }
    }
    if int(attckNum) < len(units) {
        for i := 0; i < int(attckNum); {
            var count = 0
            var tag bool
            //r := rand.New(rand.NewSource(time.Now().UnixNano()))
            targetIndex := rand.Intn(int(len(units) - 1))
            if len(resultUnits) != 0 {
​
                for _, ele := range resultUnits {
                    if ele.Id == units[targetIndex].Id {
                        count++
                    }
                }
                if int(count) >= 1 {
                    tag = true
                }
                if !tag {
                    //fmt.Println("--------------%v",+targetIndex)
                    resultUnits = append(resultUnits, units[targetIndex])
                    i++
                }
            } else {
                //fmt.Println("--------------%v",+targetIndex)
                resultUnits = append(resultUnits, units[targetIndex])
                i++
            }
​
        }
        return resultUnits
    }
    return units
}
​
//获取最远的目标
​
func (self *BattleGround) FindFarestUnit(team int32, findEnemy bool, pos Vector3) *Unit {
    var choosed *Unit = nil
    var maxdist float32 = 0
    var dist float32 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 {
            continue
        }
        if unit.Team == team && findEnemy || unit.Team != team && !findEnemy || unit.Team == 0 || unit.GetAttr(ATTR_Invisible) > 0 && findEnemy {
            continue
        }
        dist = pos.Distance2DSqr(unit.Pos)
        if dist > maxdist {
            maxdist = dist
            choosed = unit
        }
    }
    return choosed
}
​
 //获取 unit.hp / unit.hpMax 最大的
​
func (self *BattleGround) FindHpRatioMaxUnit(me *Unit, findEnemy bool) *Unit {
    var choosed *Unit = nil
    var maxHpRatio float64 = 0
    var dist float64 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 {
            continue
        }
        if unit.Team == me.Team && findEnemy || unit.Team != me.Team && !findEnemy || unit.Team == 0 || unit.GetAttr(ATTR_Invisible) > 0 && findEnemy {
            continue
        }
        dist = unit.hp / unit.hpMax
        if dist > maxHpRatio {
            maxHpRatio = dist
            choosed = unit
        }
    }
    return choosed
}
​
 //获取 unit.hp / unit.hpMax最小的
func (self *BattleGround) FindHpRatioMinUnit(me *Unit, findEnemy bool) *Unit {
    var choosed *Unit = nil
    var mixHpRatio float64 = 9999999
    var dist float64 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 {
            continue
        }
        if unit.Team == me.Team && findEnemy || unit.Team != me.Team && !findEnemy || unit.Team == 0 || unit.GetAttr(ATTR_Invisible) > 0 && findEnemy {
            continue
        }
        dist = unit.hp / unit.hpMax
        if dist < mixHpRatio {
            mixHpRatio = dist
            choosed = unit
        }
    }
    return choosed
}
​
//获取血量最大的目标
func (self *BattleGround) FindHpMaxUnit(me *Unit, findEnemy bool) *Unit {
    var choosed *Unit = nil
    var maxHp float64 = 0
    var dist float64 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 {
            continue
        }
        if unit.Team == me.Team && findEnemy || unit.Team != me.Team && !findEnemy || unit.Team == 0 || unit.GetAttr(ATTR_Invisible) > 0 && findEnemy {
            continue
        }
        dist = unit.hp
        if dist > maxHp {
            maxHp = dist
            choosed = unit
        }
    }
    return choosed
}
//获取血量最小的
func (self *BattleGround) FindHpMinUnit(me *Unit, findEnemy bool) *Unit {
    var choosed *Unit = nil
    var minHp float64 = 999999999
    var dist float64 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 {
            continue
        }
        if unit.Team == me.Team && findEnemy || unit.Team != me.Team && !findEnemy || unit.Team == 0 || unit.GetAttr(ATTR_Invisible) > 0 && findEnemy {
            continue
        }
        dist = unit.hp
        if dist < minHp {
            minHp = dist
            choosed = unit
        }
    }
    return choosed
}
//获取物理攻击力（ATTR_PhysicsAttack）最大的
func (self *BattleGround) FindPhysicsAttackMaxUnit(me *Unit, findEnemy bool) *Unit {
    var choosed *Unit = nil
    var maxPhysics float64 = 0
    var dist float64 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 {
            continue
        }
        if unit.Team == me.Team && findEnemy || unit.Team != me.Team && !findEnemy || unit.Team == 0 || unit.GetAttr(ATTR_Invisible) > 0 && findEnemy {
            continue
        }
        dist = unit.GetAttr(ATTR_PhysicsAttack)
        if dist > maxPhysics {
            maxPhysics = dist
            choosed = unit
        }
    }
    return choosed
}
//获取物理攻击力（ATTR_PhysicsAttack）最小的
func (self *BattleGround) FindPhysicsAttackMinUnit(me *Unit, findEnemy bool) *Unit {
    var choosed *Unit = nil
    var minPhysics float64 = 999999999
    var dist float64 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 {
            continue
        }
        if unit.Team == me.Team && findEnemy || unit.Team != me.Team && !findEnemy || unit.Team == 0 || unit.GetAttr(ATTR_Invisible) > 0 && findEnemy {
            continue
        }
        dist = unit.GetAttr(ATTR_PhysicsAttack)
        if dist < minPhysics {
            minPhysics = dist
            choosed = unit
        }
    }
    return choosed
}
​
//获取魔攻击力（ATTR_MagicAttack）最大的
func (self *BattleGround) FindMagicAttackMaxUnit(me *Unit, findEnemy bool) *Unit {
    var choosed *Unit = nil
    var maxMagic float64 = 0
    var dist float64 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 {
            continue
        }
        if unit.Team == me.Team && findEnemy || unit.Team != me.Team && !findEnemy || unit.Team == 0 || unit.GetAttr(ATTR_Invisible) > 0 && findEnemy {
            continue
        }
        dist = unit.GetAttr(ATTR_MagicAttack)
        if dist > maxMagic {
            maxMagic = dist
            choosed = unit
        }
    }
    return choosed
}
//获取魔攻击力（ATTR_MagicAttack）最小的
func (self *BattleGround) FindMagicAttackMinUnit(me *Unit, findEnemy bool) *Unit {
    var choosed *Unit = nil
    var minMagic float64 = 999999999
    var dist float64 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 {
            continue
        }
        if unit.Team == me.Team && findEnemy || unit.Team != me.Team && !findEnemy || unit.Team == 0 || unit.GetAttr(ATTR_Invisible) > 0 && findEnemy {
            continue
        }
        dist = unit.GetAttr(ATTR_MagicAttack)
        if dist < minMagic {
            minMagic = dist
            choosed = unit
        }
    }
    return choosed
}
​
//获取防御力（ATTR_PhysicsDefense）最大的
func (self *BattleGround) FindPhysicsDefenseMaxUnit(me *Unit, findEnemy bool) *Unit {
    var choosed *Unit = nil
    var maxPhysics float64 = 0
    var dist float64 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 {
            continue
        }
        if unit.Team == me.Team && findEnemy || unit.Team != me.Team && !findEnemy || unit.Team == 0 || unit.GetAttr(ATTR_Invisible) > 0 && findEnemy {
            continue
        }
        dist = unit.GetAttr(ATTR_PhysicsDefense)
        if dist > maxPhysics {
            maxPhysics = dist
            choosed = unit
        }
    }
    return choosed
}
​
//获取物理防御力（ATTR_PhysicsDefense）最小的
func (self *BattleGround) FindPhysicsDefenseMinUnit(me *Unit, findEnemy bool) *Unit {
    var choosed *Unit = nil
    var minPhysics float64 = 999999999
    var dist float64 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 {
            continue
        }
        if unit.Team == me.Team && findEnemy || unit.Team != me.Team && !findEnemy || unit.Team == 0 || unit.GetAttr(ATTR_Invisible) > 0 && findEnemy {
            continue
        }
        dist = unit.GetAttr(ATTR_PhysicsDefense)
        if dist < minPhysics {
            minPhysics = dist
            choosed = unit
        }
    }
    return choosed
}
​
//获取魔攻防御力（ATTR_MagicDefense）最大的
func (self *BattleGround) FindMagicDefenseMaxUnit(me *Unit, findEnemy bool) *Unit {
    var choosed *Unit = nil
    var maxMagic float64 = 0
    var dist float64 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 {
            continue
        }
        if unit.Team == me.Team && findEnemy || unit.Team != me.Team && !findEnemy || unit.Team == 0 || unit.GetAttr(ATTR_Invisible) > 0 && findEnemy {
            continue
        }
        dist = unit.GetAttr(ATTR_MagicDefense)
        if dist > maxMagic {
            maxMagic = dist
            choosed = unit
        }
    }
    return choosed
}
//获取魔攻防御力（ATTR_MagicDefense）最小的
func (self *BattleGround) FindMagicDefenseMinUnit(me *Unit, findEnemy bool) *Unit {
    var choosed *Unit = nil
    var minMagic float64 = 999999999
    var dist float64 = 0
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 {
            continue
        }
        if unit.Team == me.Team && findEnemy || unit.Team != me.Team && !findEnemy || unit.Team == 0 || unit.GetAttr(ATTR_Invisible) > 0 && findEnemy {
            continue
        }
        dist = unit.GetAttr(ATTR_MagicDefense)
        if dist < minMagic {
            minMagic = dist
            choosed = unit
        }
    }
    return choosed
}
​
//获取活着的目标
​
func (self *BattleGround) FindLiveUnits(me *Unit, findEnemy bool, includeSelf bool) []*Unit {
    units := make([]*Unit, 0)
    for _, unit := range self.Units {
        if unit.Dead || unit.GetAttr(ATTR_Invincibility) > 0 {
            continue
        }
        if unit.Team == me.Team && findEnemy || unit.Team != me.Team && !findEnemy || unit.Team == 0 || unit.GetAttr(ATTR_Invisible) > 0 && findEnemy {
            continue
        }
        if !includeSelf && me.Id == unit.Id {
            continue
        }
        units = append(units, unit)
    }
    return units
}
​
//获取死亡的目标
​
func (self *BattleGround) FindDeadUnits(me *Unit, findEnemy bool, includeSelf bool) []*Unit {
    units := make([]*Unit, 0)
    for _, unit := range self.Units {
        if !unit.Dead {
            continue
        }
        if unit.Team == me.Team && findEnemy || unit.Team != me.Team && !findEnemy || unit.Team == 0 {
            continue
        }
        if !includeSelf && me.Id == unit.Id {
            continue
        }
        units = append(units, unit)
    }
    return units
}
​
​

 

BattleGroundHandler:

 

 

 

 

 

 

 

 

3.BattleServer:

BattleServer结构：

type BattleServer struct {
    listenServer *Server
    handlers map[pbID.Message]ClientPacketHandler
    battlegrounds sync.Map
    userId2battleGrounds sync.Map
​
    ch_WorldPacket chan *ClientPacket
    wg *sync.WaitGroup
}

MapBattleServer结构：

type _MapBattleServer struct {
    mapSever *MapServer
    battleServer *BattleServer
    client2World *Client
    clientListening bool
    openServerTime int64
}

MapServer结构：

type MapServer struct {
    wg *sync.WaitGroup
​
    listenServer *Server
    ch_WorldPacket chan *ClientPacket
    serverHandlers map[pbID.Message]ClientPacketHandler
    gridMaps map[int64]*GridMap
    usersInMap map[int64]*GridMap
   ch_DeleteMap chan *GridMap
}

 

GridMap结构：

type GridMap struct {
   id int64
   mapType MapType
   mapId int32
   refProtoId int32
   refId int64
   relatedConfig interface{}   //根据mapType不同而不同。副本是副本配置
​
   handlers map[pbID.Message]ClientPacketHandler
   serverHandlers map[pbID.Message]ClientPacketHandler
   time int64
   timeVirtual time.Time
   spwanMap *MonsterSpawnMap
   users map[int64]*MapUser
   Grids [][]*Grid //使用顶点是0，0的算法       //中心点是0，0的算法用map[int32]map[int32]*Grid，因为有负数
   ch_Packet  chan *ClientPacket
   ch_logOut  chan *LogoutData
   ch_WorldServerPacket chan *ClientPacket
   size int32
   enableGrid bool
   noGridLoadUsers map[int64]*MapUser
​
   fbMap *FBMap
   state int32
   closeTimer <-chan time.Time
}

LogoutData结构：

type LogoutData struct {
   user *MapUser
   isCurUserGridMap bool
}

 

MapUser结构：

type MapUser struct {
   gridMap               *GridMap
   id                    int64
   token                 string
   session               *Session
   pos                   Vector3
   speed                 float32
   name                  string
   sex                   int32
   dress                 []int32
   horse                 int32 //默认坐骑
   horseSpeed            float32
   mountOwnerId int64    //骑在谁的马上
   mountPos int32  //骑在哪个位置
   passengers []int64 //自己坐骑上的乘客列表，含自己（含自己方便调整位置）
   pet                   int32
   level                 int32
   vip                   int32
   decorate           map[int32]int32
   guildId               int64
   guildName             string
   guildTitle            int32
   title                 int32
   monsterProtectEndTime int64
   inBattle              bool
​
   followState         MapUserFollowState
   followUserId        int64
   followedMems        []int64
​
   horseConfig *MountConfig
   rideInvited map[int64]struct{} //邀请列表
   rideApplied map[int64]struct{} //（向别人）申请列表
   canBattle         bool
   fightData        *MapUserFightData
​
   moveType         int32 //当前移动方式
}

MountConfig结构：

type MountConfig struct {
   Mounts_id     int32
   Clothes          int32
}

 

MapUserFightData结构：

type MapUserFightData struct {
   fightState        int32
   fightTime     int64
   fightType     int32
   fbId         int32     //剧情战斗:剧情id 副本:副本明雷id simle:battleField id
   battleGround   int64
}

 

MonsterSpawnMap结构：

type MonsterSpawnMap struct{
    sceneName string
    //color2SpwanInfo map[int32]*MonsterSpawnConfigInfo
    spawnMaskImage image.Image
    scale float32
    fullsize int32
}

 

MonsterSpawnConfigInfo结构：

type MonsterSpawnConfigInfo struct {
    Battle_id int32
    Battle_name string
    Battle_lv int32
    Battle_lv_type int32
    Monsters [][]int32
    Battle_areacenter [][]float32
    Center []Vector3
    Min_level int32
​
    // 捕捉宠物
    Probability         int32
    Capture_pet         [][]int32
    Capture_level       int32
    Core_pet            int32
}

FBMap结构：

type FBMap struct {
   gridMap *GridMap
   wave int32
   config *CopyConfig
   mines map[int32]*FBMine
   finishStar int32
}

 

FBMine结构：

type FBMine struct {
   fbMap *FBMap
   config *CopyUnitConfig
   pos Vector3
   fighting bool
}

 

4.BUFF:

BUFFTriggerEvent结构：

type BUFFTriggerEvent struct {
    occation BUFF_Occation
    skill SkillInstInterface
    releatedUnit *Unit
    releatedUnit2 *Unit
    doublevalue float64
    intvalue int64
    doublevalue2 float64
    intvalue2 int64
    anyvalue interface{}
    anyvalue2 interface{}
}

 

BUFFConfig结构：

type BUFFConfig struct {
    Id int32
    Name string
    Goodorbad int32         //1--增益   2--减益
    Triggerway int32        //BUFF生效方式 1=获得时立即生效，2=逐帧触发
    StateType  int32        //buff类型
}

BUFFInterface结构：

type BUFFInterface interface {
    Trigger(event *BUFFTriggerEvent) (end bool)
    AddStack(newbuff *BUFF)
    GetID() int64
    GetConfig() *BUFFConfig
    GetSourceSkill() SkillInstInterface
    GetType() int64
    IsEnd() bool
    End()
    OnBeforeEnd()
    GetBUFF()*UnitBUFF
    GetEventType() int32
    GetBuffType()string
}

 

BUFF结构：

type BUFF struct {
   Id int64
   battleGround *BattleGround
   Config *BUFFConfig
   Stack int32
   StackMax int32
   StartTime int64
   source *Unit
   sourceSkill SkillInstInterface
   end bool
   EffectType int64      //效果类型 //沉默 眩晕。。。。等
   thisInterface BUFFInterface
   eventType int32
   bufftype string
}

 

UnitBUFF结构：

​

 

BUFFInterface结构：

​

 

BUFFTriggerEvent结构：

​

 

5.Unit

Unit结构：

type Unit struct {
    Id             int64
    idForTrigger   int32
    Type int32
    Name           string
    BattleGround   *BattleGround
    AttackSkill    *Skill
    Skills         map[string]*Skill
    SkillInstances   []SkillInstInterface
    BUFFs            []BUFFInterface
    BUFFMaps        map[string]BUFFInterface
    BUFFsForTrigger map[BUFF_Occation][]BUFFInterface
    Pos              Vector3
    hp               float64
    hpMax            float64
    speed            float64
    Attrs            []float64
​
    Role             *FightRole
    ProtoId          int32
    Dir              Vector3
    StandPlace       int32
    Team             int32
    Dead             bool
    BornPos          Vector3
    AI               AIInterface
    Moving           bool
    movetarget       Vector3
    NavReq           *NavRequest
    lastnavtime      int64
    lastmovesendtime int64
    PlayerControling bool
    skillusingend    int64
    navPath          NavPath
    reviveTime       int64
    attSpeed         float64
    nowUsedSkill    SkillInstInterface
    ExHarm           map[int32]*Seriesharm //其他单位额外增加的技能伤害Key技能属性类型，额外增加的技能伤害数量
    ExSkillHarm      map[int32]float64 //技能攻击力加成
    ImmuneBuff       int32  //免疫buff类型
    changedAttrs map[int32]float64 //每一帧变化的属性
    config interface{}
}

 

PetConfig结构：

type PetConfig struct {
   Pet_id           int32
   Pet_name         string
   Pet_model  int64
   UnitConfig *UnitConfig
   Hp float64
   Att_1  float64
   Att_2  float64
   Def_1  float64
   Def_2  float64
   Run_speed float64
​
   Hit_rate         float64
   Dodge_rate       float64
   Crit_rate        float64
   Uncrit_rate      float64
   Hurt_up          float64
   Hurt_down        float64
   Att_speed      float64
   Ball1_probability     int32
   Ball2_probability     int32
   Ball3_probability     int32
​
   Pet_depa_1 int32
   Pet_depa_2 int32
​
   Capture_Initialization [][]int32   //抓捕时,生成的随机类型
   genCapQualityTotalRate int32
}

 

MonsterConfig结构：

type MonsterConfig struct {
   Monster_id           int32
   Monster_name         string
   Monster_type    int32
   Prop_model int64
   UnitConfig *UnitConfig
   Pet_depa_1 int32
   Pet_depa_2 int32
   Run_speed float64
   Attack_id string
   Skill_id []string
   Att_speed float64
   Deviation []int32
}

 

 

6.Skill

Skill结构：

type Skill struct {
    Owner *Unit
    Id string
    Cd int64
    SkillTime int64
    CdStart int64
    Config *SkillConfig
    Level int32
}

SkillInstInterface结构：

type SkillInstInterface interface{
    Start() (end bool)
    Update() (end bool)
    CheckTimeAndUpdate() (end bool)
    Interrupt(force bool) (end bool) //force强制打断，用于单位死亡，剧情切换等情况
    GetSkill() *Skill
    GetId() int64
    SetInst(inst SkillInstInterface)
    GetSkillConfig()*SkillConfig
    StageEnd(duration int64)(end bool)
}

 

SkillInst结构：

​

 

 

 

SkillConfig结构：

type SkillConfig struct {
    Id string
    Name string
    Script string
    Pp float64
    Cd float64
    Skill_type int32
    Dis_min float32
    Dis_max float32
    Weight int32
    Skill_time float64
    Start_cd float64
    //Interruptable bool
    Skill_depa int32
    Search_Type int32
    Effectsid []int32
    Skill_buff []int32
    Growth float64
    Skill_power float64
    DamageType DamageType
    StringParams []string
    IntParams []int64
    DoubleParams []float64
    Hit_time   []int64
    Effect_time  []int64
    Floatparams   []float32
}

 

7.FightRole结构：

type FightRole struct {
    Id                   int64
    lv                   int32
    token                string
    BattleGround         *BattleGround
    Session              *Session
    team                 int32
    Units                map[int64]*Unit
    AttackSkill          *Skill
    Skills               []*Skill       //当前可用技能
    NextSkill            *Skill         //下次刷新技能
    SkillStorehouse      []*Skill       //技能池
    SingleFight          bool           //单人战斗
    FixedSlotInMulFight  int32          //多人战斗中的固定槽位
}

 

7.Target：

Target结构:

​

 

8.TriggerManager：

TriggerManager_结构：

type TriggerManager_ struct {
   dramaBattleTriggers map[int32][]*TriggerConfig
   fbBattleTriggers map[int32][]*TriggerConfig
   dramaEndTriggers map[int32][]*TriggerConfig
   battleOnceTriggers map[int64][]int32
}

TriggerConfig结构：

​

 

9.FightRole

type FightRole struct {
   Id                   int64
   lv                  int32
   token                string
   BattleGround         *BattleGround
   Session              *Session
   team                 int32
   Units                map[int64]*Unit
   AttackSkill           *Skill
   Skills               []*Skill     //当前可用技能
   NextSkill         *Skill          //下次刷新技能
   SkillStorehouse      []*Skill     //技能池
   SingleFight           bool        //单人战斗
   FixedSlotInMulFight  int32       //多人战斗中的固定槽位
}

 

 

 

Package：Network

 

1.Sever

Server结构：

​

ServerOptions结构：

type ServerOptions struct{
    WriteBufferLen int
    ReadBufferLen int
    StreamMode bool
    Timeout int
}

 

2.Client

Client 结构：

type Client struct {
    id            string
    server        string
    Session       *Session
    protocol ProtocolType  //type ProtocolType string
    AutoReconnect bool
    Chan_Packet chan *ClientPacket
    Chan_Close chan *Session
    Chan_Connection chan *Session
    connected bool
    chan_nextconnect <-chan time.Time
    chan_nextheartbeat <-chan time.Time
}

 

3.Packet

Packet结构：

type Packet struct {
    msgLength int
    version   uint16 //暂时尚未使用。首位征用，用于表示是否有ReqId
    MessageId uint32
    ErrCode   uint32
    data      []byte
    hasReqId bool
    ReqId     uint32    //在包尾
}

 

4.Session

Session结构：

type Session struct {
    Conn            net.Conn
    Userid          int64
    User            interface{}
    State           int32
    Account         string
​
    packet          *Packet
    HandleConnected func()
    ProcessPacket   func(session *Session, packet *Packet)
    HandleClose     func(session *Session)
    chan_packet *chan *ClientPacket
    IsClient        bool
    connected bool
    syncRequests        sync.Map
​
    cipher          *rc4.Cipher
    reqIdNext uint32
}

 

 

Package:kcp

 

 

 

 

 

PhU号
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
棋牌游戏Server结构
CherishBliss的博客
04-12 2697
c s具体通信流程      服务器间的交互                                  与数据库交互的服务器                           玩法服务器                                      现有的gameserver/battleserver的负载有多少？       几万，battleserver负载均衡创建一个房...
java版斗地主源码-ServerFramework:可用作全球同服或滚服的分布式Java游戏服务器框架，附带若干实用工具和游戏客户端
06-04
框架中的服务器类型分为GM服务器（GM）、逻辑服务器（LogicServer）、战斗服务器（BattleServer）、网关服务器（Gateway），服务器之间的通讯使用Akka框架，处理服务器并发问题，也是利用Akka框架的Actor模型思想 ...
PetBattle:这是一款宝可梦(Pokemon)类型的即时战斗回合制游戏，以精灵养成和联机对战玩法为主，客户端基于Cocos Creator，服务端基于本人的开源框架JCEngine，数据库使用MySQL，使用乐观帧同步实现联机对战。该游戏为本人独立制作，仅用于学习交流
05-02
小精灵大作战 数据库说明 数据库使用MySQL，推荐管理软件Navicat For MySQL。 创建数据库命名为pet_battle，字符集选用utf8 -- UTF-8 Unicode，排序规则选用utf8_general_ci。 设置连接账号[root]密码[123456]。 导入数据库脚本pet_battle.sql。 客户端说明 使用Cocos Creator-2.3.3打开项目PetBattleClient。 可在LoginMgr.ts中修改连接后台的URL。 已有测试账号： 账号 密码 123456 123456 asdfgh asdfgh 注意：要先运行服务端再运行客户端，否则会报连接错误。 服务端说明 推荐使用Eclipse打开项目PetBattleServer。 有问题联系作者：
stick-BattleServer负载均衡
weixin_34293246的博客
12-17 150
2019独角兽企业重金招聘Python工程师标准>>> ...
基于帧同步的游戏框架说明
格物致知
09-23 3277
基于帧同步的游戏框架说明 一，关于帧同步和状态同步的比较 帧同步 状态同步 安全性 比较差，计算都在客户端，服务器只做转发；有服务器校验的方案，比较繁琐 计算都在服务器 可以将重要的判定都由服务器决定 网络流量 比较小，每一帧只同步玩...
开悟AIArena，深度学习神经网络，暑假开悟比赛的学习
Williamtym的博客
07-11 1万+
峡谷漫步v1场景的目标是：通过算法训练一个智能体，让其在对地图不断的探索中学习移动策略，减少碰撞障碍物，以最少的步数从起点走到终点并且收集宝箱。本赛题支持的框架为：PyTorch是一个开源的机器学习框架。PyTorch是一个由Facebook开发的深度学习框架，它主要针对GPU加速的深度神经网络（DNN）编程，并且可以用于其他数学密集型应用2。PyTorch的特点：简洁：PyTorch的设计追求最少的封装，尽量避免重复造轮子。可以顺畅的在 eager 和 graph 模式下切换。
多人实时竞技类游戏解决方案.pdf
05-08
3. **分布式部署与高速传输网络**：WorldServer部署在杭州数据中心，而BattleServer根据玩家的实际位置选择在不同的数据中心部署（如华北地区的北京或青岛数据中心、华东地区的杭州或上海数据中心、华南地区的深圳...
全球同服 游戏服务器架构设计
开心
01-22 1万+
著作权归作者所有。 商业转载请联系作者获得授权，非商业转载请注明出处。 作者：马剑飞 链接：https://www.zhihu.com/question/31103751/answer/64631116 来源：知乎 首先，游戏服务器是IO密集型服务器，它的主要瓶颈在网络IO，而不是CPU，这点要记住了。所以经常服务器问题都会出现在网络IO，带宽，数据库磁盘读写上面，而非CPU上面。
bat脚本常用指令
enchant06的专栏
09-01 6028
windows的bat比较难用且资料较少，本人在工作中收集了平时较为常用的指令
服务器显示不兼容这是什么问题,服务器server0处于不兼容的状态，怎么办？
weixin_35110330的博客
08-06 2532
请参阅创建受管服务器。请参阅创建受管服务器。配置受管服务器与“节点管理器”进行通信。节点管理器是一个 WebLogic Server 实用工具,您可以使用它启动、停止和挂起服务器实例,并且可以远程自动重新启动服务器。节点管理器必须运行。服务器不兼容是因为WoW版本不是最新版本，battle.net之前出现无法正常更新的问题12月4号维护完成，今天登录一看，所有服务器显示不兼容，晕了，真是啥毛病，登...
Android中有时候运行程序的时候会报错：An internal error occurred during:。。。。
热门推荐
zhangyupeng_hehe的专栏
03-13 1万+
解决办法： Project -> Properties -> Run/Debug Settings: 1. select "Launching New_configuration" (你要运行的程序) 2. Delete 3. OK 然后在运行的时候就不会提示这样的错误了。好记性不如烂笔头，为了以后遇到同样的问题能快速解决，特写博客来重温一下。
寄快递小程序（源码）.zip
最新发布
08-22
寄快递小程序（源码）.zip
基于Springboot的 个人博客系统的设计与实现源码 （优秀毕业设计源码）
08-22
1. 个人博客系统的设计与实现代码说明：经导师指导并认可通过的98分毕设项目代码。 2.适用对象：本代码学习资料适用于计算机、电子信息工程、数学等专业正在做毕设的学生，需要项目实战练习的学习者，也适用于课程设计、期末大作业。 3.技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 4. 作者介绍：大厂码农，java领域创作者，阿里云开发社区乘风者计划专家博主，专注于大学生项目实战开发，文章底部有博主联系方式，更多优质系统、项目定制请私信。 5. 最新计算机软件毕业设计选题大全: https://blog.csdn.net/weixin_45630258/article/details/135901374
数学建模-2021年-国赛D题-解决连铸切割问题（模拟训练专用）
08-22
题是在参加学校数学建模培训时的第二道模拟训练题，为2021年国赛D题解决连铸切割问题。该题主要采用多目标规划以及序贯解法解决。本题的最终论文已存放在该压缩包感兴趣可下载使用学习。本文针对尾坯长度和结晶器异常情况，给出最优的切割方案，满足用户的目标要求和正常要求。 解决这个问题可以提高生产效率，减少资源浪费，满足用户需求，确保生产线的正常运行。 问题一：这个问题根据尾坯长度制定出最优的切割方案，这是一个规划优化类问题。我们使用了多目标规划模型和序贯算法，首先考虑报废钢坯的长度，使报废钢坯长度最小；其次考虑用户要求，在相同的切割损失下，切割出的钢坯尽量满足用户的目标范围中的目标值，得出最优切方案（表 1）。 问题二： 在钢坯第 1 次出现报废段时，给出此段钢坯的切割方案； 我们继续使用多目标规划模型，目标一：首先考虑报废钢坯的长度，使报废钢坯长度最小； 目标二： 其次考虑用户要求，在相同的切割损失下，切割出的钢坯尽量满足用户的目标范围[9.0,10.0]标;目标三：达到用户目标值 9.5m。 根据多目标规划模型分别依次计算从初始时刻到每次结晶器异常时刻的尾坯切割方案
1021330100000000606020231723102386644
08-22
1021330100000000606020231723102386644
Python100道题(38).zip
08-22
python爬虫
基于Android手机图片浏览器APP设计与实现.docx
08-22
基于Android手机图片浏览器APP设计与实现.docx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

PhU号

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值