265 lines
7.4 KiB
Go
265 lines
7.4 KiB
Go
package message_server
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
"google.golang.org/protobuf/proto"
|
|
"joylink.club/bj-rtsts-server/message_server/ms_api"
|
|
"joylink.club/bj-rtsts-server/ts/protos/graphicData"
|
|
"joylink.club/bj-rtsts-server/ts/protos/state"
|
|
"joylink.club/bj-rtsts-server/ts/simulation/wayside/memory"
|
|
"joylink.club/ecs"
|
|
"joylink.club/rtsssimulation/component"
|
|
"joylink.club/rtsssimulation/entity"
|
|
)
|
|
|
|
// 信号平面布置图消息服务
|
|
type SfpMs struct {
|
|
vs *memory.VerifySimulation
|
|
mapId int32
|
|
channel string
|
|
}
|
|
|
|
func NewSfpMs(vs *memory.VerifySimulation, mapId int32) *SfpMs {
|
|
return &SfpMs{
|
|
vs: vs,
|
|
mapId: mapId,
|
|
channel: fmt.Sprintf("simulation-%s_%d-devices-status", vs.SimulationId, mapId),
|
|
}
|
|
}
|
|
|
|
// 获取通道名
|
|
func (ms *SfpMs) GetChannel() string {
|
|
return ms.channel
|
|
}
|
|
|
|
// 发送消息间隔时间,单位ms
|
|
func (ms *SfpMs) GetInterval() time.Duration {
|
|
return 200 * time.Millisecond
|
|
}
|
|
|
|
// 定时发送的消息
|
|
func (ms *SfpMs) OnTick() ([]*ms_api.TopicMsg, error) {
|
|
turnoutStates, err := ms.collectTurnoutStates()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
trainStates, err := ms.collectTrainStates()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
signalStates, err := ms.collectSignalStates()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
buttonStates, err := ms.collectStationButtonStates()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
psdStates, err := ms.collectPsdStates()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sectionStates, err := ms.collectSectionStates()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ststes := &state.PushedDevicesStatus{
|
|
All: true,
|
|
AllStatus: &state.AllDevicesStatus{
|
|
SwitchState: turnoutStates,
|
|
TrainState: trainStates,
|
|
SignalState: signalStates,
|
|
ButtonState: buttonStates,
|
|
PsdState: psdStates,
|
|
SectionState: sectionStates,
|
|
},
|
|
}
|
|
b, err := proto.Marshal(ststes)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("信号布置图设备状态消息服务数据序列化失败, %s", err)
|
|
}
|
|
return []*ms_api.TopicMsg{ms_api.NewTopicMsg(ms.channel, b)}, nil
|
|
}
|
|
|
|
func (ms *SfpMs) OnError(err error) {
|
|
// TODO: 错误处理
|
|
}
|
|
|
|
// 收集屏蔽门状态
|
|
func (ms *SfpMs) collectPsdStates() ([]*state.PsdState, error) {
|
|
world := ms.vs.World
|
|
uidStructure := memory.QueryUidStructure[*memory.StationUidStructure](ms.mapId)
|
|
data := memory.QueryGiData[*graphicData.RtssGraphicStorage](ms.mapId)
|
|
var psdStateArr []*state.PsdState
|
|
for _, door := range data.ScreenDoors {
|
|
uid := uidStructure.PsdIds[door.Common.Id].Uid
|
|
psdEntry, ok := entity.GetEntityByUid(world, uid)
|
|
if ok {
|
|
var openSubDoor []int32
|
|
for i, asd := range component.AsdListType.Get(psdEntry).List {
|
|
if !component.AsdMotorStateType.Get(asd).MG {
|
|
openSubDoor = append(openSubDoor, int32(i+1))
|
|
}
|
|
}
|
|
psdStateArr = append(psdStateArr, &state.PsdState{
|
|
Id: door.Common.Id,
|
|
Close: component.PsdStateType.Get(psdEntry).Close,
|
|
OpenAsdCodes: openSubDoor,
|
|
})
|
|
}
|
|
}
|
|
return psdStateArr, nil
|
|
}
|
|
|
|
// 收集区段状态
|
|
func (ms *SfpMs) collectSectionStates() ([]*state.SectionState, error) {
|
|
uidMap := memory.QueryMapUidMapByType(ms.mapId, &graphicData.Section{})
|
|
var sectionArr []*state.SectionState
|
|
for _, u := range uidMap {
|
|
s := handlerSectionState(ms.vs.World, u.Uid)
|
|
if s == nil {
|
|
continue
|
|
}
|
|
s.Id = u.CommonId
|
|
sectionArr = append(sectionArr, s)
|
|
}
|
|
return sectionArr, nil
|
|
}
|
|
|
|
func handlerSectionState(w ecs.World, uid string) *state.SectionState {
|
|
entry, ok := entity.GetEntityByUid(w, uid)
|
|
if !ok {
|
|
//fmt.Printf("id=%s的信号机不存在", uid)
|
|
return nil
|
|
}
|
|
if entry.HasComponent(component.AxleSectionType) { //计轴区段
|
|
sectionState := &state.SectionState{}
|
|
axleState := component.AxleSectionType.Get(entry)
|
|
sectionFault := component.AxleSectionFaultType.Get(entry)
|
|
sectionState.Occupied = axleState.Occ
|
|
sectionState.AxleFault = sectionFault.SectionFault
|
|
return sectionState
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 收集车站按钮状态
|
|
func (ms *SfpMs) collectStationButtonStates() ([]*state.ButtonState, error) {
|
|
// 获取地图上的按钮状态
|
|
uidMap := memory.QueryMapUidMapByType(ms.mapId, &graphicData.EsbButton{})
|
|
var btnStateArr []*state.ButtonState
|
|
for _, u := range uidMap {
|
|
entry, ok := entity.GetEntityByUid(ms.vs.World, u.Uid)
|
|
if !ok {
|
|
return nil, fmt.Errorf("ESB按钮实体不存在: World id=%d, uid=%s", ms.vs.World.Id(), u.Uid)
|
|
}
|
|
if entry.HasComponent(component.ButtonTag) { // 按钮
|
|
bit := component.BitStateType.Get(entry)
|
|
btnStateArr = append(btnStateArr, &state.ButtonState{Id: u.CommonId, Down: bit.Val})
|
|
}
|
|
}
|
|
return btnStateArr, nil
|
|
}
|
|
|
|
// 收集信号机状态
|
|
func (ms *SfpMs) collectSignalStates() ([]*state.SignalState, error) {
|
|
uidMap := memory.QueryMapUidMapByType(ms.mapId, &graphicData.Signal{})
|
|
var signalArr []*state.SignalState
|
|
for _, u := range uidMap {
|
|
s, err := handlerSignalState(ms.vs.World, u.Uid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
s.Id = u.CommonId
|
|
signalArr = append(signalArr, s)
|
|
}
|
|
return signalArr, nil
|
|
}
|
|
|
|
func handlerSignalState(w ecs.World, uid string) (*state.SignalState, error) {
|
|
entry, ok := entity.GetEntityByUid(w, uid)
|
|
if !ok {
|
|
return nil, fmt.Errorf("信号机不存在: World id=%d, 信号机id=%s", w.Id(), uid)
|
|
}
|
|
if !entry.HasComponent(component.SignalLightsType) { //信号机灯列表
|
|
return nil, fmt.Errorf("信号机没有SignalLights组件: World id=%d, 信号机id=%s", w.Id(), uid)
|
|
}
|
|
signalState := &state.SignalState{}
|
|
lights := component.SignalLightsType.Get(entry)
|
|
isL := false
|
|
isH := false
|
|
isU := false
|
|
isA := false
|
|
isB := false
|
|
for _, light := range lights.Lights {
|
|
switch {
|
|
case light.HasComponent(component.LdTag):
|
|
isL = component.BitStateType.Get(light).Val
|
|
case light.HasComponent(component.HdTag):
|
|
isH = component.BitStateType.Get(light).Val
|
|
case light.HasComponent(component.UdTag):
|
|
isU = component.BitStateType.Get(light).Val
|
|
case light.HasComponent(component.BdTag):
|
|
isB = component.BitStateType.Get(light).Val
|
|
case light.HasComponent(component.AdTag):
|
|
isA = component.BitStateType.Get(light).Val
|
|
}
|
|
}
|
|
if isH && isU {
|
|
signalState.Aspect = state.Signal_HU
|
|
} else {
|
|
switch {
|
|
case isL:
|
|
signalState.Aspect = state.Signal_L
|
|
case isH:
|
|
signalState.Aspect = state.Signal_H
|
|
case isU:
|
|
signalState.Aspect = state.Signal_U
|
|
case isB:
|
|
signalState.Aspect = state.Signal_B
|
|
case isA:
|
|
signalState.Aspect = state.Signal_A
|
|
}
|
|
}
|
|
return signalState, nil
|
|
}
|
|
|
|
// 收集列车状态
|
|
func (ms *SfpMs) collectTrainStates() ([]*state.TrainState, error) {
|
|
allTrainMap := &ms.vs.Memory.Status.TrainStateMap
|
|
var trainArr []*state.TrainState
|
|
allTrainMap.Range(func(_, v any) bool {
|
|
trainArr = append(trainArr, v.(*state.TrainState))
|
|
return true
|
|
})
|
|
return trainArr, nil
|
|
}
|
|
|
|
// 收集道岔状态
|
|
func (ms *SfpMs) collectTurnoutStates() ([]*state.SwitchState, error) {
|
|
s := ms.vs
|
|
uidMap := memory.QueryMapUidMapByType(ms.mapId, &graphicData.Turnout{})
|
|
var switchArr []*state.SwitchState
|
|
for _, u := range uidMap {
|
|
entry, ok := entity.GetEntityByUid(s.World, u.Uid)
|
|
if !ok {
|
|
return nil, fmt.Errorf("道岔不存在: World id=%d,道岔id=%s", s.World.Id(), u.Uid)
|
|
}
|
|
if !entry.HasComponent(component.TurnoutPositionType) {
|
|
return nil, fmt.Errorf("道岔没有TurnoutPosition组件: World id=%d,道岔id=%s", s.World.Id(), u.Uid)
|
|
}
|
|
pos := component.TurnoutPositionType.Get(entry)
|
|
s := &state.SwitchState{
|
|
Id: u.CommonId,
|
|
Normal: pos.Db,
|
|
Reverse: pos.Fb,
|
|
Dw: pos.Dw,
|
|
Fw: pos.Fw,
|
|
}
|
|
switchArr = append(switchArr, s)
|
|
}
|
|
return switchArr, nil
|
|
}
|