amethyst/apps/amethyst/lib/states/configuration.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/>.

defmodule Amethyst.ConnectionState.Configuration do
  require Amethyst.ConnectionState.Macros
  alias Amethyst.ConnectionState.Macros

  require Logger

  @moduledoc """
  This module contains the packets and logic for the Configuration state.
  """
  Macros.defpacket_clientbound :cookie_request, 0x00, 767, [identifier: :string]
  Macros.defpacket_clientbound :clientbound_plugin_message, 0x01, 767, [channel: :string, data: :raw]
  Macros.defpacket_clientbound :disconnect, 0x02, 767, [reason: :nbt]
  Macros.defpacket_clientbound :finish_configuration, 0x03, 767, []
  Macros.defpacket_clientbound :clientbound_keep_alive, 0x04, 767, [id: :long]
  Macros.defpacket_clientbound :ping, 0x05, 767, [id: :int]
  Macros.defpacket_clientbound :reset_chat, 0x06, 767, []
  Macros.defpacket_clientbound :registry_data, 0x07, 767, [
    id: :string,
    entries: {:array, [
      id: :string,
      data: {:optional, :nbt}
    ]}
  ]
  Macros.defpacket_clientbound :remove_resource_pack, 0x08, 767, [
    uuid: {:optional, :uuid}
  ]
  Macros.defpacket_clientbound :add_resource_pack, 0x09, 767, [
    uuid: :uuid,
    url: :string,
    hash: :string,
    forced: :bool,
    prompt_message: {:optional, :string}
  ]
  Macros.defpacket_clientbound :store_cookie, 0x0A, 767, [identifier: :string, payload: :byte_array]
  Macros.defpacket_clientbound :transfer, 0x0B, 767, [host: :string, port: :varint]
  Macros.defpacket_clientbound :feature_flags, 0x0C, 767, [flags: {:array, [flag: :string]}]
  Macros.defpacket_clientbound :update_tags, 0x0D, 767, [
    tags: {:array, [
      registry: :string,
      tags: {:array, [
        name: :string,
        entries: {:array, [id: :varint]}
      ]}
    ]}
  ]
  Macros.defpacket_clientbound :clientbound_known_packs, 0x0E, 767, [
    packs: {:array, [
      namespace: :string,
      id: :string,
      version: :string
    ]}
  ]
  Macros.defpacket_clientbound :custom_report_details, 0x0F, 767, [
    details: {:array, [
      title: :string,
      desctioption: :string
    ]}
  ]
  Macros.defpacket_clientbound :server_links, 0x10, 767, [
    links: {:array, [
      is_builtin: :bool,
      label: :string,
      url: :string
    ]}
  ]

  Macros.defpacket_serverbound :client_information, 0x00, 767, [
    locale: :string,
    view_distance: :byte,
    chat_mode: :varint,
    chat_colors: :bool,
    displayed_skin_parts: :byte,
    main_hand: :varint,
    text_filtering: :bool,
    allow_server_listings: :bool
  ]
  Macros.defpacket_serverbound :cookie_response, 0x01, 767, [
    key: :string,
    payload: {:optional, :byte_array}
  ]
  Macros.defpacket_serverbound :serverbound_plugin_message, 0x02, 767, [channel: :string, data: :raw]
  Macros.defpacket_serverbound :acknowledge_finish_configuration, 0x03, 767, []
  Macros.defpacket_serverbound :serverbound_keep_alive, 0x04, 767, [id: :long]
  Macros.defpacket_serverbound :pong, 0x05, 767, [id: :int]
  Macros.defpacket_serverbound :resource_pack_response, 0x06, 767, [uuid: :uuid, result: :varint]
  Macros.defpacket_serverbound :serverbound_known_packs, 0x07, 767, [
    packs: {:array, [
      namespace: :string,
      id: :string,
      version: :string
    ]}
  ]

  def handle(%{packet_type: :serverbound_plugin_message, channel: "minecraft:brand", data: data}, 767, state) do
    {[string], ""} = Amethyst.Minecraft.Read.start(data) |> Amethyst.Minecraft.Read.string() |> Amethyst.Minecraft.Read.stop()
    Logger.debug("Received brand: #{string}")
    send(self(), {:send_packet, %{
      packet_type: :clientbound_plugin_message,
      channel: "minecraft:brand",
      data: Amethyst.Minecraft.Write.string("Amethyst")
    }})
    state |> Map.put(:brand, string)
  end

  def handle(%{
    packet_type: :client_information,
    locale: locale,
    view_distance: view_distance,
    chat_mode: chat_mode,
    chat_colors: chat_colors,
    displayed_skin_parts: displayed_skin_parts,
    main_hand: main_hand,
    text_filtering: text_filtering,
    allow_server_listings: allow_server_listings
  }, 767, state) do
    Logger.debug("Received client information")
    send(self(), {:send_packet, %{
      packet_type: :feature_flags,
      flags: []
    }})
    send(self(), {:send_packet, %{
      packet_type: :clientbound_known_packs,
      packs: [%{namespace: "minecraft", id: "base", version: "1.21"}]
    }})
    state
    |> Map.put(:locale, locale)
    |> Map.put(:view_distance, view_distance)
    |> Map.put(:chat_mode, chat_mode)
    |> Map.put(:chat_colors, chat_colors)
    |> Map.put(:displayed_skin_parts, displayed_skin_parts)
    |> Map.put(:main_hand, main_hand)
    |> Map.put(:text_filtering, text_filtering)
    |> Map.put(:allow_server_listings, allow_server_listings)
  end

  def handle(%{packet_type: :serverbound_known_packs, packs: _packs}, 767, _state) do
    Logger.debug("Received known packs")
    import Amethyst.NBT.Write
    # TODO: Of course, the registries shouldn't be hard-coded
    send(self(), {:send_packet, %{
      packet_type: :registry_data,
      id: "minecraft:dimension_type",
      entries: [
        %{id: "amethyst:basic", data: compound(%{
          "has_skylight" => byte(1),
          "has_ceiling" => byte(0),
          "ultrawarm" => byte(0),
          "natural" => byte(1),
          "coordinate_scale" => float(1.0),
          "bed_works" => byte(1),
          "respawn_anchor_works" => byte(1),
          "min_y" => int(0),
          "height" => int(256),
          "logical_height" => int(256),
          "infiniburn" => string("#"),
          "effects" => string("minecraft:overworld"),
          "ambient_light" => float(0.0),
          "piglin_safe" => byte(0),
          "has_raids" => byte(1),
          "monster_spawn_light_level" => int(0),
          "monster_spawn_block_light_limit" => int(0)
        })}
      ]
    }})
    send(self(), {:send_packet, %{
      packet_type: :registry_data,
      id: "minecraft:painting_variant", entries: [
        %{id: "minecraft:kebab", data: compound(%{
          "asset_id" => string("minecraft:kebab"),
          "height" => int(1),
          "width" => int(1),
        })}
      ]
    }})
    send(self(), {:send_packet, %{
      packet_type: :registry_data,
      id: "minecraft:wolf_variant",
      entries: [
        %{id: "minecraft:wolf_ashen", data: compound(%{
          "wild_texture" => string("minecraft:entity/wolf/wolf_ashen"),
          "tame_texture" => string("minecraft:entity/wolf/wolf_ashen_tame"),
          "angry_texture" => string("minecraft:entity/wolf/wolf_ashen_angry"),
          "biomes" => string("amethyst:basic"),
        })}
      ]
    }})
    # https://gist.github.com/WinX64/ab8c7a8df797c273b32d3a3b66522906 minecraft:plains
    basic_biome = compound(%{
      "effects" => compound(%{
        "sky_color" => int(7_907_327),
        "water_fog_color" => int(329_011),
        "fog_color" => int(12_638_463),
        "water_color" => int(4_159_204),
        "mood_sound" => compound(%{
          "tick_delay" => int(6000),
          "offset" => float(2.0),
          "sound" => string("minecraft:ambient.cave"),
          "block_search_extent" => int(8)
        }),
      }),
      "has_precipitation" => byte(1),
      "temperature" => float(0.8),
      "downfall" => float(0.4),
    })
    send(self(), {:send_packet, %{
      packet_type: :registry_data,
      id: "minecraft:worldgen/biome",
      entries: [
        %{id: "amethyst:basic", data: basic_biome},
        %{id: "minecraft:plains", data: basic_biome}
      ]
    }})
    # this game sucks
    generic_damage = compound(%{
      "scaling" => string("when_caused_by_living_non_player"),
      "exhaustion" => float(0.0),
      "message_id" => string("generic")
    })
    send(self(), {:send_packet, %{
      packet_type: :registry_data,
      id: "minecraft:damage_type",
      entries: [
        %{id: "minecraft:in_fire", data: generic_damage},
        %{id: "minecraft:campfire", data: generic_damage},
        %{id: "minecraft:lightning_bolt", data: generic_damage},
        %{id: "minecraft:on_fire", data: generic_damage},
        %{id: "minecraft:lava", data: generic_damage},
        %{id: "minecraft:cramming", data: generic_damage},
        %{id: "minecraft:drown", data: generic_damage},
        %{id: "minecraft:starve", data: generic_damage},
        %{id: "minecraft:cactus", data: generic_damage},
        %{id: "minecraft:fall", data: generic_damage},
        %{id: "minecraft:fly_into_wall", data: generic_damage},
        %{id: "minecraft:out_of_world", data: generic_damage},
        %{id: "minecraft:generic", data: generic_damage},
        %{id: "minecraft:magic", data: generic_damage},
        %{id: "minecraft:wither", data: generic_damage},
        %{id: "minecraft:dragon_breath", data: generic_damage},
        %{id: "minecraft:dry_out", data: generic_damage},
        %{id: "minecraft:sweet_berry_bush", data: generic_damage},
        %{id: "minecraft:freeze", data: generic_damage},
        %{id: "minecraft:stalagmite", data: generic_damage},
        %{id: "minecraft:outside_border", data: generic_damage},
        %{id: "minecraft:generic_kill", data: generic_damage},
        %{id: "minecraft:hot_floor", data: generic_damage},
        %{id: "minecraft:in_wall", data: generic_damage},
      ]
    }})
    send(self(), {:send_packet, %{packet_type: :finish_configuration}})
    :ok
  end

  def handle(%{packet_type: :acknowledge_finish_configuration}, 767, state) do
    Logger.debug("Received acknowledge finish configuration")
    send(self(), {:set_state, Amethyst.ConnectionState.Play})

    game = Application.fetch_env!(:amethyst, :default_game) |> Amethyst.GameCoordinator.find_or_create()
    state = state |> Map.put(:game, game)
    login = Amethyst.Game.login(game, state)
    case login do
      :reject ->
        send(self(), {:disconnect, "Default game rejected connection"})
        :ok
      {:accept, {x, y, z}, {yaw, pitch}} ->
        send(self(), {:send_packet, %{
          packet_type: :login,
          entity_id: 0,
          is_hardcore: false,
          dimensions: [%{name: "minecraft:overworld"}],
          max_players: 0,
          view_distance: 16,
          simulation_distance: 16,
          reduced_debug_info: false,
          enable_respawn_screen: true,
          do_limited_crafting: false,
          dimension_type: 0,
          dimension_name: "minecraft:overworld",
          hashed_seed: 0,
          game_mode: 1,
          previous_game_mode: -1,
          is_debug: false,
          is_flat: false,
          death_location: nil,
          portal_cooldown: 0,
          enforces_secure_chat: false
        }})
        send(self(), {:send_packet, %{
          packet_type: :synchronize_player_position,
          x: x, y: y, z: z, yaw: yaw, pitch: pitch, teleport_id: 0, flags: 0x00
        }})
        send(self(), {:send_packet, Amethyst.ConnectionState.Play.ge_start_waiting_for_level_chunks(767)})
        send(self(), {:send_packet, %{packet_type: :set_center_chunk,
          chunk_x: div(floor(x), 16),
          chunk_z: div(floor(z), 16)
        }})
        send(self(), {:set_position, {x, y, z}})
        send(self(), {:send_packet, %{packet_type: :player_info_update_add_player,
          players: [
            %{
              uuid: Map.get(state, :uuid),
              name: Map.get(state, :name),
              properties: Map.get(state, :properties) |>
                Enum.map(fn prop -> %{name: prop["name"], value: prop["value"], signature: Map.get(prop, "signature")} end)
            }
          ]
        }})
        # Begin keepalive loop
        # TODO: Put it under some supervisor
        me = self()
        pid = spawn(fn -> Amethyst.ConnectionState.Play.keepalive_loop(me) end)
        state |> Map.put(:keepalive, pid)
    end
  end

  def disconnect(reason) do
    %{packet_type: :disconnect, reason: {:compound, %{
      "text" => {:string, reason}
    }}}
  end
end