sturdyengine/vessel.go at master · fia0/sturdyengine · GitHub

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
package sturdyengine

import (
	"github.com/golang/protobuf/proto"
	util "github.com/jwuensche/sturdyengine/internal"
	krpc "github.com/jwuensche/sturdyengine/internal/krpcproto"
)

//Vessel represents a combination of krpc Vessel & Control allowing direct operations on the current vessel
type Vessel struct {
	sc *SpaceCenter

	vessel  []byte
	control []byte
}

//NewVessel returns a initialized instance of a vessel ready to use
func (sc *SpaceCenter) NewVessel() (vessel Vessel, err error) {
	vsl, err := sc.GetActiveVessel()
	vessel = Vessel{
		sc:     sc,
		vessel: vsl,
	}
	vessel.control, err = vessel.GetVesselControl()
	return
}

//ActivateNextStage activate the next stage of the given control unit
func (vsl *Vessel) ActivateNextStage() (err error) {
	arg := [][]byte{vsl.control}
	pr := createRequest("SpaceCenter", "Control_ActivateNextStage", createArguments(arg))

	p, err := vsl.sc.conn.sendMessage(pr)
	if err != nil {
		return
	}
	res := &krpc.Response{}
	proto.Unmarshal(p, res)

	return
}

//GetActiveVessel returns the current active Vessel as byte slice
func (sc *SpaceCenter) GetActiveVessel() (r []byte, e error) {
	pr := createRequest("SpaceCenter", "get_ActiveVessel", nil)

	p, e := sc.conn.sendMessage(pr)
	res := &krpc.Response{}
	proto.Unmarshal(p, res)
	r = res.GetResults()[0].GetValue()
	return
}

//GetVesselControl returns control object to a given vessel
func (vsl *Vessel) GetVesselControl() (r []byte, e error) {
	arg := [][]byte{vsl.vessel}
	pr := createRequest("SpaceCenter", "Vessel_get_Control", createArguments(arg))

	p, e := vsl.sc.conn.sendMessage(pr)
	if e != nil {
		return
	}
	res := &krpc.Response{}
	e = proto.Unmarshal(p, res)
	if e != nil {
		return
	}

	r = res.GetResults()[0].GetValue()
	return
}

//GetSAS returns the current state of the given control unit SAS, true in case it is activated
func (vsl *Vessel) GetSAS() (r bool, e error) {
	arg := [][]byte{vsl.control}
	pr := createRequest("SpaceCenter", "Control_get_SAS", createArguments(arg))
	p, e := vsl.sc.conn.sendMessage(pr)
	res := &krpc.Response{}
	proto.Unmarshal(p, res)
	r = util.ByteToBool(res.GetResults()[0].GetValue())
	return
}

//SetSAS sets the state of the given control unit's SAS, true to activate
func (vsl *Vessel) SetSAS(state bool) (e error) {
	s := util.BoolToByte(state)
	arg := [][]byte{vsl.vessel, s}
	pr := createRequest("SpaceCenter", "Control_set_SAS", createArguments(arg))

	_, e = vsl.sc.conn.sendMessage(pr)
	return
}

//GetThrottle returns the Throtlle of the given control unit as float value between 0 and 1
func (vsl *Vessel) GetThrottle() (val float32, e error) {
	arg := [][]byte{vsl.control}
	pr := createRequest("SpaceCenter", "Control_get_Throttle", createArguments(arg))
	p, e := vsl.sc.conn.sendMessage(pr)
	if e != nil {
		return
	}
	res := &krpc.Response{}
	proto.Unmarshal(p, res)
	val = util.ByteToFloat32(res.GetResults()[0].GetValue())
	return
}

//SetThrottle sets the Throtlle of the given control unit as float value between 0 and 1
func (vsl *Vessel) SetThrottle(val float32) (e error) {
	arg := [][]byte{vsl.control, util.Float32toByte(val)}
	pr := createRequest("SpaceCenter", "Control_set_Throttle", createArguments(arg))
	_, e = vsl.sc.conn.sendMessage(pr)

	return
}

func (vsl *Vessel) GetActionGroup(group []byte) (e error) {
	//// TODO:
	return
}

func (vsl *Vessel) SetActionGroup(group []byte, state bool) (e error) {
	//// TODO:
	return
}

func (vsl *Vessel) ToggleActionGroup(group []byte) (e error) {
	//// TODO:
	return
}