amethyst/apps/amethyst/lib/states/macros.ex

# Amethyst - An experimental Minecraft server written in Elixir.
# Copyright (C) 2024 KodiCraft
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.

# TODO!!!: REDO THIS WHOLE THING AGAIN IT'S A MESS

defmodule Amethyst.ConnectionState.Macros do
  @moduledoc """
  Useful macros for defining packets.
  """
  require Logger
  defmacro defpacket_serverbound(name, id, version, signature, where \\ true) do
    quote do
      @impl true
      def deserialize(unquote(id), unquote(version), data) when unquote(where) do
        {packet, ""} = Amethyst.ConnectionState.Macros.read_signature(data, unquote(signature))
        packet |> Map.put(:packet_type, unquote(name))
      end
    end
  end

  defmacro defpacket_clientbound(name, id, version, signature, where \\ true) do
    quote do
      @impl true
      def serialize(%{packet_type: unquote(name)} = packet, unquote(version)) when unquote(where) do
        # Don't check types if we are in release mode
        if Application.get_env(:amethyst, :release, false) || Amethyst.ConnectionState.Macros.check_type(packet, unquote(signature)) do
          Amethyst.Minecraft.Write.varint(unquote(id)) <> Amethyst.ConnectionState.Macros.write_signature(packet, unquote(signature))
        else
          raise "Invalid packet type for #{unquote(name)}! Got #{inspect(packet)}"
        end
      end
    end
  end

  alias Amethyst.Minecraft.Read
  alias Amethyst.Minecraft.Write

  def read_signature(data, signature) do
    names = Enum.map(signature, fn {name, _type} -> name end)
    {got, rest} = Enum.reduce(signature, Read.start(data), fn {_name, type}, {acc, rest, :reversed} ->
      case type do
        {:optional, {:compound, signature}} ->
          {[exists], rest} = Read.start(rest) |> Read.bool() |> Read.stop()
          if exists do
            {item, rest} = read_signature(rest, signature)
            {[item | acc], rest, :reversed}
          else
            {[nil | acc], rest, :reversed}
          end
        {:optional, {:raw, length}} ->
          {[exists], rest} = Read.start(rest) |> Read.bool() |> Read.stop()
          if exists do
            Read.raw({acc, rest, :reversed}, length)
          else
            {[nil | acc], rest, :reversed}
          end
        {:optional, t} ->
          {[exists], rest} = Read.start(rest) |> Read.bool() |> Read.stop()
          if exists do
            apply(Read, t, [{acc, rest, :reversed}])
          else
            {[nil | acc], rest, :reversed}
          end
        {:fixed_bitset, length} ->
          Read.fixed_bitset({acc, rest, :reversed}, length)
        {:raw, length} ->
          Read.raw({acc, rest, :reversed}, length)
        {:array, signature} ->
          {[count], rest} = Read.start(rest) |> Read.varint() |> Read.stop()
          if count == 0 do
            {[[] | acc], rest, :reversed}
          else
            {items, rest} = Enum.reduce(1..count, {[], rest}, fn _, {acc, rest} ->
                {item, rest} = read_signature(rest, signature)
                {[item | acc], rest}
            end)
            {[Enum.reverse(items) | acc], rest, :reversed}
          end
        t -> apply(Read, t, [{acc, rest, :reversed}])
      end
    end) |> Read.stop()

    {Enum.zip(names, got) |> Map.new(), rest}
  end

  def write_signature(packet, signature) do
    Enum.reduce(signature, "", fn {name, type}, acc ->
      case type do
        {:optional, {:compound, signature}} ->
          case Map.get(packet, name) do
            nil -> acc <> Write.bool(false)
            _ -> acc <> Write.bool(true) <> write_signature(Map.get(packet, name), signature)
          end
        {:optional, t} ->
          case Map.get(packet, name) do
            nil -> acc <> Write.bool(false)
            _ -> acc <> Write.bool(true) <> apply(Write, t, [Map.get(packet, name)])
          end
        {:array, signature} ->
          acc <> Write.varint(Enum.count(Map.get(packet, name))) <>
          Enum.reduce(Map.get(packet, name), "", fn item, acc ->
              acc <> write_signature(item, signature)
          end)
        {:literal, type, value} -> acc <> apply(Write, type, [value])
        t -> acc <> apply(Write, t, [Map.get(packet, name)])
      end
    end)
  end

  def check_type(packet, signature) do
    try do
      Enum.all?(signature, fn {name, type} ->
        case Map.get(packet, name, :missing) do
          :missing ->
            if is_tuple(type) && elem(type, 0) == :literal do
              true
            else
              throw {:missing, name}
            end
          value -> case type_matches(value, type) do
            true -> true
            false -> throw {:mismatch, name, value, type}
          end
        end
      end)
    catch
      reason ->
        Logger.debug("Found invalid packet type: #{inspect(reason)}")
        false
    end
  end

  def type_matches(value, :bool) when is_boolean(value), do: true
  def type_matches(value, :byte) when is_integer(value) and value in -128..127, do: true
  def type_matches(value, :ubyte) when is_integer(value) and value in 0..255, do: true
  def type_matches(value, :short) when is_integer(value) and value in -32_768..32_767, do: true
  def type_matches(value, :ushort) when is_integer(value) and value in 0..65_535, do: true
  def type_matches(value, :int) when is_integer(value) and value in -2_147_483_648..2_147_483_647, do: true
  def type_matches(value, :long) when is_integer(value) and value in -9_223_372_036_854_775_808..9_223_372_036_854_775_807, do: true
  def type_matches(value, :float) when is_number(value), do: true
  def type_matches(value, :double) when is_number(value), do: true
  def type_matches(value, :varint) when is_integer(value) and value in -2_147_483_648..2_147_483_647, do: true
  def type_matches(value, :varlong) when is_integer(value) and value in -9_223_372_036_854_775_808..9_223_372_036_854_775_807, do: true
  def type_matches(value, :uuid) when is_binary(value) and byte_size(value) == 36, do: true
  def type_matches(value, :string) when is_binary(value), do: true
  def type_matches(value, :raw) when is_binary(value), do: true
  def type_matches(value, :byte_array) when is_binary(value), do: true
  def type_matches({x, y, z}, :position) when
          is_integer(x) and x in -33_554_432..33_554_431 and
          is_integer(y) and y in -2048..2047 and
          is_integer(z) and z in -33_554_432..33_554_431, do: true
  def type_matches(value, :nbt), do: Amethyst.NBT.Write.check_type(value)
  def type_matches(value, :json) do
    case Jason.encode(value) do
      {:ok, _} -> true
      _ -> false
    end
  end
  def type_matches(value, {:optional, _type}) when is_nil(value), do: true
  def type_matches(value, {:optional, type}), do: type_matches(value, type)
  def type_matches(value, {:array, signature}) when is_list(value), do: Enum.all?(value, fn item -> check_type(item, signature) end)
  def type_matches(value, :bitset) when is_list(value), do: Enum.all?(value, fn item -> is_boolean(item) end)
  def type_matches(value, {:compound, signature}) when is_map(value), do: check_type(value, signature)
  def type_matches(_, _) do
    false
  end
end