port over some more

lib/odinsea/database/schema/achievement.ex

@@ -0,0 +1,25 @@
+defmodule Odinsea.Database.Schema.Achievement do
+  @moduledoc """
+  Ecto schema for the achievements table.
+  Represents character achievements.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key false
+  schema "achievements" do
+    field :achievementid, :integer, primary_key: true
+    field :charid, :integer, primary_key: true
+    field :accountid, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for creating an achievement.
+  """
+  def changeset(achievement, attrs) do
+    achievement
+    |> cast(attrs, [:achievementid, :charid, :accountid])
+    |> validate_required([:achievementid, :charid])
+  end
+end

lib/odinsea/database/schema/alliance.ex

@@ -0,0 +1,55 @@
+defmodule Odinsea.Database.Schema.Alliance do
+  @moduledoc """
+  Ecto schema for the alliances table.
+  Represents guild alliances.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "alliances" do
+    field :name, :string
+    field :leaderid, :integer
+    field :guild1, :integer
+    field :guild2, :integer
+    field :guild3, :integer, default: 0
+    field :guild4, :integer, default: 0
+    field :guild5, :integer, default: 0
+    field :rank1, :string, default: "Master"
+    field :rank2, :string, default: "Jr.Master"
+    field :rank3, :string, default: "Member"
+    field :rank4, :string, default: "Member"
+    field :rank5, :string, default: "Member"
+    field :capacity, :integer, default: 2
+    field :notice, :string, default: ""
+  end
+
+  @doc """
+  Changeset for creating an alliance.
+  """
+  def creation_changeset(alliance, attrs) do
+    alliance
+    |> cast(attrs, [:name, :leaderid, :guild1, :guild2, :capacity])
+    |> validate_required([:name, :leaderid, :guild1, :guild2])
+    |> validate_length(:name, min: 1, max: 13)
+    |> unique_constraint(:name)
+  end
+
+  @doc """
+  Changeset for updating alliance guilds.
+  """
+  def guilds_changeset(alliance, attrs) do
+    alliance
+    |> cast(attrs, [:guild1, :guild2, :guild3, :guild4, :guild5])
+  end
+
+  @doc """
+  Changeset for updating alliance ranks.
+  """
+  def ranks_changeset(alliance, attrs) do
+    alliance
+    |> cast(attrs, [:rank1, :rank2, :rank3, :rank4, :rank5])
+  end
+end

lib/odinsea/database/schema/android.ex

@@ -0,0 +1,26 @@
+defmodule Odinsea.Database.Schema.Android do
+  @moduledoc """
+  Ecto schema for the androids table.
+  Represents android companion data.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:uniqueid, :id, autogenerate: true}
+
+  schema "androids" do
+    field :name, :string, default: "Android"
+    field :hair, :integer, default: 0
+    field :face, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for creating/updating an android.
+  """
+  def changeset(android, attrs) do
+    android
+    |> cast(attrs, [:name, :hair, :face])
+    |> validate_required([:name])
+  end
+end

lib/odinsea/database/schema/battle_log.ex

@@ -0,0 +1,27 @@
+defmodule Odinsea.Database.Schema.BattleLog do
+  @moduledoc """
+  Ecto schema for the battlelog table.
+  Represents PvP battle records between accounts.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:battlelogid, :id, autogenerate: true}
+  @timestamps_opts [inserted_at: :when, updated_at: false]
+
+  schema "battlelog" do
+    field :accid, :integer, default: 0
+    field :accid_to, :integer, default: 0
+    field :when, :naive_datetime
+  end
+
+  @doc """
+  Changeset for creating a battle log entry.
+  """
+  def changeset(battle_log, attrs) do
+    battle_log
+    |> cast(attrs, [:accid, :accid_to])
+    |> validate_required([:accid, :accid_to])
+  end
+end

lib/odinsea/database/schema/bbs_reply.ex

@@ -0,0 +1,33 @@
+defmodule Odinsea.Database.Schema.BbsReply do
+  @moduledoc """
+  Ecto schema for the bbs_replies table.
+  Represents guild BBS thread replies.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:replyid, :id, autogenerate: true}
+
+  schema "bbs_replies" do
+    field :threadid, :integer
+    field :postercid, :integer
+    field :timestamp, :integer
+    field :content, :string, default: ""
+    field :guildid, :integer, default: 0
+
+    belongs_to :bbs_thread, Odinsea.Database.Schema.BbsThread,
+      foreign_key: :threadid,
+      references: :threadid,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating a BBS reply.
+  """
+  def changeset(bbs_reply, attrs) do
+    bbs_reply
+    |> cast(attrs, [:threadid, :postercid, :timestamp, :content, :guildid])
+    |> validate_required([:threadid, :postercid, :timestamp])
+  end
+end

lib/odinsea/database/schema/bbs_thread.ex

@@ -0,0 +1,32 @@
+defmodule Odinsea.Database.Schema.BbsThread do
+  @moduledoc """
+  Ecto schema for the bbs_threads table.
+  Represents guild BBS threads.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:threadid, :id, autogenerate: true}
+
+  schema "bbs_threads" do
+    field :postercid, :integer
+    field :name, :string, default: ""
+    field :timestamp, :integer
+    field :icon, :integer
+    field :startpost, :string
+    field :guildid, :integer
+    field :localthreadid, :integer
+
+    has_many :bbs_replies, Odinsea.Database.Schema.BbsReply, foreign_key: :threadid
+  end
+
+  @doc """
+  Changeset for creating a BBS thread.
+  """
+  def creation_changeset(bbs_thread, attrs) do
+    bbs_thread
+    |> cast(attrs, [:postercid, :name, :timestamp, :icon, :startpost, :guildid, :localthreadid])
+    |> validate_required([:postercid, :timestamp, :guildid, :localthreadid])
+  end
+end

lib/odinsea/database/schema/buddy.ex

@@ -0,0 +1,32 @@
+defmodule Odinsea.Database.Schema.Buddy do
+  @moduledoc """
+  Ecto schema for the buddies table.
+  Represents buddy list entries for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "buddies" do
+    field :characterid, :integer
+    field :buddyid, :integer
+    field :pending, :integer, default: 0
+    field :groupname, :string, default: "ETC"
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating a buddy entry.
+  """
+  def changeset(buddy, attrs) do
+    buddy
+    |> cast(attrs, [:characterid, :buddyid, :pending, :groupname])
+    |> validate_required([:characterid, :buddyid])
+  end
+end

lib/odinsea/database/schema/cashshop_limit_sell.ex

@@ -0,0 +1,24 @@
+defmodule Odinsea.Database.Schema.CashshopLimitSell do
+  @moduledoc """
+  Ecto schema for the cashshop_limit_sell table.
+  Represents limited sale quantities for cash shop items.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:serial, :integer, autogenerate: false}
+
+  schema "cashshop_limit_sell" do
+    field :amount, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for cashshop limit sell.
+  """
+  def changeset(cashshop_limit_sell, attrs) do
+    cashshop_limit_sell
+    |> cast(attrs, [:serial, :amount])
+    |> validate_required([:serial])
+  end
+end

lib/odinsea/database/schema/cashshop_modified_item.ex

@@ -0,0 +1,40 @@
+defmodule Odinsea.Database.Schema.CashshopModifiedItem do
+  @moduledoc """
+  Ecto schema for the cashshop_modified_items table.
+  Represents modified cash shop items (discounts, etc).
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:serial, :integer, autogenerate: false}
+
+  schema "cashshop_modified_items" do
+    field :discount_price, :integer, default: -1
+    field :mark, :integer, default: -1
+    field :showup, :integer, default: 0
+    field :itemid, :integer, default: 0
+    field :priority, :integer, default: 0
+    field :package, :integer, default: 0
+    field :period, :integer, default: 0
+    field :gender, :integer, default: 0
+    field :count, :integer, default: 0
+    field :meso, :integer, default: 0
+    field :unk_1, :integer, default: 0
+    field :unk_2, :integer, default: 0
+    field :unk_3, :integer, default: 0
+    field :extra_flags, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for cashshop modified items.
+  """
+  def changeset(cashshop_modified_item, attrs) do
+    cashshop_modified_item
+    |> cast(attrs, [
+      :serial, :discount_price, :mark, :showup, :itemid, :priority,
+      :package, :period, :gender, :count, :meso, :unk_1, :unk_2, :unk_3, :extra_flags
+    ])
+    |> validate_required([:serial])
+  end
+end

lib/odinsea/database/schema/character_slot.ex

@@ -0,0 +1,26 @@
+defmodule Odinsea.Database.Schema.CharacterSlot do
+  @moduledoc """
+  Ecto schema for the character_slots table.
+  Represents character slot counts per world.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "character_slots" do
+    field :accid, :integer, default: 0
+    field :worldid, :integer, default: 0
+    field :charslots, :integer, default: 6
+  end
+
+  @doc """
+  Changeset for creating/updating character slots.
+  """
+  def changeset(character_slot, attrs) do
+    character_slot
+    |> cast(attrs, [:accid, :worldid, :charslots])
+    |> validate_required([:accid, :worldid])
+  end
+end

lib/odinsea/database/schema/cheat_log.ex

@@ -0,0 +1,29 @@
+defmodule Odinsea.Database.Schema.CheatLog do
+  @moduledoc """
+  Ecto schema for the cheatlog table.
+  Represents cheat/anti-cheat log entries.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+  @timestamps_opts [inserted_at: :lastoffensetime, updated_at: false]
+
+  schema "cheatlog" do
+    field :characterid, :integer, default: 0
+    field :offense, :string
+    field :count, :integer, default: 0
+    field :lastoffensetime, :naive_datetime
+    field :param, :string
+  end
+
+  @doc """
+  Changeset for creating a cheat log entry.
+  """
+  def changeset(cheat_log, attrs) do
+    cheat_log
+    |> cast(attrs, [:characterid, :offense, :count, :param])
+    |> validate_required([:characterid, :offense])
+  end
+end

lib/odinsea/database/schema/compensation_log.ex

@@ -0,0 +1,26 @@
+defmodule Odinsea.Database.Schema.CompensationLog do
+  @moduledoc """
+  Ecto schema for the compensationlog_confirmed table.
+  Represents compensation records for players.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:chrname, :string, autogenerate: false}
+
+  schema "compensationlog_confirmed" do
+    field :donor, :integer, default: 0
+    field :value, :integer, default: 0
+    field :taken, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for compensation log.
+  """
+  def changeset(compensation_log, attrs) do
+    compensation_log
+    |> cast(attrs, [:chrname, :donor, :value, :taken])
+    |> validate_required([:chrname])
+  end
+end

lib/odinsea/database/schema/cs_item.ex

@@ -0,0 +1,41 @@
+defmodule Odinsea.Database.Schema.CsItem do
+  @moduledoc """
+  Ecto schema for the csitems table.
+  Represents cash shop inventory items.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:inventoryitemid, :integer, autogenerate: false}
+
+  schema "csitems" do
+    field :characterid, :integer
+    field :accountid, :integer
+    field :packageid, :integer
+    field :itemid, :integer, default: 0
+    field :inventorytype, :integer, default: 0
+    field :position, :integer, default: 0
+    field :quantity, :integer, default: 0
+    field :owner, :string
+    field :gm_log, :string, source: :GM_Log
+    field :uniqueid, :integer, default: -1
+    field :flag, :integer, default: 0
+    field :expiredate, :integer, default: -1
+    field :type, :integer, default: 0
+    field :sender, :string, default: ""
+  end
+
+  @doc """
+  Changeset for creating/updating a cash shop item.
+  """
+  def changeset(cs_item, attrs) do
+    cs_item
+    |> cast(attrs, [
+      :inventoryitemid, :characterid, :accountid, :packageid, :itemid,
+      :inventorytype, :position, :quantity, :owner, :gm_log, :uniqueid,
+      :flag, :expiredate, :type, :sender
+    ])
+    |> validate_required([:inventoryitemid, :itemid, :inventorytype, :position, :quantity])
+  end
+end

lib/odinsea/database/schema/donation.ex

@@ -0,0 +1,29 @@
+defmodule Odinsea.Database.Schema.Donation do
+  @moduledoc """
+  Ecto schema for the donation table.
+  Represents donation records.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+  @timestamps_opts [inserted_at: :date, updated_at: false]
+
+  schema "donation" do
+    field :date, :naive_datetime
+    field :ip, :string
+    field :username, :string
+    field :quantity, :integer
+    field :status, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for donation records.
+  """
+  def changeset(donation, attrs) do
+    donation
+    |> cast(attrs, [:ip, :username, :quantity, :status])
+    |> validate_required([:ip, :username])
+  end
+end

lib/odinsea/database/schema/donor_log.ex

@@ -0,0 +1,34 @@
+defmodule Odinsea.Database.Schema.DonorLog do
+  @moduledoc """
+  Ecto schema for the donorlog table.
+  Represents donation transaction logs.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "donorlog" do
+    field :accname, :string, default: ""
+    field :acc_id, :integer, default: 0, source: :accId
+    field :chrname, :string, default: ""
+    field :chr_id, :integer, default: 0, source: :chrId
+    field :log, :string, default: ""
+    field :time, :string, default: ""
+    field :previous_points, :integer, default: 0, source: :previousPoints
+    field :current_points, :integer, default: 0, source: :currentPoints
+  end
+
+  @doc """
+  Changeset for creating a donor log entry.
+  """
+  def changeset(donor_log, attrs) do
+    donor_log
+    |> cast(attrs, [
+      :accname, :acc_id, :chrname, :chr_id, :log, :time,
+      :previous_points, :current_points
+    ])
+    |> validate_required([:acc_id])
+  end
+end

lib/odinsea/database/schema/drop_data.ex

@@ -0,0 +1,29 @@
+defmodule Odinsea.Database.Schema.DropData do
+  @moduledoc """
+  Ecto schema for the drop_data table.
+  Represents monster drop tables.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "drop_data" do
+    field :dropperid, :integer
+    field :itemid, :integer, default: 0
+    field :minimum_quantity, :integer, default: 1
+    field :maximum_quantity, :integer, default: 1
+    field :questid, :integer, default: 0
+    field :chance, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for creating/updating drop data.
+  """
+  def changeset(drop_data, attrs) do
+    drop_data
+    |> cast(attrs, [:dropperid, :itemid, :minimum_quantity, :maximum_quantity, :questid, :chance])
+    |> validate_required([:dropperid, :itemid, :chance])
+  end
+end

lib/odinsea/database/schema/drop_data_global.ex

@@ -0,0 +1,31 @@
+defmodule Odinsea.Database.Schema.DropDataGlobal do
+  @moduledoc """
+  Ecto schema for the drop_data_global table.
+  Represents global drops that apply to all monsters in a continent.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "drop_data_global" do
+    field :continent, :integer
+    field :drop_type, :integer, default: 0, source: :dropType
+    field :itemid, :integer, default: 0
+    field :minimum_quantity, :integer, default: 1
+    field :maximum_quantity, :integer, default: 1
+    field :questid, :integer, default: 0
+    field :chance, :integer, default: 0
+    field :comments, :string
+  end
+
+  @doc """
+  Changeset for creating/updating global drop data.
+  """
+  def changeset(drop_data_global, attrs) do
+    drop_data_global
+    |> cast(attrs, [:continent, :drop_type, :itemid, :minimum_quantity, :maximum_quantity, :questid, :chance, :comments])
+    |> validate_required([:continent, :itemid, :chance])
+  end
+end

lib/odinsea/database/schema/duey_item.ex

@@ -0,0 +1,41 @@
+defmodule Odinsea.Database.Schema.DueyItem do
+  @moduledoc """
+  Ecto schema for the dueyitems table.
+  Represents Duey package items.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:inventoryitemid, :integer, autogenerate: false}
+
+  schema "dueyitems" do
+    field :characterid, :integer
+    field :accountid, :integer
+    field :packageid, :integer
+    field :itemid, :integer, default: 0
+    field :inventorytype, :integer, default: 0
+    field :position, :integer, default: 0
+    field :quantity, :integer, default: 0
+    field :owner, :string
+    field :gm_log, :string, source: :GM_Log
+    field :uniqueid, :integer, default: -1
+    field :flag, :integer, default: 0
+    field :expiredate, :integer, default: -1
+    field :type, :integer, default: 0
+    field :sender, :string, default: ""
+  end
+
+  @doc """
+  Changeset for creating/updating a duey item.
+  """
+  def changeset(duey_item, attrs) do
+    duey_item
+    |> cast(attrs, [
+      :inventoryitemid, :characterid, :accountid, :packageid, :itemid,
+      :inventorytype, :position, :quantity, :owner, :gm_log, :uniqueid,
+      :flag, :expiredate, :type, :sender
+    ])
+    |> validate_required([:inventoryitemid, :itemid, :inventorytype, :position, :quantity])
+  end
+end

lib/odinsea/database/schema/duey_package.ex

@@ -0,0 +1,37 @@
+defmodule Odinsea.Database.Schema.DueyPackage do
+  @moduledoc """
+  Ecto schema for the dueypackages table.
+  Represents Duey packages (mail/delivery system).
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:package_id, :id, autogenerate: true, source: :PackageId}
+
+  schema "dueypackages" do
+    field :reciever_id, :integer, source: :RecieverId
+    field :sender_name, :string, source: :SenderName
+    field :mesos, :integer, default: 0, source: :Mesos
+    field :timestamp, :integer, source: :TimeStamp
+    field :checked, :integer, default: 1, source: :Checked
+    field :type, :integer, source: :Type
+  end
+
+  @doc """
+  Changeset for creating a duey package.
+  """
+  def creation_changeset(duey_package, attrs) do
+    duey_package
+    |> cast(attrs, [:reciever_id, :sender_name, :mesos, :timestamp, :type])
+    |> validate_required([:reciever_id, :sender_name, :type])
+  end
+
+  @doc """
+  Changeset for marking package as checked.
+  """
+  def checked_changeset(duey_package, attrs) do
+    duey_package
+    |> cast(attrs, [:checked])
+  end
+end

lib/odinsea/database/schema/extended_slot.ex

@@ -0,0 +1,25 @@
+defmodule Odinsea.Database.Schema.ExtendedSlot do
+  @moduledoc """
+  Ecto schema for the extendedslots table.
+  Represents extended inventory slots for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "extendedslots" do
+    field :characterid, :integer, default: 0
+    field :item_id, :integer, default: 0, source: :itemId
+  end
+
+  @doc """
+  Changeset for creating an extended slot entry.
+  """
+  def changeset(extended_slot, attrs) do
+    extended_slot
+    |> cast(attrs, [:characterid, :item_id])
+    |> validate_required([:characterid])
+  end
+end

lib/odinsea/database/schema/fame_log.ex

@@ -0,0 +1,32 @@
+defmodule Odinsea.Database.Schema.FameLog do
+  @moduledoc """
+  Ecto schema for the famelog table.
+  Represents fame (reputation) transactions between characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:famelogid, :id, autogenerate: true}
+  @timestamps_opts [inserted_at: :when, updated_at: false]
+
+  schema "famelog" do
+    field :characterid, :integer, default: 0
+    field :characterid_to, :integer, default: 0
+    field :when, :naive_datetime
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating a fame log entry.
+  """
+  def changeset(fame_log, attrs) do
+    fame_log
+    |> cast(attrs, [:characterid, :characterid_to])
+    |> validate_required([:characterid, :characterid_to])
+  end
+end

lib/odinsea/database/schema/familiar.ex

@@ -0,0 +1,34 @@
+defmodule Odinsea.Database.Schema.Familiar do
+  @moduledoc """
+  Ecto schema for the familiars table.
+  Represents familiar data for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "familiars" do
+    field :characterid, :integer, default: 0
+    field :familiar, :integer, default: 0
+    field :name, :string, default: ""
+    field :fatigue, :integer, default: 0
+    field :expiry, :integer, default: 0
+    field :vitality, :integer, default: 0
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating a familiar.
+  """
+  def changeset(familiar, attrs) do
+    familiar
+    |> cast(attrs, [:characterid, :familiar, :name, :fatigue, :expiry, :vitality])
+    |> validate_required([:characterid, :familiar])
+  end
+end

lib/odinsea/database/schema/family.ex

@@ -0,0 +1,33 @@
+defmodule Odinsea.Database.Schema.Family do
+  @moduledoc """
+  Ecto schema for the families table.
+  Represents family data in the game.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:familyid, :id, autogenerate: true}
+
+  schema "families" do
+    field :leaderid, :integer, default: 0
+    field :notice, :string, default: ""
+  end
+
+  @doc """
+  Changeset for creating a family.
+  """
+  def creation_changeset(family, attrs) do
+    family
+    |> cast(attrs, [:leaderid, :notice])
+    |> validate_required([:leaderid])
+  end
+
+  @doc """
+  Changeset for updating family notice.
+  """
+  def notice_changeset(family, attrs) do
+    family
+    |> cast(attrs, [:notice])
+  end
+end

lib/odinsea/database/schema/gift.ex

@@ -0,0 +1,28 @@
+defmodule Odinsea.Database.Schema.Gift do
+  @moduledoc """
+  Ecto schema for the gifts table.
+  Represents cash shop gifts sent between characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:giftid, :id, autogenerate: true}
+
+  schema "gifts" do
+    field :recipient, :integer, default: 0
+    field :from, :string, default: ""
+    field :message, :string, default: ""
+    field :sn, :integer, default: 0
+    field :uniqueid, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for creating a gift.
+  """
+  def changeset(gift, attrs) do
+    gift
+    |> cast(attrs, [:recipient, :from, :message, :sn, :uniqueid])
+    |> validate_required([:recipient, :from])
+  end
+end

lib/odinsea/database/schema/gm_log.ex

@@ -0,0 +1,28 @@
+defmodule Odinsea.Database.Schema.GmLog do
+  @moduledoc """
+  Ecto schema for the gmlog table.
+  Represents GM command usage logs.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:gmlogid, :id, autogenerate: true}
+  @timestamps_opts [inserted_at: :time, updated_at: false]
+
+  schema "gmlog" do
+    field :cid, :integer, default: 0
+    field :command, :string
+    field :mapid, :integer, default: 0
+    field :time, :naive_datetime
+  end
+
+  @doc """
+  Changeset for creating a GM log entry.
+  """
+  def changeset(gm_log, attrs) do
+    gm_log
+    |> cast(attrs, [:cid, :command, :mapid])
+    |> validate_required([:cid, :command])
+  end
+end

lib/odinsea/database/schema/guild.ex

@@ -0,0 +1,63 @@
+defmodule Odinsea.Database.Schema.Guild do
+  @moduledoc """
+  Ecto schema for the guilds table.
+  Represents guild data in the game.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:guildid, :id, autogenerate: true}
+
+  schema "guilds" do
+    field :leader, :integer, default: 0
+    field :gp, :integer, default: 0, source: :GP
+    field :logo, :integer
+    field :logo_color, :integer, default: 0, source: :logoColor
+    field :name, :string
+    field :rank1title, :string, default: "Master"
+    field :rank2title, :string, default: "Jr. Master"
+    field :rank3title, :string, default: "Member"
+    field :rank4title, :string, default: "Member"
+    field :rank5title, :string, default: "Member"
+    field :capacity, :integer, default: 10
+    field :logo_bg, :integer, source: :logoBG
+    field :logo_bg_color, :integer, default: 0, source: :logoBGColor
+    field :notice, :string
+    field :signature, :integer, default: 0
+    field :alliance, :integer, default: 0
+
+    has_many :guild_skills, Odinsea.Database.Schema.GuildSkill, foreign_key: :guildid
+  end
+
+  @doc """
+  Changeset for creating a guild.
+  """
+  def creation_changeset(guild, attrs) do
+    guild
+    |> cast(attrs, [:leader, :name, :capacity, :logo, :logo_color, :logo_bg, :logo_bg_color])
+    |> validate_required([:leader, :name])
+    |> validate_length(:name, min: 1, max: 45)
+    |> unique_constraint(:name)
+  end
+
+  @doc """
+  Changeset for updating guild settings.
+  """
+  def settings_changeset(guild, attrs) do
+    guild
+    |> cast(attrs, [
+      :rank1title, :rank2title, :rank3title, :rank4title, :rank5title,
+      :capacity, :notice, :signature, :alliance
+    ])
+  end
+
+  @doc """
+  Changeset for updating guild leader.
+  """
+  def leader_changeset(guild, attrs) do
+    guild
+    |> cast(attrs, [:leader])
+    |> validate_required([:leader])
+  end
+end

lib/odinsea/database/schema/guild_skill.ex

@@ -0,0 +1,33 @@
+defmodule Odinsea.Database.Schema.GuildSkill do
+  @moduledoc """
+  Ecto schema for the guildskills table.
+  Represents purchased guild skills.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "guildskills" do
+    field :guildid, :integer, default: 0
+    field :skillid, :integer, default: 0
+    field :level, :integer, default: 1
+    field :timestamp, :integer, default: 0
+    field :purchaser, :string, default: ""
+
+    belongs_to :guild, Odinsea.Database.Schema.Guild,
+      foreign_key: :guildid,
+      references: :guildid,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating a guild skill.
+  """
+  def changeset(guild_skill, attrs) do
+    guild_skill
+    |> cast(attrs, [:guildid, :skillid, :level, :timestamp, :purchaser])
+    |> validate_required([:guildid, :skillid])
+  end
+end

lib/odinsea/database/schema/hired_merch.ex

@@ -0,0 +1,27 @@
+defmodule Odinsea.Database.Schema.HiredMerch do
+  @moduledoc """
+  Ecto schema for the hiredmerch table.
+  Represents hired merchant storage.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:package_id, :id, autogenerate: true, source: :PackageId}
+
+  schema "hiredmerch" do
+    field :characterid, :integer, default: 0
+    field :accountid, :integer
+    field :mesos, :integer, default: 0, source: :Mesos
+    field :time, :integer, source: :time
+  end
+
+  @doc """
+  Changeset for creating/updating hired merchant data.
+  """
+  def changeset(hired_merch, attrs) do
+    hired_merch
+    |> cast(attrs, [:characterid, :accountid, :mesos, :time])
+    |> validate_required([:characterid])
+  end
+end

lib/odinsea/database/schema/hired_merch_item.ex

@@ -0,0 +1,41 @@
+defmodule Odinsea.Database.Schema.HiredMerchItem do
+  @moduledoc """
+  Ecto schema for the hiredmerchitems table.
+  Represents hired merchant items.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:inventoryitemid, :integer, autogenerate: false}
+
+  schema "hiredmerchitems" do
+    field :characterid, :integer
+    field :accountid, :integer
+    field :packageid, :integer
+    field :itemid, :integer, default: 0
+    field :inventorytype, :integer, default: 0
+    field :position, :integer, default: 0
+    field :quantity, :integer, default: 0
+    field :owner, :string
+    field :gm_log, :string, source: :GM_Log
+    field :uniqueid, :integer, default: -1
+    field :flag, :integer, default: 0
+    field :expiredate, :integer, default: -1
+    field :type, :integer, default: 0
+    field :sender, :string, default: ""
+  end
+
+  @doc """
+  Changeset for creating/updating a hired merchant item.
+  """
+  def changeset(hired_merch_item, attrs) do
+    hired_merch_item
+    |> cast(attrs, [
+      :inventoryitemid, :characterid, :accountid, :packageid, :itemid,
+      :inventorytype, :position, :quantity, :owner, :gm_log, :uniqueid,
+      :flag, :expiredate, :type, :sender
+    ])
+    |> validate_required([:inventoryitemid, :itemid, :inventorytype, :position, :quantity])
+  end
+end

lib/odinsea/database/schema/hyperrock_location.ex

@@ -0,0 +1,30 @@
+defmodule Odinsea.Database.Schema.HyperrockLocation do
+  @moduledoc """
+  Ecto schema for the hyperrocklocations table.
+  Represents hyper teleport rock locations for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:trockid, :id, autogenerate: true}
+
+  schema "hyperrocklocations" do
+    field :characterid, :integer
+    field :mapid, :integer
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating a hyper teleport rock location.
+  """
+  def changeset(hyperrock_location, attrs) do
+    hyperrock_location
+    |> cast(attrs, [:characterid, :mapid])
+    |> validate_required([:characterid, :mapid])
+  end
+end

lib/odinsea/database/schema/imp.ex

@@ -0,0 +1,34 @@
+defmodule Odinsea.Database.Schema.Imp do
+  @moduledoc """
+  Ecto schema for the imps table.
+  Represents Imp (pocket pet) data for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:impid, :id, autogenerate: true}
+
+  schema "imps" do
+    field :characterid, :integer, default: 0
+    field :itemid, :integer, default: 0
+    field :level, :integer, default: 1
+    field :state, :integer, default: 1
+    field :closeness, :integer, default: 0
+    field :fullness, :integer, default: 0
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating an imp.
+  """
+  def changeset(imp, attrs) do
+    imp
+    |> cast(attrs, [:characterid, :itemid, :level, :state, :closeness, :fullness])
+    |> validate_required([:characterid, :itemid])
+  end
+end

lib/odinsea/database/schema/inventory_equipment.ex

@@ -0,0 +1,58 @@
+defmodule Odinsea.Database.Schema.InventoryEquipment do
+  @moduledoc """
+  Ecto schema for the inventoryequipment table.
+  Represents equipment stats for inventory items.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:inventoryequipmentid, :id, autogenerate: true}
+
+  schema "inventoryequipment" do
+    field :inventoryitemid, :integer, default: 0
+    field :upgradeslots, :integer, default: 0
+    field :level, :integer, default: 0
+    field :str, :integer, default: 0
+    field :dex, :integer, default: 0
+    field :int, :integer, default: 0
+    field :luk, :integer, default: 0
+    field :hp, :integer, default: 0
+    field :mp, :integer, default: 0
+    field :watk, :integer, default: 0
+    field :matk, :integer, default: 0
+    field :wdef, :integer, default: 0
+    field :mdef, :integer, default: 0
+    field :acc, :integer, default: 0
+    field :avoid, :integer, default: 0
+    field :hands, :integer, default: 0
+    field :speed, :integer, default: 0
+    field :jump, :integer, default: 0
+    field :vicioushammer, :integer, default: 0, source: :ViciousHammer
+    field :itemexp, :integer, default: 0, source: :itemEXP
+    field :durability, :integer, default: -1
+    field :enhance, :integer, default: 0
+    field :potential1, :integer, default: 0
+    field :potential2, :integer, default: 0
+    field :potential3, :integer, default: 0
+    field :hp_r, :integer, default: 0, source: :hpR
+    field :mp_r, :integer, default: 0, source: :mpR
+    field :incskill, :integer, default: -1, source: :incSkill
+    field :charmexp, :integer, default: -1, source: :charmEXP
+    field :pvpdamage, :integer, default: 0, source: :pvpDamage
+  end
+
+  @doc """
+  Changeset for creating/updating inventory equipment.
+  """
+  def changeset(inventory_equipment, attrs) do
+    inventory_equipment
+    |> cast(attrs, [
+      :inventoryitemid, :upgradeslots, :level, :str, :dex, :int, :luk,
+      :hp, :mp, :watk, :matk, :wdef, :mdef, :acc, :avoid, :hands, :speed, :jump,
+      :vicioushammer, :itemexp, :durability, :enhance, :potential1, :potential2,
+      :potential3, :hp_r, :mp_r, :incskill, :charmexp, :pvpdamage
+    ])
+    |> validate_required([:inventoryitemid])
+  end
+end

lib/odinsea/database/schema/inventory_log.ex

@@ -0,0 +1,25 @@
+defmodule Odinsea.Database.Schema.InventoryLog do
+  @moduledoc """
+  Ecto schema for the inventorylog table.
+  Represents inventory transaction logs.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:inventorylogid, :id, autogenerate: true}
+
+  schema "inventorylog" do
+    field :inventoryitemid, :integer, default: 0
+    field :msg, :string
+  end
+
+  @doc """
+  Changeset for creating an inventory log entry.
+  """
+  def changeset(inventory_log, attrs) do
+    inventory_log
+    |> cast(attrs, [:inventoryitemid, :msg])
+    |> validate_required([:inventoryitemid, :msg])
+  end
+end

lib/odinsea/database/schema/inventory_slot.ex

@@ -0,0 +1,35 @@
+defmodule Odinsea.Database.Schema.InventorySlot do
+  @moduledoc """
+  Ecto schema for the inventoryslot table.
+  Represents inventory slot counts for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "inventoryslot" do
+    field :characterid, :integer
+    field :equip, :integer
+    field :use, :integer
+    field :setup, :integer
+    field :etc, :integer
+    field :cash, :integer
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating inventory slots.
+  """
+  def changeset(inventory_slot, attrs) do
+    inventory_slot
+    |> cast(attrs, [:characterid, :equip, :use, :setup, :etc, :cash])
+    |> validate_required([:characterid])
+    |> unique_constraint(:characterid)
+  end
+end

lib/odinsea/database/schema/ip_ban.ex

@@ -0,0 +1,24 @@
+defmodule Odinsea.Database.Schema.IpBan do
+  @moduledoc """
+  Ecto schema for the ipbans table.
+  Represents IP address bans.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:ipbanid, :id, autogenerate: true}
+
+  schema "ipbans" do
+    field :ip, :string, default: ""
+  end
+
+  @doc """
+  Changeset for creating an IP ban.
+  """
+  def changeset(ip_ban, attrs) do
+    ip_ban
+    |> cast(attrs, [:ip])
+    |> validate_required([:ip])
+  end
+end

lib/odinsea/database/schema/ip_log.ex

@@ -0,0 +1,26 @@
+defmodule Odinsea.Database.Schema.IpLog do
+  @moduledoc """
+  Ecto schema for the iplog table.
+  Represents IP address login logs.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "iplog" do
+    field :accid, :integer
+    field :ip, :string
+    field :time, :string
+  end
+
+  @doc """
+  Changeset for creating an IP log entry.
+  """
+  def changeset(ip_log, attrs) do
+    ip_log
+    |> cast(attrs, [:accid, :ip, :time])
+    |> validate_required([:accid, :ip])
+  end
+end

lib/odinsea/database/schema/ipvote_log.ex

@@ -0,0 +1,27 @@
+defmodule Odinsea.Database.Schema.IpvoteLog do
+  @moduledoc """
+  Ecto schema for the ipvotelog table.
+  Represents IP-based voting records.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:vid, :id, autogenerate: true}
+
+  schema "ipvotelog" do
+    field :accid, :integer, default: 0
+    field :ipaddress, :string, default: "127.0.0.1"
+    field :votetime, :integer, default: 0
+    field :votetype, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for IP vote log.
+  """
+  def changeset(ipvote_log, attrs) do
+    ipvote_log
+    |> cast(attrs, [:accid, :ipaddress, :votetime, :votetype])
+    |> validate_required([:accid])
+  end
+end

lib/odinsea/database/schema/keymap.ex

@@ -0,0 +1,32 @@
+defmodule Odinsea.Database.Schema.Keymap do
+  @moduledoc """
+  Ecto schema for the keymap table.
+  Represents key bindings for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "keymap" do
+    field :characterid, :integer, default: 0
+    field :key, :integer, default: 0
+    field :type, :integer, default: 0
+    field :action, :integer, default: 0
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating a keymap entry.
+  """
+  def changeset(keymap, attrs) do
+    keymap
+    |> cast(attrs, [:characterid, :key, :type, :action])
+    |> validate_required([:characterid, :key, :type, :action])
+  end
+end

lib/odinsea/database/schema/mac_ban.ex

@@ -0,0 +1,25 @@
+defmodule Odinsea.Database.Schema.MacBan do
+  @moduledoc """
+  Ecto schema for the macbans table.
+  Represents MAC address bans.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:macbanid, :id, autogenerate: true}
+
+  schema "macbans" do
+    field :mac, :string
+  end
+
+  @doc """
+  Changeset for creating a MAC ban.
+  """
+  def changeset(mac_ban, attrs) do
+    mac_ban
+    |> cast(attrs, [:mac])
+    |> validate_required([:mac])
+    |> unique_constraint(:mac)
+  end
+end

lib/odinsea/database/schema/mac_filter.ex

@@ -0,0 +1,24 @@
+defmodule Odinsea.Database.Schema.MacFilter do
+  @moduledoc """
+  Ecto schema for the macfilters table.
+  Represents MAC address filters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:macfilterid, :id, autogenerate: true}
+
+  schema "macfilters" do
+    field :filter, :string
+  end
+
+  @doc """
+  Changeset for creating a MAC filter.
+  """
+  def changeset(mac_filter, attrs) do
+    mac_filter
+    |> cast(attrs, [:filter])
+    |> validate_required([:filter])
+  end
+end

lib/odinsea/database/schema/monsterbook.ex

@@ -0,0 +1,31 @@
+defmodule Odinsea.Database.Schema.Monsterbook do
+  @moduledoc """
+  Ecto schema for the monsterbook table.
+  Represents monster book cards collected by characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "monsterbook" do
+    field :charid, :integer, default: 0
+    field :cardid, :integer, default: 0
+    field :level, :integer, default: 1
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :charid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating a monsterbook entry.
+  """
+  def changeset(monsterbook, attrs) do
+    monsterbook
+    |> cast(attrs, [:charid, :cardid, :level])
+    |> validate_required([:charid, :cardid])
+  end
+end

lib/odinsea/database/schema/mount_data.ex

@@ -0,0 +1,33 @@
+defmodule Odinsea.Database.Schema.MountData do
+  @moduledoc """
+  Ecto schema for the mountdata table.
+  Represents mount levels and experience for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "mountdata" do
+    field :characterid, :integer
+    field :level, :integer, default: 0, source: :Level
+    field :exp, :integer, default: 0, source: :Exp
+    field :fatigue, :integer, default: 0, source: :Fatigue
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating mount data.
+  """
+  def changeset(mount_data, attrs) do
+    mount_data
+    |> cast(attrs, [:characterid, :level, :exp, :fatigue])
+    |> validate_required([:characterid])
+    |> unique_constraint(:characterid)
+  end
+end

lib/odinsea/database/schema/mts_cart.ex

@@ -0,0 +1,30 @@
+defmodule Odinsea.Database.Schema.MtsCart do
+  @moduledoc """
+  Ecto schema for the mts_cart table.
+  Represents MTS cart items for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "mts_cart" do
+    field :characterid, :integer, default: 0
+    field :itemid, :integer, default: 0
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating an MTS cart entry.
+  """
+  def changeset(mts_cart, attrs) do
+    mts_cart
+    |> cast(attrs, [:characterid, :itemid])
+    |> validate_required([:characterid, :itemid])
+  end
+end

lib/odinsea/database/schema/mts_item.ex

@@ -0,0 +1,28 @@
+defmodule Odinsea.Database.Schema.MtsItem do
+  @moduledoc """
+  Ecto schema for the mts_items table.
+  Represents MTS (Maple Trading System) listings.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :integer, autogenerate: false}
+
+  schema "mts_items" do
+    field :tab, :integer, default: 1
+    field :price, :integer, default: 0
+    field :characterid, :integer, default: 0
+    field :seller, :string, default: ""
+    field :expiration, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for creating an MTS item listing.
+  """
+  def changeset(mts_item, attrs) do
+    mts_item
+    |> cast(attrs, [:id, :tab, :price, :characterid, :seller, :expiration])
+    |> validate_required([:id, :characterid])
+  end
+end

lib/odinsea/database/schema/mts_transfer.ex

@@ -0,0 +1,41 @@
+defmodule Odinsea.Database.Schema.MtsTransfer do
+  @moduledoc """
+  Ecto schema for the mtstransfer table.
+  Represents MTS transfer items.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:inventoryitemid, :integer, autogenerate: false}
+
+  schema "mtstransfer" do
+    field :characterid, :integer
+    field :accountid, :integer
+    field :packageid, :integer
+    field :itemid, :integer, default: 0
+    field :inventorytype, :integer, default: 0
+    field :position, :integer, default: 0
+    field :quantity, :integer, default: 0
+    field :owner, :string
+    field :gm_log, :string, source: :GM_Log
+    field :uniqueid, :integer, default: -1
+    field :flag, :integer, default: 0
+    field :expiredate, :integer, default: -1
+    field :type, :integer, default: 0
+    field :sender, :string, default: ""
+  end
+
+  @doc """
+  Changeset for MTS transfer items.
+  """
+  def changeset(mts_transfer, attrs) do
+    mts_transfer
+    |> cast(attrs, [
+      :inventoryitemid, :characterid, :accountid, :packageid, :itemid,
+      :inventorytype, :position, :quantity, :owner, :gm_log, :uniqueid,
+      :flag, :expiredate, :type, :sender
+    ])
+    |> validate_required([:inventoryitemid, :itemid])
+  end
+end

lib/odinsea/database/schema/note.ex

@@ -0,0 +1,28 @@
+defmodule Odinsea.Database.Schema.Note do
+  @moduledoc """
+  Ecto schema for the notes table.
+  Represents in-game notes/messages between characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "notes" do
+    field :to, :string, default: ""
+    field :from, :string, default: ""
+    field :message, :string
+    field :timestamp, :integer
+    field :gift, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for creating a note.
+  """
+  def changeset(note, attrs) do
+    note
+    |> cast(attrs, [:to, :from, :message, :timestamp, :gift])
+    |> validate_required([:to, :from, :message, :timestamp])
+  end
+end

lib/odinsea/database/schema/nx_code.ex

@@ -0,0 +1,27 @@
+defmodule Odinsea.Database.Schema.NxCode do
+  @moduledoc """
+  Ecto schema for the nxcode table.
+  Represents NX (cash) redemption codes.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:code, :string, autogenerate: false}
+
+  schema "nxcode" do
+    field :valid, :integer, default: 1
+    field :user, :string
+    field :type, :integer, default: 0
+    field :item, :integer, default: 10000
+  end
+
+  @doc """
+  Changeset for creating/updating an NX code.
+  """
+  def changeset(nx_code, attrs) do
+    nx_code
+    |> cast(attrs, [:code, :valid, :user, :type, :item])
+    |> validate_required([:code])
+  end
+end

lib/odinsea/database/schema/pet.ex

@@ -0,0 +1,38 @@
+defmodule Odinsea.Database.Schema.Pet do
+  @moduledoc """
+  Ecto schema for the pets table.
+  Represents pet data in the game.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:petid, :id, autogenerate: true}
+
+  schema "pets" do
+    field :name, :string
+    field :level, :integer, default: 1
+    field :closeness, :integer, default: 0
+    field :fullness, :integer, default: 0
+    field :seconds, :integer, default: 0
+    field :flags, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for creating a pet.
+  """
+  def creation_changeset(pet, attrs) do
+    pet
+    |> cast(attrs, [:name, :level, :closeness, :fullness])
+    |> validate_required([:name])
+    |> validate_length(:name, min: 1, max: 13)
+  end
+
+  @doc """
+  Changeset for updating pet stats.
+  """
+  def stats_changeset(pet, attrs) do
+    pet
+    |> cast(attrs, [:level, :closeness, :fullness, :seconds, :flags])
+  end
+end

lib/odinsea/database/schema/playernpc.ex

@@ -0,0 +1,41 @@
+defmodule Odinsea.Database.Schema.Playernpc do
+  @moduledoc """
+  Ecto schema for the playernpcs table.
+  Represents player-created NPCs.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "playernpcs" do
+    field :name, :string
+    field :hair, :integer
+    field :face, :integer
+    field :skin, :integer
+    field :x, :integer, default: 0
+    field :y, :integer, default: 0
+    field :map, :integer
+    field :charid, :integer
+    field :scriptid, :integer
+    field :foothold, :integer
+    field :dir, :integer, default: 0
+    field :gender, :integer, default: 0
+    field :pets, :string, default: "0,0,0"
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :charid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating a player NPC.
+  """
+  def changeset(playernpc, attrs) do
+    playernpc
+    |> cast(attrs, [:name, :hair, :face, :skin, :x, :y, :map, :charid, :scriptid, :foothold, :dir, :gender, :pets])
+    |> validate_required([:name, :map, :charid, :scriptid])
+  end
+end

lib/odinsea/database/schema/playernpc_equip.ex

@@ -0,0 +1,32 @@
+defmodule Odinsea.Database.Schema.PlayernpcEquip do
+  @moduledoc """
+  Ecto schema for the playernpcs_equip table.
+  Represents equipment for player NPCs.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "playernpcs_equip" do
+    field :npcid, :integer
+    field :equipid, :integer
+    field :equippos, :integer
+    field :charid, :integer
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :charid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for player NPC equipment.
+  """
+  def changeset(playernpc_equip, attrs) do
+    playernpc_equip
+    |> cast(attrs, [:npcid, :equipid, :equippos, :charid])
+    |> validate_required([:npcid, :equipid, :charid])
+  end
+end

lib/odinsea/database/schema/pokemon.ex

@@ -0,0 +1,51 @@
+defmodule Odinsea.Database.Schema.Pokemon do
+  @moduledoc """
+  Ecto schema for the pokemon table.
+  Represents Pokemon-like pet data for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "pokemon" do
+    field :monsterid, :integer, default: 0
+    field :characterid, :integer, default: 0
+    field :level, :integer, default: 1
+    field :exp, :integer, default: 0
+    field :name, :string, default: ""
+    field :nature, :integer, default: 0
+    field :active, :integer, default: 0
+    field :accountid, :integer, default: 0
+    field :itemid, :integer, default: 0
+    field :gender, :integer, default: -1
+    field :hpiv, :integer, default: -1
+    field :atkiv, :integer, default: -1
+    field :defiv, :integer, default: -1
+    field :spatkiv, :integer, default: -1
+    field :spdefiv, :integer, default: -1
+    field :speediv, :integer, default: -1
+    field :evaiv, :integer, default: -1
+    field :acciv, :integer, default: -1
+    field :ability, :integer, default: -1
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating a pokemon.
+  """
+  def changeset(pokemon, attrs) do
+    pokemon
+    |> cast(attrs, [
+      :monsterid, :characterid, :level, :exp, :name, :nature, :active,
+      :accountid, :itemid, :gender, :hpiv, :atkiv, :defiv, :spatkiv,
+      :spdefiv, :speediv, :evaiv, :acciv, :ability
+    ])
+    |> validate_required([:monsterid])
+  end
+end

lib/odinsea/database/schema/quest_info.ex

@@ -0,0 +1,31 @@
+defmodule Odinsea.Database.Schema.QuestInfo do
+  @moduledoc """
+  Ecto schema for the questinfo table.
+  Represents custom quest info data for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:questinfoid, :id, autogenerate: true}
+
+  schema "questinfo" do
+    field :characterid, :integer, default: 0
+    field :quest, :integer, default: 0
+    field :custom_data, :string, source: :customData
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating quest info.
+  """
+  def changeset(quest_info, attrs) do
+    quest_info
+    |> cast(attrs, [:characterid, :quest, :custom_data])
+    |> validate_required([:characterid, :quest])
+  end
+end

lib/odinsea/database/schema/quest_status.ex

@@ -0,0 +1,36 @@
+defmodule Odinsea.Database.Schema.QuestStatus do
+  @moduledoc """
+  Ecto schema for the queststatus table.
+  Represents quest progress/status for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:queststatusid, :id, autogenerate: true}
+
+  schema "queststatus" do
+    field :characterid, :integer, default: 0
+    field :quest, :integer, default: 0
+    field :status, :integer, default: 0
+    field :time, :integer, default: 0
+    field :forfeited, :integer, default: 0
+    field :custom_data, :string, source: :customData
+
+    has_many :quest_status_mobs, Odinsea.Database.Schema.QuestStatusMob, foreign_key: :queststatusid
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating quest status.
+  """
+  def changeset(quest_status, attrs) do
+    quest_status
+    |> cast(attrs, [:characterid, :quest, :status, :time, :forfeited, :custom_data])
+    |> validate_required([:characterid, :quest])
+  end
+end

lib/odinsea/database/schema/quest_status_mob.ex

@@ -0,0 +1,31 @@
+defmodule Odinsea.Database.Schema.QuestStatusMob do
+  @moduledoc """
+  Ecto schema for the queststatusmobs table.
+  Represents mob kill counts for active quests.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:queststatusmobid, :id, autogenerate: true}
+
+  schema "queststatusmobs" do
+    field :queststatusid, :integer, default: 0
+    field :mob, :integer, default: 0
+    field :count, :integer, default: 0
+
+    belongs_to :quest_status, Odinsea.Database.Schema.QuestStatus,
+      foreign_key: :queststatusid,
+      references: :queststatusid,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating quest status mob.
+  """
+  def changeset(quest_status_mob, attrs) do
+    quest_status_mob
+    |> cast(attrs, [:queststatusid, :mob, :count])
+    |> validate_required([:queststatusid, :mob])
+  end
+end

lib/odinsea/database/schema/reactor_drop.ex

@@ -0,0 +1,27 @@
+defmodule Odinsea.Database.Schema.ReactorDrop do
+  @moduledoc """
+  Ecto schema for the reactordrops table.
+  Represents reactor (map object) drop tables.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:reactordropid, :id, autogenerate: true}
+
+  schema "reactordrops" do
+    field :reactorid, :integer
+    field :itemid, :integer
+    field :chance, :integer
+    field :questid, :integer, default: -1
+  end
+
+  @doc """
+  Changeset for creating/updating a reactor drop.
+  """
+  def changeset(reactor_drop, attrs) do
+    reactor_drop
+    |> cast(attrs, [:reactorid, :itemid, :chance, :questid])
+    |> validate_required([:reactorid, :itemid, :chance])
+  end
+end

lib/odinsea/database/schema/regrock_location.ex

@@ -0,0 +1,30 @@
+defmodule Odinsea.Database.Schema.RegrockLocation do
+  @moduledoc """
+  Ecto schema for the regrocklocations table.
+  Represents regular teleport rock locations for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:trockid, :id, autogenerate: true}
+
+  schema "regrocklocations" do
+    field :characterid, :integer
+    field :mapid, :integer
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating a regular teleport rock location.
+  """
+  def changeset(regrock_location, attrs) do
+    regrock_location
+    |> cast(attrs, [:characterid, :mapid])
+    |> validate_required([:characterid, :mapid])
+  end
+end

lib/odinsea/database/schema/report.ex

@@ -0,0 +1,26 @@
+defmodule Odinsea.Database.Schema.Report do
+  @moduledoc """
+  Ecto schema for the reports table.
+  Represents player reports.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:reportid, :id, autogenerate: true}
+
+  schema "reports" do
+    field :characterid, :integer, default: 0, primary_key: true
+    field :type, :integer, default: 0
+    field :count, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for creating/updating a report.
+  """
+  def changeset(report, attrs) do
+    report
+    |> cast(attrs, [:characterid, :type, :count])
+    |> validate_required([:characterid])
+  end
+end

lib/odinsea/database/schema/ring.ex

@@ -0,0 +1,27 @@
+defmodule Odinsea.Database.Schema.Ring do
+  @moduledoc """
+  Ecto schema for the rings table.
+  Represents ring (friendship/marriage) data.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:ringid, :id, autogenerate: true}
+
+  schema "rings" do
+    field :partner_ring_id, :integer, default: 0, source: :partnerRingId
+    field :partner_chr_id, :integer, default: 0, source: :partnerChrId
+    field :itemid, :integer, default: 0
+    field :partnername, :string, default: ""
+  end
+
+  @doc """
+  Changeset for creating/updating a ring.
+  """
+  def changeset(ring, attrs) do
+    ring
+    |> cast(attrs, [:partner_ring_id, :partner_chr_id, :itemid, :partnername])
+    |> validate_required([:itemid])
+  end
+end

lib/odinsea/database/schema/saved_location.ex

@@ -0,0 +1,31 @@
+defmodule Odinsea.Database.Schema.SavedLocation do
+  @moduledoc """
+  Ecto schema for the savedlocations table.
+  Represents saved locations for characters (teleport rocks, etc).
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "savedlocations" do
+    field :characterid, :integer
+    field :locationtype, :integer, default: 0
+    field :map, :integer
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating a saved location.
+  """
+  def changeset(saved_location, attrs) do
+    saved_location
+    |> cast(attrs, [:characterid, :locationtype, :map])
+    |> validate_required([:characterid, :map])
+  end
+end

lib/odinsea/database/schema/scroll_log.ex

@@ -0,0 +1,37 @@
+defmodule Odinsea.Database.Schema.ScrollLog do
+  @moduledoc """
+  Ecto schema for the scroll_log table.
+  Represents scroll usage logs.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "scroll_log" do
+    field :acc_id, :integer, default: 0, source: :accId
+    field :chr_id, :integer, default: 0, source: :chrId
+    field :scroll_id, :integer, default: 0, source: :scrollId
+    field :item_id, :integer, default: 0, source: :itemId
+    field :old_slots, :integer, default: 0, source: :oldSlots
+    field :new_slots, :integer, default: 0, source: :newSlots
+    field :hammer, :integer, default: 0
+    field :result, :string, default: ""
+    field :white_scroll, :integer, default: 0, source: :whiteScroll
+    field :legendary_spirit, :integer, default: 0, source: :legendarySpirit
+    field :vega_id, :integer, default: 0, source: :vegaId
+  end
+
+  @doc """
+  Changeset for creating a scroll log entry.
+  """
+  def changeset(scroll_log, attrs) do
+    scroll_log
+    |> cast(attrs, [
+      :acc_id, :chr_id, :scroll_id, :item_id, :old_slots, :new_slots,
+      :hammer, :result, :white_scroll, :legendary_spirit, :vega_id
+    ])
+    |> validate_required([:acc_id, :chr_id, :scroll_id, :item_id])
+  end
+end

lib/odinsea/database/schema/shop.ex

@@ -0,0 +1,23 @@
+defmodule Odinsea.Database.Schema.Shop do
+  @moduledoc """
+  Ecto schema for the shops table.
+  Represents NPC shop definitions.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:shopid, :id, autogenerate: true}
+
+  schema "shops" do
+    field :npcid, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for creating/updating a shop.
+  """
+  def changeset(shop, attrs) do
+    shop
+    |> cast(attrs, [:npcid])
+  end
+end

lib/odinsea/database/schema/shop_item.ex

@@ -0,0 +1,30 @@
+defmodule Odinsea.Database.Schema.ShopItem do
+  @moduledoc """
+  Ecto schema for the shopitems table.
+  Represents items available in NPC shops.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:shopitemid, :id, autogenerate: true}
+
+  schema "shopitems" do
+    field :shopid, :integer, default: 0
+    field :itemid, :integer, default: 0
+    field :price, :integer, default: 0
+    field :position, :integer, default: 0
+    field :reqitem, :integer, default: 0
+    field :reqitemq, :integer, default: 0
+    field :rank, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for creating/updating a shop item.
+  """
+  def changeset(shop_item, attrs) do
+    shop_item
+    |> cast(attrs, [:shopid, :itemid, :price, :position, :reqitem, :reqitemq, :rank])
+    |> validate_required([:shopid, :itemid])
+  end
+end

lib/odinsea/database/schema/shop_rank.ex

@@ -0,0 +1,27 @@
+defmodule Odinsea.Database.Schema.ShopRank do
+  @moduledoc """
+  Ecto schema for the shopranks table.
+  Represents shop rank definitions.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "shopranks" do
+    field :shopid, :integer, default: 0
+    field :rank, :integer, default: 0
+    field :name, :string, default: ""
+    field :itemid, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for creating/updating a shop rank.
+  """
+  def changeset(shop_rank, attrs) do
+    shop_rank
+    |> cast(attrs, [:shopid, :rank, :name, :itemid])
+    |> validate_required([:shopid])
+  end
+end

lib/odinsea/database/schema/sidekick.ex

@@ -0,0 +1,25 @@
+defmodule Odinsea.Database.Schema.Sidekick do
+  @moduledoc """
+  Ecto schema for the sidekicks table.
+  Represents sidekick (partner) relationships between characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "sidekicks" do
+    field :firstid, :integer, default: 0
+    field :secondid, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for creating a sidekick relationship.
+  """
+  def changeset(sidekick, attrs) do
+    sidekick
+    |> cast(attrs, [:firstid, :secondid])
+    |> validate_required([:firstid, :secondid])
+  end
+end

lib/odinsea/database/schema/skill.ex

@@ -0,0 +1,33 @@
+defmodule Odinsea.Database.Schema.Skill do
+  @moduledoc """
+  Ecto schema for the skills table.
+  Represents character skill levels.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "skills" do
+    field :skillid, :integer, default: 0
+    field :characterid, :integer, default: 0
+    field :skilllevel, :integer, default: 0
+    field :masterlevel, :integer, default: 0
+    field :expiration, :integer, default: -1
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating a skill.
+  """
+  def changeset(skill, attrs) do
+    skill
+    |> cast(attrs, [:skillid, :characterid, :skilllevel, :masterlevel, :expiration])
+    |> validate_required([:skillid, :characterid])
+  end
+end

lib/odinsea/database/schema/skill_cooldown.ex

@@ -0,0 +1,32 @@
+defmodule Odinsea.Database.Schema.SkillCooldown do
+  @moduledoc """
+  Ecto schema for the skills_cooldowns table.
+  Represents active skill cooldowns for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "skills_cooldowns" do
+    field :charid, :integer
+    field :skill_id, :integer, source: :SkillID
+    field :length, :integer
+    field :start_time, :integer, source: :StartTime
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :charid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating a skill cooldown.
+  """
+  def changeset(skill_cooldown, attrs) do
+    skill_cooldown
+    |> cast(attrs, [:charid, :skill_id, :length, :start_time])
+    |> validate_required([:charid, :skill_id, :length, :start_time])
+  end
+end

lib/odinsea/database/schema/skill_macro.ex

@@ -0,0 +1,35 @@
+defmodule Odinsea.Database.Schema.SkillMacro do
+  @moduledoc """
+  Ecto schema for the skillmacros table.
+  Represents skill macros (combo skills) for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "skillmacros" do
+    field :characterid, :integer, default: 0
+    field :position, :integer, default: 0
+    field :skill1, :integer, default: 0
+    field :skill2, :integer, default: 0
+    field :skill3, :integer, default: 0
+    field :name, :string
+    field :shout, :integer, default: 0
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating a skill macro.
+  """
+  def changeset(skill_macro, attrs) do
+    skill_macro
+    |> cast(attrs, [:characterid, :position, :skill1, :skill2, :skill3, :name, :shout])
+    |> validate_required([:characterid, :position])
+  end
+end

lib/odinsea/database/schema/speedrun.ex

@@ -0,0 +1,28 @@
+defmodule Odinsea.Database.Schema.Speedrun do
+  @moduledoc """
+  Ecto schema for the speedruns table.
+  Represents dungeon speedrun records.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "speedruns" do
+    field :type, :string
+    field :leader, :string
+    field :timestring, :string
+    field :time, :integer, default: 0
+    field :members, :string, default: ""
+  end
+
+  @doc """
+  Changeset for creating a speedrun record.
+  """
+  def changeset(speedrun, attrs) do
+    speedrun
+    |> cast(attrs, [:type, :leader, :timestring, :time, :members])
+    |> validate_required([:type, :leader, :timestring])
+  end
+end

lib/odinsea/database/schema/storage.ex

@@ -0,0 +1,31 @@
+defmodule Odinsea.Database.Schema.Storage do
+  @moduledoc """
+  Ecto schema for the storages table.
+  Represents account storage (bank) data.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:storageid, :id, autogenerate: true}
+
+  schema "storages" do
+    field :accountid, :integer, default: 0
+    field :slots, :integer, default: 0
+    field :meso, :integer, default: 0
+
+    belongs_to :account, Odinsea.Database.Schema.Account,
+      foreign_key: :accountid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating storage.
+  """
+  def changeset(storage, attrs) do
+    storage
+    |> cast(attrs, [:accountid, :slots, :meso])
+    |> validate_required([:accountid])
+  end
+end

lib/odinsea/database/schema/tournament_log.ex

@@ -0,0 +1,27 @@
+defmodule Odinsea.Database.Schema.TournamentLog do
+  @moduledoc """
+  Ecto schema for the tournamentlog table.
+  Represents tournament records.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:logid, :id, autogenerate: true}
+  @timestamps_opts [inserted_at: :when, updated_at: false]
+
+  schema "tournamentlog" do
+    field :winnerid, :integer, default: 0
+    field :num_contestants, :integer, default: 0, source: :numContestants
+    field :when, :naive_datetime
+  end
+
+  @doc """
+  Changeset for creating a tournament log entry.
+  """
+  def changeset(tournament_log, attrs) do
+    tournament_log
+    |> cast(attrs, [:winnerid, :num_contestants])
+    |> validate_required([:winnerid])
+  end
+end

lib/odinsea/database/schema/trock_location.ex

@@ -0,0 +1,30 @@
+defmodule Odinsea.Database.Schema.TrockLocation do
+  @moduledoc """
+  Ecto schema for the trocklocations table.
+  Represents teleport rock locations for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:trockid, :id, autogenerate: true}
+
+  schema "trocklocations" do
+    field :characterid, :integer
+    field :mapid, :integer
+
+    belongs_to :character, Odinsea.Database.Schema.Character,
+      foreign_key: :characterid,
+      references: :id,
+      define_field: false
+  end
+
+  @doc """
+  Changeset for creating/updating a teleport rock location.
+  """
+  def changeset(trock_location, attrs) do
+    trock_location
+    |> cast(attrs, [:characterid, :mapid])
+    |> validate_required([:characterid, :mapid])
+  end
+end

lib/odinsea/database/schema/wishlist.ex

@@ -0,0 +1,24 @@
+defmodule Odinsea.Database.Schema.Wishlist do
+  @moduledoc """
+  Ecto schema for the wishlist table.
+  Represents cash shop wishlist items for characters.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key false
+  schema "wishlist" do
+    field :characterid, :integer, primary_key: true
+    field :sn, :integer, primary_key: true
+  end
+
+  @doc """
+  Changeset for creating a wishlist entry.
+  """
+  def changeset(wishlist, attrs) do
+    wishlist
+    |> cast(attrs, [:characterid, :sn])
+    |> validate_required([:characterid, :sn])
+  end
+end

lib/odinsea/database/schema/wz_item_add_data.ex

@@ -0,0 +1,27 @@
+defmodule Odinsea.Database.Schema.WzItemAddData do
+  @moduledoc """
+  Ecto schema for the wz_itemadddata table.
+  Represents additional static item data from WZ files.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "wz_itemadddata" do
+    field :itemid, :integer
+    field :key, :string
+    field :value1, :integer, default: 0
+    field :value2, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for WZ item add data.
+  """
+  def changeset(wz_item_add_data, attrs) do
+    wz_item_add_data
+    |> cast(attrs, [:itemid, :key, :value1, :value2])
+    |> validate_required([:itemid, :key])
+  end
+end

lib/odinsea/database/schema/wz_item_data.ex

@@ -0,0 +1,49 @@
+defmodule Odinsea.Database.Schema.WzItemData do
+  @moduledoc """
+  Ecto schema for the wz_itemdata table.
+  Represents static item data from WZ files.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:itemid, :integer, autogenerate: false}
+
+  schema "wz_itemdata" do
+    field :name, :string
+    field :msg, :string
+    field :desc, :string
+    field :slot_max, :integer, default: 1, source: :slotMax
+    field :price, :string, default: "-1.0"
+    field :whole_price, :integer, default: -1, source: :wholePrice
+    field :state_change, :integer, default: 0, source: :stateChange
+    field :flags, :integer, default: 0
+    field :karma, :integer, default: 0
+    field :meso, :integer, default: 0
+    field :monster_book, :integer, default: 0, source: :monsterBook
+    field :item_make_level, :integer, default: 0, source: :itemMakeLevel
+    field :quest_id, :integer, default: 0, source: :questId
+    field :scroll_reqs, :string, source: :scrollReqs
+    field :consume_item, :string, source: :consumeItem
+    field :totalprob, :integer, default: 0
+    field :inc_skill, :string, default: "", source: :incSkill
+    field :replaceid, :integer, default: 0
+    field :replacemsg, :string, default: ""
+    field :create, :integer, default: 0
+    field :after_image, :string, default: "", source: :afterImage
+  end
+
+  @doc """
+  Changeset for WZ item data.
+  """
+  def changeset(wz_item_data, attrs) do
+    wz_item_data
+    |> cast(attrs, [
+      :itemid, :name, :msg, :desc, :slot_max, :price, :whole_price,
+      :state_change, :flags, :karma, :meso, :monster_book, :item_make_level,
+      :quest_id, :scroll_reqs, :consume_item, :totalprob, :inc_skill,
+      :replaceid, :replacemsg, :create, :after_image
+    ])
+    |> validate_required([:itemid])
+  end
+end

lib/odinsea/database/schema/wz_item_equip_data.ex

@@ -0,0 +1,27 @@
+defmodule Odinsea.Database.Schema.WzItemEquipData do
+  @moduledoc """
+  Ecto schema for the wz_itemequipdata table.
+  Represents static equipment data from WZ files.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "wz_itemequipdata" do
+    field :itemid, :integer
+    field :item_level, :integer, default: -1, source: :itemLevel
+    field :key, :string
+    field :value, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for WZ equipment data.
+  """
+  def changeset(wz_item_equip_data, attrs) do
+    wz_item_equip_data
+    |> cast(attrs, [:itemid, :item_level, :key, :value])
+    |> validate_required([:itemid, :key])
+  end
+end

lib/odinsea/database/schema/wz_item_reward_data.ex

@@ -0,0 +1,30 @@
+defmodule Odinsea.Database.Schema.WzItemRewardData do
+  @moduledoc """
+  Ecto schema for the wz_itemrewarddata table.
+  Represents item reward data from WZ files.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "wz_itemrewarddata" do
+    field :itemid, :integer
+    field :item, :integer
+    field :prob, :integer, default: 0
+    field :quantity, :integer, default: 0
+    field :period, :integer, default: -1
+    field :world_msg, :string, default: "", source: :worldMsg
+    field :effect, :string, default: ""
+  end
+
+  @doc """
+  Changeset for WZ item reward data.
+  """
+  def changeset(wz_item_reward_data, attrs) do
+    wz_item_reward_data
+    |> cast(attrs, [:itemid, :item, :prob, :quantity, :period, :world_msg, :effect])
+    |> validate_required([:itemid, :item])
+  end
+end

lib/odinsea/database/schema/wz_mob_skill_data.ex

@@ -0,0 +1,43 @@
+defmodule Odinsea.Database.Schema.WzMobSkillData do
+  @moduledoc """
+  Ecto schema for the wz_mobskilldata table.
+  Represents monster skill data from WZ files.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "wz_mobskilldata" do
+    field :skillid, :integer
+    field :level, :integer
+    field :hp, :integer, default: 100
+    field :mpcon, :integer, default: 0
+    field :x, :integer, default: 1
+    field :y, :integer, default: 1
+    field :time, :integer, default: 0
+    field :prop, :integer, default: 100
+    field :limit, :integer, default: 0
+    field :spawneffect, :integer, default: 0
+    field :interval, :integer, default: 0
+    field :summons, :string, default: ""
+    field :ltx, :integer, default: 0
+    field :lty, :integer, default: 0
+    field :rbx, :integer, default: 0
+    field :rby, :integer, default: 0
+    field :once, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for WZ mob skill data.
+  """
+  def changeset(wz_mob_skill_data, attrs) do
+    wz_mob_skill_data
+    |> cast(attrs, [
+      :skillid, :level, :hp, :mpcon, :x, :y, :time, :prop, :limit,
+      :spawneffect, :interval, :summons, :ltx, :lty, :rbx, :rby, :once
+    ])
+    |> validate_required([:skillid, :level])
+  end
+end

lib/odinsea/database/schema/wz_ox_data.ex

@@ -0,0 +1,27 @@
+defmodule Odinsea.Database.Schema.WzOxData do
+  @moduledoc """
+  Ecto schema for the wz_oxdata table.
+  Represents OX quiz questions from WZ files.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key false
+  schema "wz_oxdata" do
+    field :questionset, :integer, default: 0, primary_key: true
+    field :questionid, :integer, default: 0, primary_key: true
+    field :question, :string, default: ""
+    field :display, :string, default: ""
+    field :answer, :string
+  end
+
+  @doc """
+  Changeset for WZ OX data.
+  """
+  def changeset(wz_ox_data, attrs) do
+    wz_ox_data
+    |> cast(attrs, [:questionset, :questionid, :question, :display, :answer])
+    |> validate_required([:questionset, :questionid, :answer])
+  end
+end

lib/odinsea/database/schema/wz_quest_act_data.ex

@@ -0,0 +1,29 @@
+defmodule Odinsea.Database.Schema.WzQuestActData do
+  @moduledoc """
+  Ecto schema for the wz_questactdata table.
+  Represents quest action data from WZ files.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "wz_questactdata" do
+    field :questid, :integer, default: 0
+    field :name, :string, default: ""
+    field :type, :integer, default: 0
+    field :int_store, :integer, default: 0, source: :intStore
+    field :applicable_jobs, :string, default: "", source: :applicableJobs
+    field :uniqueid, :integer, default: 0
+  end
+
+  @doc """
+  Changeset for WZ quest action data.
+  """
+  def changeset(wz_quest_act_data, attrs) do
+    wz_quest_act_data
+    |> cast(attrs, [:questid, :name, :type, :int_store, :applicable_jobs, :uniqueid])
+    |> validate_required([:questid])
+  end
+end

lib/odinsea/database/schema/wz_quest_data.ex

@@ -0,0 +1,34 @@
+defmodule Odinsea.Database.Schema.WzQuestData do
+  @moduledoc """
+  Ecto schema for the wz_questdata table.
+  Represents static quest data from WZ files.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:questid, :integer, autogenerate: false}
+
+  schema "wz_questdata" do
+    field :name, :string, default: ""
+    field :auto_start, :integer, default: 0, source: :autoStart
+    field :auto_pre_complete, :integer, default: 0, source: :autoPreComplete
+    field :view_medal_item, :integer, default: 0, source: :viewMedalItem
+    field :selected_skill_id, :integer, default: 0, source: :selectedSkillID
+    field :blocked, :integer, default: 0
+    field :auto_accept, :integer, default: 0, source: :autoAccept
+    field :auto_complete, :integer, default: 0, source: :autoComplete
+  end
+
+  @doc """
+  Changeset for WZ quest data.
+  """
+  def changeset(wz_quest_data, attrs) do
+    wz_quest_data
+    |> cast(attrs, [
+      :questid, :name, :auto_start, :auto_pre_complete, :view_medal_item,
+      :selected_skill_id, :blocked, :auto_accept, :auto_complete
+    ])
+    |> validate_required([:questid])
+  end
+end

lib/odinsea/database/schema/wz_quest_req_data.ex

@@ -0,0 +1,29 @@
+defmodule Odinsea.Database.Schema.WzQuestReqData do
+  @moduledoc """
+  Ecto schema for the wz_questreqdata table.
+  Represents quest requirement data from WZ files.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key {:id, :id, autogenerate: true}
+
+  schema "wz_questreqdata" do
+    field :questid, :integer, default: 0
+    field :name, :string, default: ""
+    field :type, :integer, default: 0
+    field :string_store, :string, default: "", source: :stringStore
+    field :int_stores_first, :string, default: "", source: :intStoresFirst
+    field :int_stores_second, :string, default: "", source: :intStoresSecond
+  end
+
+  @doc """
+  Changeset for WZ quest requirement data.
+  """
+  def changeset(wz_quest_req_data, attrs) do
+    wz_quest_req_data
+    |> cast(attrs, [:questid, :name, :type, :string_store, :int_stores_first, :int_stores_second])
+    |> validate_required([:questid])
+  end
+end