strom/generator/helper_append.txt

func TypeToPacketIdentifier(d queser.Direction, s queser.State, t any) (i string) {
	switch d {
	case queser.ToServer:
		switch s {
		case queser.Handshaking:
			i = HandshakingToServerTypeToPacketIdentifier(t)
		case queser.Status:
			i = StatusToServerTypeToPacketIdentifier(t)
		case queser.Login:
			i = LoginToServerTypeToPacketIdentifier(t)
		case queser.Configuration:
			i = ConfigurationToServerTypeToPacketIdentifier(t)
		case queser.Play:
			i = PlayToServerTypeToPacketIdentifier(t)
		}
	case queser.ToClient:
		switch s {
		case queser.Handshaking:
			i = HandshakingToClientTypeToPacketIdentifier(t)
		case queser.Status:
			i = StatusToClientTypeToPacketIdentifier(t)
		case queser.Login:
			i = LoginToClientTypeToPacketIdentifier(t)
		case queser.Configuration:
			i = ConfigurationToClientTypeToPacketIdentifier(t)
		case queser.Play:
			i = PlayToClientTypeToPacketIdentifier(t)
		}
	}
	return
}

func PacketIdentifierToType(d queser.Direction, s queser.State, i string) (t any) {
	switch d {
	case queser.ToServer:
		switch s {
		case queser.Handshaking:
			t = HandshakingToServerPacketIdentifierToType(i)
		case queser.Status:
			t = StatusToServerPacketIdentifierToType(i)
		case queser.Login:
			t = LoginToServerPacketIdentifierToType(i)
		case queser.Configuration:
			t = ConfigurationToServerPacketIdentifierToType(i)
		case queser.Play:
			t = PlayToServerPacketIdentifierToType(i)
		}
	case queser.ToClient:
		switch s {
		case queser.Handshaking:
			t = HandshakingToClientPacketIdentifierToType(i)
		case queser.Status:
			t = StatusToClientPacketIdentifierToType(i)
		case queser.Login:
			t = LoginToClientPacketIdentifierToType(i)
		case queser.Configuration:
			t = ConfigurationToClientPacketIdentifierToType(i)
		case queser.Play:
			t = PlayToClientPacketIdentifierToType(i)
		}
	}
	return
}

func DecodePacket(d queser.Direction, s queser.State, r io.Reader) (params any, err error) {
	switch d {
	case queser.ToServer:
		switch s {
		case queser.Handshaking:
			var packet HandshakingToServerPacket
			packet, err = HandshakingToServerPacket{}.Decode(r)
			if err != nil {
				return
			}
			params = packet.Params
		case queser.Status:
			var packet StatusToServerPacket
			packet, err = StatusToServerPacket{}.Decode(r)
			if err != nil {
				return
			}
			params = packet.Params
		case queser.Login:
			var packet LoginToServerPacket
			packet, err = LoginToServerPacket{}.Decode(r)
			if err != nil {
				return
			}
			params = packet.Params
		case queser.Configuration:
			var packet ConfigurationToServerPacket
			packet, err = ConfigurationToServerPacket{}.Decode(r)
			if err != nil {
				return
			}
			params = packet.Params
		case queser.Play:
			var packet PlayToServerPacket
			packet, err = PlayToServerPacket{}.Decode(r)
			if err != nil {
				return
			}
			params = packet.Params
		}
	case queser.ToClient:
		switch s {
		case queser.Handshaking:
			var packet HandshakingToClientPacket
			packet, err = HandshakingToClientPacket{}.Decode(r)
			if err != nil {
				return
			}
			params = packet.Params
		case queser.Status:
			var packet StatusToClientPacket
			packet, err = StatusToClientPacket{}.Decode(r)
			if err != nil {
				return
			}
			params = packet.Params
		case queser.Login:
			var packet LoginToClientPacket
			packet, err = LoginToClientPacket{}.Decode(r)
			if err != nil {
				return
			}
			params = packet.Params
		case queser.Configuration:
			var packet ConfigurationToClientPacket
			packet, err = ConfigurationToClientPacket{}.Decode(r)
			if err != nil {
				return
			}
			params = packet.Params
		case queser.Play:
			var packet PlayToClientPacket
			packet, err = PlayToClientPacket{}.Decode(r)
			if err != nil {
				return
			}
			params = packet.Params
		}
	}
	return
}

func EncodePacket(d queser.Direction, s queser.State, i string, p any, w io.Writer) (err error) {
	switch d {
	case queser.ToServer:
		switch s {
		case queser.Handshaking:
			err = HandshakingToServerPacket{i, p}.Encode(w)
		case queser.Status:
			err = StatusToServerPacket{i, p}.Encode(w)
		case queser.Login:
			err = LoginToServerPacket{i, p}.Encode(w)
		case queser.Configuration:
			err = ConfigurationToServerPacket{i, p}.Encode(w)
		case queser.Play:
			err = PlayToServerPacket{i, p}.Encode(w)
		}
	case queser.ToClient:
		switch s {
		case queser.Handshaking:
			err = HandshakingToClientPacket{i, p}.Encode(w)
		case queser.Status:
			err = StatusToClientPacket{i, p}.Encode(w)
		case queser.Login:
			err = LoginToClientPacket{i, p}.Encode(w)
		case queser.Configuration:
			err = ConfigurationToClientPacket{i, p}.Encode(w)
		case queser.Play:
			err = PlayToClientPacket{i, p}.Encode(w)
		}
	}
	return
}