mirror of
https://github.com/duanhf2012/origin.git
synced 2026-02-03 22:45:13 +08:00
731 lines
14 KiB
Go
731 lines
14 KiB
Go
package blueprint
|
||
|
||
import (
|
||
"fmt"
|
||
"math/rand/v2"
|
||
"time"
|
||
|
||
"github.com/duanhf2012/origin/v2/log"
|
||
)
|
||
|
||
// 系统入口ID定义，1000以内
|
||
const (
|
||
EntranceID_IntParam = 1
|
||
EntranceID_ArrayParam = 2
|
||
EntranceID_Timer = 3
|
||
)
|
||
|
||
type Entrance_ArrayParam struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *Entrance_ArrayParam) GetName() string {
|
||
return "Entrance_ArrayParam"
|
||
}
|
||
|
||
func (em *Entrance_ArrayParam) Exec() (int, error) {
|
||
return 0, nil
|
||
}
|
||
|
||
type Entrance_IntParam struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *Entrance_IntParam) GetName() string {
|
||
return "Entrance_IntParam"
|
||
}
|
||
|
||
func (em *Entrance_IntParam) Exec() (int, error) {
|
||
return 0, nil
|
||
}
|
||
|
||
type Entrance_Timer struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *Entrance_Timer) GetName() string {
|
||
return "Entrance_Timer"
|
||
}
|
||
|
||
func (em *Entrance_Timer) Exec() (int, error) {
|
||
return 0, nil
|
||
}
|
||
|
||
type DebugOutput struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *DebugOutput) GetName() string {
|
||
return "DebugOutput"
|
||
}
|
||
|
||
func (em *DebugOutput) Exec() (int, error) {
|
||
val, ok := em.GetInPortInt(1)
|
||
if !ok {
|
||
return 0, fmt.Errorf("output Exec inParam not found")
|
||
}
|
||
|
||
valStr, ok := em.GetInPortStr(2)
|
||
if !ok {
|
||
return 0, fmt.Errorf("output Exec inParam not found")
|
||
}
|
||
|
||
valArray, ok := em.GetInPortArray(3)
|
||
if !ok {
|
||
return 0, fmt.Errorf("output Exec inParam not found")
|
||
}
|
||
|
||
log.Debug("DebugOutput Exec", log.Any("param1", val), log.Any("param2", valStr), log.Any("param3", valArray))
|
||
return 0, nil
|
||
}
|
||
|
||
type Sequence struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *Sequence) GetName() string {
|
||
return "Sequence"
|
||
}
|
||
|
||
func (em *Sequence) Exec() (int, error) {
|
||
for i := range em.outPort {
|
||
if !em.outPort[i].IsPortExec() {
|
||
break
|
||
}
|
||
|
||
err := em.DoNext(i)
|
||
if err != nil {
|
||
return -1, err
|
||
}
|
||
}
|
||
|
||
return -1, nil
|
||
}
|
||
|
||
type ForeachIntArray struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *ForeachIntArray) GetName() string {
|
||
return "ForeachIntArray"
|
||
}
|
||
|
||
func (em *ForeachIntArray) Exec() (int, error) {
|
||
array, ok := em.GetInPortArray(1)
|
||
if !ok {
|
||
return 0, fmt.Errorf("ForeachIntArray Exec inParam 1 not found")
|
||
}
|
||
|
||
for i := range array {
|
||
em.ExecContext.OutputPorts[2].SetInt(array[i].IntVal)
|
||
err := em.DoNext(0)
|
||
if err != nil {
|
||
return -1, err
|
||
}
|
||
}
|
||
|
||
err := em.DoNext(1)
|
||
if err != nil {
|
||
return -1, err
|
||
}
|
||
|
||
return -1, nil
|
||
}
|
||
|
||
type Foreach struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *Foreach) GetName() string {
|
||
return "Foreach"
|
||
}
|
||
|
||
func (em *Foreach) Exec() (int, error) {
|
||
startIndex, ok := em.ExecContext.InputPorts[1].GetInt()
|
||
if !ok {
|
||
return 0, fmt.Errorf("foreach Exec inParam not found")
|
||
}
|
||
endIndex, ok := em.ExecContext.InputPorts[2].GetInt()
|
||
if !ok {
|
||
return 0, fmt.Errorf("foreach Exec inParam not found")
|
||
}
|
||
|
||
for i := startIndex; i < endIndex; i++ {
|
||
em.ExecContext.OutputPorts[2].SetInt(i)
|
||
err := em.DoNext(0)
|
||
if err != nil {
|
||
return -1, err
|
||
}
|
||
}
|
||
|
||
err := em.DoNext(1)
|
||
if err != nil {
|
||
return -1, err
|
||
}
|
||
|
||
return -1, nil
|
||
}
|
||
|
||
type GetArrayInt struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *GetArrayInt) GetName() string {
|
||
return "GetArrayInt"
|
||
}
|
||
|
||
func (em *GetArrayInt) Exec() (int, error) {
|
||
inPort := em.GetInPort(0)
|
||
if inPort == nil {
|
||
return -1, fmt.Errorf("GetArrayInt inParam not found")
|
||
}
|
||
outPort := em.GetOutPort(0)
|
||
if outPort == nil {
|
||
return -1, fmt.Errorf("GetArrayInt outParam not found")
|
||
}
|
||
|
||
arrIndexPort := em.GetInPort(1)
|
||
if arrIndexPort == nil {
|
||
return -1, fmt.Errorf("GetArrayInt arrIndexParam not found")
|
||
}
|
||
arrIndex, ok := arrIndexPort.GetInt()
|
||
if !ok {
|
||
return -1, fmt.Errorf("GetArrayInt arrIndexParam not found")
|
||
}
|
||
|
||
if arrIndex < 0 || arrIndex >= inPort.GetArrayLen() {
|
||
return -1, fmt.Errorf("GetArrayInt arrIndexParam out of range,index %d", arrIndex)
|
||
}
|
||
|
||
val, ok := inPort.GetArrayValInt(int(arrIndex))
|
||
if !ok {
|
||
log.Errorf("GetArrayValInt failed, idx:%d", arrIndex)
|
||
return -1, fmt.Errorf("GetArrayInt inParam not found")
|
||
}
|
||
|
||
outPort.SetInt(val)
|
||
return -1, nil
|
||
}
|
||
|
||
type GetArrayString struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *GetArrayString) GetName() string {
|
||
return "GetArrayString"
|
||
}
|
||
|
||
func (em *GetArrayString) Exec() (int, error) {
|
||
inPort := em.GetInPort(0)
|
||
if inPort == nil {
|
||
return -1, fmt.Errorf("GetArrayInt inParam 0 not found")
|
||
}
|
||
outPort := em.GetOutPort(0)
|
||
if outPort == nil {
|
||
return -1, fmt.Errorf("GetArrayInt outParam 0 not found")
|
||
}
|
||
|
||
arrIndexPort := em.GetInPort(1)
|
||
if arrIndexPort == nil {
|
||
return -1, fmt.Errorf("GetArrayInt arrIndexParam 1 not found")
|
||
}
|
||
arrIndex, ok := arrIndexPort.GetInt()
|
||
if !ok {
|
||
return -1, fmt.Errorf("GetArrayInt arrIndexParam not found")
|
||
}
|
||
|
||
if arrIndex < 0 || arrIndex >= inPort.GetArrayLen() {
|
||
return -1, fmt.Errorf("GetArrayInt arrIndexParam out of range,index %d", arrIndex)
|
||
}
|
||
|
||
val, ok := inPort.GetArrayValStr(int(arrIndex))
|
||
if !ok {
|
||
log.Errorf("GetArrayValStr failed, idx:%d", arrIndex)
|
||
return -1, fmt.Errorf("GetArrayInt inParam not found")
|
||
}
|
||
|
||
outPort.SetStr(val)
|
||
return -1, nil
|
||
}
|
||
|
||
type GetArrayLen struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *GetArrayLen) GetName() string {
|
||
return "GetArrayLen"
|
||
}
|
||
|
||
func (em *GetArrayLen) Exec() (int, error) {
|
||
inPort := em.GetInPort(0)
|
||
if inPort == nil {
|
||
return -1, fmt.Errorf("GetArrayInt inParam 0 not found")
|
||
}
|
||
outPort := em.GetOutPort(0)
|
||
if outPort == nil {
|
||
return -1, fmt.Errorf("GetArrayInt outParam 0 not found")
|
||
}
|
||
|
||
outPort.SetInt(inPort.GetArrayLen())
|
||
return -1, nil
|
||
}
|
||
|
||
// BoolIf 布尔判断
|
||
type BoolIf struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *BoolIf) GetName() string {
|
||
return "BoolIf"
|
||
}
|
||
|
||
func (em *BoolIf) Exec() (int, error) {
|
||
inPort := em.GetInPort(1)
|
||
if inPort == nil {
|
||
return -1, fmt.Errorf("GetArrayInt inParam 1 not found")
|
||
}
|
||
|
||
ret, ok := inPort.GetBool()
|
||
if !ok {
|
||
return -1, fmt.Errorf("BoolIf inParam error")
|
||
}
|
||
|
||
if ret {
|
||
return 1, nil
|
||
}
|
||
|
||
return 0, nil
|
||
}
|
||
|
||
// GreaterThanInteger 大于(整型) >
|
||
type GreaterThanInteger struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *GreaterThanInteger) GetName() string {
|
||
return "GreaterThanInteger"
|
||
}
|
||
|
||
func (em *GreaterThanInteger) Exec() (int, error) {
|
||
inPortEqual := em.GetInPort(1)
|
||
if inPortEqual == nil {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 not found")
|
||
}
|
||
|
||
inPortA := em.GetInPort(2)
|
||
if inPortA == nil {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 not found")
|
||
}
|
||
|
||
inPorB := em.GetInPort(3)
|
||
if inPorB == nil {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 not found")
|
||
}
|
||
|
||
ret, ok := inPortEqual.GetBool()
|
||
if !ok {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 error")
|
||
}
|
||
|
||
inA, ok := inPortA.GetInt()
|
||
if !ok {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 2 error")
|
||
}
|
||
inB, ok := inPorB.GetInt()
|
||
if !ok {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 3 error")
|
||
}
|
||
if ret {
|
||
if inA >= inB {
|
||
return 1, nil
|
||
}
|
||
return 0, nil
|
||
}
|
||
|
||
if inA > inB {
|
||
return 1, nil
|
||
}
|
||
return 0, nil
|
||
}
|
||
|
||
// LessThanInteger 小于(整型) <
|
||
type LessThanInteger struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *LessThanInteger) GetName() string {
|
||
return "LessThanInteger"
|
||
}
|
||
|
||
func (em *LessThanInteger) Exec() (int, error) {
|
||
inPortEqual := em.GetInPort(1)
|
||
if inPortEqual == nil {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 not found")
|
||
}
|
||
|
||
inPortA := em.GetInPort(2)
|
||
if inPortA == nil {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 not found")
|
||
}
|
||
|
||
inPorB := em.GetInPort(3)
|
||
if inPorB == nil {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 not found")
|
||
}
|
||
|
||
ret, ok := inPortEqual.GetBool()
|
||
if !ok {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 error")
|
||
}
|
||
|
||
inA, ok := inPortA.GetInt()
|
||
if !ok {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 2 error")
|
||
}
|
||
inB, ok := inPorB.GetInt()
|
||
if !ok {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 3 error")
|
||
}
|
||
if ret {
|
||
if inA <= inB {
|
||
return 1, nil
|
||
}
|
||
return 0, nil
|
||
}
|
||
|
||
if inA < inB {
|
||
return 1, nil
|
||
}
|
||
return 0, nil
|
||
}
|
||
|
||
// EqualInteger 等于(整型)==
|
||
type EqualInteger struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *EqualInteger) GetName() string {
|
||
return "EqualInteger"
|
||
}
|
||
|
||
func (em *EqualInteger) Exec() (int, error) {
|
||
|
||
inPortA := em.GetInPort(1)
|
||
if inPortA == nil {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 not found")
|
||
}
|
||
|
||
inPorB := em.GetInPort(2)
|
||
if inPorB == nil {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 not found")
|
||
}
|
||
|
||
inA, ok := inPortA.GetInt()
|
||
if !ok {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 2 error")
|
||
}
|
||
inB, ok := inPorB.GetInt()
|
||
if !ok {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 3 error")
|
||
}
|
||
|
||
if inA == inB {
|
||
return 1, nil
|
||
}
|
||
return 0, nil
|
||
}
|
||
|
||
// RangeCompare 范围比较<=
|
||
type RangeCompare struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *RangeCompare) GetName() string {
|
||
return "RangeCompare"
|
||
}
|
||
|
||
func (em *RangeCompare) Exec() (int, error) {
|
||
inPortA := em.GetInPort(1)
|
||
if inPortA == nil {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 not found")
|
||
}
|
||
|
||
ret, ok := inPortA.GetInt()
|
||
if !ok {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 error")
|
||
}
|
||
|
||
intArray := em.execNode.GetInPortDefaultIntArrayValue(2)
|
||
if intArray == nil {
|
||
return 0, nil
|
||
}
|
||
|
||
for i := 0; i < len(intArray) && i < em.GetOutPortCount()-2; i++ {
|
||
if ret <= intArray[i] {
|
||
return i + 2, nil
|
||
}
|
||
}
|
||
|
||
return 0, nil
|
||
}
|
||
|
||
// EqualSwitch 等于分支==
|
||
type EqualSwitch struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *EqualSwitch) GetName() string {
|
||
return "EqualSwitch"
|
||
}
|
||
|
||
func (em *EqualSwitch) Exec() (int, error) {
|
||
inPortA := em.GetInPort(1)
|
||
if inPortA == nil {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 not found")
|
||
}
|
||
|
||
ret, ok := inPortA.GetInt()
|
||
if !ok {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 error")
|
||
}
|
||
|
||
intArray := em.execNode.GetInPortDefaultIntArrayValue(2)
|
||
if intArray == nil {
|
||
return 0, nil
|
||
}
|
||
|
||
for i := 0; i < len(intArray) && i < em.GetOutPortCount()-2; i++ {
|
||
if ret == intArray[i] {
|
||
return i + 2, nil
|
||
}
|
||
}
|
||
|
||
return 0, nil
|
||
}
|
||
|
||
// Probability 概率判断(万分比)
|
||
type Probability struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *Probability) GetName() string {
|
||
return "Probability"
|
||
}
|
||
|
||
func (em *Probability) Exec() (int, error) {
|
||
inPortProbability := em.GetInPort(1)
|
||
if inPortProbability == nil {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 not found")
|
||
}
|
||
|
||
inProbability, ok := inPortProbability.GetInt()
|
||
if !ok {
|
||
return -1, fmt.Errorf("GreaterThanInteger inParam 1 error")
|
||
}
|
||
|
||
if inProbability > rand.Int64N(10000) {
|
||
return 1, nil
|
||
}
|
||
|
||
return 0, nil
|
||
}
|
||
|
||
// CreateIntArray 创建整型数组
|
||
type CreateIntArray struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *CreateIntArray) GetName() string {
|
||
return "CreateIntArray"
|
||
}
|
||
|
||
func (em *CreateIntArray) Exec() (int, error) {
|
||
intArray := em.execNode.GetInPortDefaultIntArrayValue(0)
|
||
if intArray == nil {
|
||
return -1, fmt.Errorf("CreateIntArray inParam 0 not found")
|
||
}
|
||
|
||
outPort := em.GetOutPort(0)
|
||
if outPort == nil {
|
||
return -1, fmt.Errorf("GetArrayInt outParam 0 not found")
|
||
}
|
||
|
||
for _, v := range intArray {
|
||
outPort.AppendArrayValInt(v)
|
||
}
|
||
|
||
return -1, nil
|
||
}
|
||
|
||
// CreateStringArray 创建字符串数组
|
||
type CreateStringArray struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *CreateStringArray) GetName() string {
|
||
return "CreateStringArray"
|
||
}
|
||
|
||
func (em *CreateStringArray) Exec() (int, error) {
|
||
intArray := em.execNode.GetInPortDefaultStringArrayValue(0)
|
||
if intArray == nil {
|
||
return -1, fmt.Errorf("CreateIntArray inParam 0 not found")
|
||
}
|
||
|
||
outPort := em.GetOutPort(0)
|
||
if outPort == nil {
|
||
return -1, fmt.Errorf("GetArrayInt outParam 0 not found")
|
||
}
|
||
|
||
for _, v := range intArray {
|
||
outPort.AppendArrayValStr(v)
|
||
}
|
||
|
||
return -1, nil
|
||
}
|
||
|
||
// AppendIntegerToArray 数组追加整型
|
||
type AppendIntegerToArray struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *AppendIntegerToArray) GetName() string {
|
||
return "AppendIntegerToArray"
|
||
}
|
||
|
||
func (em *AppendIntegerToArray) Exec() (int, error) {
|
||
inPortArray := em.GetInPort(0)
|
||
if inPortArray == nil {
|
||
return -1, fmt.Errorf("AppendIntegerToArray inParam 0 not found")
|
||
}
|
||
|
||
inPortVal := em.GetInPort(1)
|
||
if inPortVal == nil {
|
||
return -1, fmt.Errorf("AppendIntegerToArray inParam 1 not found")
|
||
}
|
||
|
||
outPort := em.GetOutPort(0)
|
||
if outPort == nil {
|
||
return -1, fmt.Errorf("AppendIntegerToArray outParam 0 not found")
|
||
}
|
||
|
||
intArray, ok := inPortArray.GetArray()
|
||
if !ok {
|
||
return -1, fmt.Errorf("AppendIntegerToArray inParam 0 error")
|
||
}
|
||
|
||
intVal, ok := inPortVal.GetInt()
|
||
if !ok {
|
||
return -1, fmt.Errorf("AppendIntegerToArray inParam 1 error")
|
||
}
|
||
|
||
for i := range intArray {
|
||
outPort.AppendArrayValInt(intArray[i].IntVal)
|
||
}
|
||
outPort.AppendArrayValInt(intVal)
|
||
return -1, nil
|
||
}
|
||
|
||
// AppendStringToArray 数组追加字符串
|
||
type AppendStringToArray struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *AppendStringToArray) GetName() string {
|
||
return "AppendStringToArray"
|
||
}
|
||
|
||
func (em *AppendStringToArray) Exec() (int, error) {
|
||
inPortArray := em.GetInPort(0)
|
||
if inPortArray == nil {
|
||
return -1, fmt.Errorf("AppendStringToArray inParam 0 not found")
|
||
}
|
||
|
||
inPortVal := em.GetInPort(1)
|
||
if inPortVal == nil {
|
||
return -1, fmt.Errorf("AppendStringToArray inParam 1 not found")
|
||
}
|
||
|
||
outPort := em.GetOutPort(0)
|
||
if outPort == nil {
|
||
return -1, fmt.Errorf("AppendStringToArray outParam 0 not found")
|
||
}
|
||
|
||
intArray, ok := inPortArray.GetArray()
|
||
if !ok {
|
||
return -1, fmt.Errorf("AppendStringToArray inParam 0 error")
|
||
}
|
||
|
||
for i := range intArray {
|
||
outPort.AppendArrayValStr(intArray[i].StrVal)
|
||
}
|
||
|
||
return -1, nil
|
||
}
|
||
|
||
// CreateTimer 创建定时器
|
||
type CreateTimer struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *CreateTimer) GetName() string {
|
||
return "CreateTimer"
|
||
}
|
||
|
||
func (em *CreateTimer) Exec() (int, error) {
|
||
delay, ok := em.GetInPortInt(0)
|
||
if !ok {
|
||
return -1, fmt.Errorf("CreateTimer inParam 0 error")
|
||
}
|
||
|
||
array, ok := em.GetInPortArray(1)
|
||
if !ok {
|
||
return -1, fmt.Errorf("CreateTimer inParam 0 error")
|
||
}
|
||
|
||
var timerId uint64
|
||
graphID := em.gr.graphID
|
||
em.gr.IBlueprintModule.SafeAfterFunc(&timerId, time.Duration(delay)*time.Millisecond, nil, func(timerId uint64, additionData interface{}) {
|
||
err := em.gr.IBlueprintModule.TriggerEvent(graphID, EntranceID_Timer, array)
|
||
if err != nil {
|
||
log.Warnf("CreateTimer SafeAfterFunc error timerId:%d err:%v", timerId, err)
|
||
}
|
||
|
||
em.gr.IBlueprintModule.CancelTimerId(graphID, &timerId)
|
||
})
|
||
|
||
em.gr.mapTimerID[timerId] = struct{}{}
|
||
|
||
outPort := em.GetOutPort(1)
|
||
if outPort == nil {
|
||
return -1, fmt.Errorf("CreateTimer outParam 1 not found")
|
||
}
|
||
|
||
outPort.SetInt(int64(timerId))
|
||
return 0, nil
|
||
}
|
||
|
||
// CloseTimer 关闭定时器
|
||
type CloseTimer struct {
|
||
BaseExecNode
|
||
}
|
||
|
||
func (em *CloseTimer) GetName() string {
|
||
return "CloseTimer"
|
||
}
|
||
|
||
func (em *CloseTimer) Exec() (int, error) {
|
||
timerID, ok := em.GetInPortInt(1)
|
||
if !ok {
|
||
return -1, fmt.Errorf("CreateTimer inParam 0 error")
|
||
}
|
||
|
||
id := uint64(timerID)
|
||
ok = em.gr.IBlueprintModule.CancelTimerId(em.gr.graphID, &id)
|
||
if !ok {
|
||
log.Warnf("CloseTimer CancelTimerId:%d", id)
|
||
}
|
||
|
||
return 0, nil
|
||
}
|