xY4KOUB

package message


import "encoding/binary"

func (w *Writer) iceWallState(s IceWallState) {
 w.U32(s.ID)
 w.I32(s.WallType)
 w.I32(s.HP)
 w.vec3i(r1000(s.Pos.X), r1000(s.Pos.Y), r1000(s.Pos.Z))
 w.I16(r100(s.Rot.X))
 w.I16(r100(s.Rot.Y))
 w.I16(r100(s.Rot.Z))
 w.I16(r100(s.Rot.W))
 w.U16(s.MovePlatformID)
 w.U32(s.RepID)
 w.Bool(s.HealthExtra)
 w.Bool(s.Flag)
}

type IceWallState struct {
 ID             uint32
 WallType       int32
 HP             int32
 Pos            Vec3
 Rot            Quat
 MovePlatformID uint16
 RepID          uint32
 HealthExtra    bool
 Flag           bool
}

func AddIcewall(s IceWallState, state byte) []byte {
 w := &Writer{}
 w.iceWallState(s)
 w.U8(state)
 return w.B
}

func ResyncIcewalls(walls []IceWallState) []byte {
 w := &Writer{}
 w.I16(int16(len(walls)))
 for _, s := range walls {
  w.iceWallState(s)
 }
 return w.B
}

func RemoveIcewall(id uint32) []byte {
 w := &Writer{}
 w.U32(id)
 return w.B
}

type PlaceIcewallReq struct {
 Unique         uint32
 WallType       int32
 Pos            Vec3 
 Rot            Quat
 MovePlatformID byte
}

func ParsePlaceIcewallReq(payload []byte) (PlaceIcewallReq, bool) {
 if len(payload) < 29 {
  return PlaceIcewallReq{}, false
 }
 return PlaceIcewallReq{
  Unique:   binary.LittleEndian.Uint32(payload[0:]),
  WallType: int32(binary.LittleEndian.Uint32(payload[4:])),
  Pos: Vec3{
   X: float64(int32(binary.LittleEndian.Uint32(payload[8:]))) / 1000,
   Y: float64(int32(binary.LittleEndian.Uint32(payload[12:]))) / 1000,
   Z: float64(int32(binary.LittleEndian.Uint32(payload[16:]))) / 1000,
  },
  Rot: Quat{
   X: float64(int16(binary.LittleEndian.Uint16(payload[20:]))) / 100,
   Y: float64(int16(binary.LittleEndian.Uint16(payload[22:]))) / 100,
   Z: float64(int16(binary.LittleEndian.Uint16(payload[24:]))) / 100,
   W: float64(int16(binary.LittleEndian.Uint16(payload[26:]))) / 100,
  },
  MovePlatformID: payload[28],
 }, true
}

type IcewallDamageReq struct {
 WallID uint32
 Damage uint32
 Weapon uint32
}

func ParseIcewallDamageReq(payload []byte) (IcewallDamageReq, bool) {
 if len(payload) < 10 {
  return IcewallDamageReq{}, false
 }
 r := IcewallDamageReq{
  WallID: binary.LittleEndian.Uint32(payload[0:]),
  Damage: binary.LittleEndian.Uint32(payload[6:]),
 }
 if len(payload) >= 22 {
  r.Weapon = binary.LittleEndian.Uint32(payload[18:])
 }
 return r, true
}