API Playground

-- Spawn a crate at a specific position
local pos = Vec3.new(10, 0, 5)
local crate = rawframe.spawn("props/crate", pos)

if crate then
  print("Spawned entity:", crate)
end

-- Destroy an entity after a delay
local box = rawframe.spawn("props/box", Vec3.new(0, 1, 0))

timer.after(5.0, function()
  rawframe.destroy(box)
  print("Box destroyed.")
end)

local player = game.get_player(1)
local pos = rawframe.get_position(player)
print(string.format("Player at %.1f, %.1f, %.1f", pos.x, pos.y, pos.z))

-- Teleport player to spawn
local player = game.get_player(1)
local spawn  = Vec3.new(0, 5, 0)
rawframe.set_position(player, spawn)

local rot = rawframe.get_rotation(vehicle)
local forward = Vec3.rotate(Vec3.new(0, 0, 1), rot)
print("Vehicle forward:", forward)

-- Face a prop north (+Z direction)
local rot = Quat.from_axis_angle(Vec3.new(0, 1, 0), 0)
rawframe.set_rotation(prop, rot)

local scale = rawframe.get_scale(entity)
print("Scale:", scale.x, scale.y, scale.z)

-- Double the size of a collectible
rawframe.set_scale(pickup, Vec3.new(2, 2, 2))

-- Hide a pickup until a player is nearby
rawframe.set_visible(gem, false)
timer.after(2.0, function()
  rawframe.set_visible(gem, true)
end)

if not rawframe.is_visible(trap) then
  rawframe.set_visible(trap, true)
end

rawframe.add_tag(chest, "lootable")
rawframe.add_tag(chest, "interactable")

-- Mark chest as looted
rawframe.remove_tag(chest, "lootable")

if rawframe.has_tag(entity, "enemy") then
  char.damage(entity, 10, "fire")
end

-- Attach a hat to a player's head bone
local hat = rawframe.spawn("items/hat")
rawframe.set_parent(hat, player)

local parent = rawframe.get_parent(wheel)
if parent then
  print("Wheel belongs to vehicle:", parent)
end

local children = rawframe.get_children(vehicle)
for _, child in ipairs(children) do
  print("Child:", child)
end

-- Safely use a cached entity
if rawframe.is_valid(cached_enemy) then
  char.damage(cached_enemy, 30, "explosion")
else
  cached_enemy = nil
end

print("Entity name:", rawframe.get_name(entity))

local boss = rawframe.spawn("enemies/boss")
rawframe.set_name(boss, "FinalBoss_Arena1")

local enemies = rawframe.find_by_tag("enemy")
print(#enemies, "enemies alive")

local flag = rawframe.find_by_name("CaptureFlag_Blue")
if flag then
  rawframe.set_position(flag, Vec3.new(0, 1, 50))
end

local origin = rawframe.get_position(player)
local dir    = Vec3.new(0, -1, 0)
local hit    = physics.raycast(origin, dir, 100)

if hit then
  print("Hit entity:", hit.entity)
  print("At distance:", hit.distance)
end

-- Launch a crate upward
local crate = rawframe.spawn("props/crate", Vec3.new(0, 1, 0))
physics.apply_force(crate, Vec3.new(0, 500, 0))

-- Spin a barrel when hit
physics.apply_torque(barrel, Vec3.new(0, 200, 0))

-- Knock player back on damage
local kb_dir = Vec3.normalize(Vec3.new(1, 0.5, 0))
physics.set_velocity(player, Vec3.scale(kb_dir, 15))

local vel = physics.get_velocity(vehicle)
local speed = Vec3.length(vel)
if speed > 40 then
  print("Over speed limit!")
end

local box = rawframe.spawn("props/crate")
physics.create_body(box, {
  shape       = "box",
  size        = Vec3.new(1, 1, 1),
  mass        = 50,
  motion_type = "dynamic",
  friction    = 0.6,
  restitution = 0.2,
})

-- Ghost mode: remove physics
physics.remove_body(player)

-- Balloon floats upward
physics.set_gravity_scale(balloon, -0.5)

-- Freeze object in place during cutscene
physics.set_kinematic(door, true)
timer.after(3.0, function()
  physics.set_kinematic(door, false)
end)

-- Melee attack sweep
local hits = physics.sphere_cast(origin, forward, 0.5, 1.5)
for _, hit in ipairs(hits) do
  if rawframe.has_tag(hit.entity, "enemy") then
    char.damage(hit.entity, 40, "melee")
  end
end

-- Door hinge
local constraint = physics.add_constraint(door_frame, door, {
  type   = "hinge",
  axis   = Vec3.new(0, 1, 0),
  limits = { min = -90, max = 0 },
})

-- Break a rope on explosion
physics.remove_constraint(rope_joint)

-- Explosion damage
local victims = physics.overlap_sphere(explosion_pos, 5.0)
for _, ent in ipairs(victims) do
  if rawframe.has_tag(ent, "character") then
    char.damage(ent, 80, "explosion")
  end
end

-- Put player on layer 1, enemies on layer 2
physics.set_collision_layer(player, 1)
physics.set_collision_layer(enemy, 2)

local mass = physics.get_mass(crate)
print("Crate mass:", mass, "kg")

-- Server: tell a player their score
net.send(peer, "score_update", { score = 42, kills = 3 })

-- Broadcast a game-start event to all players
net.broadcast("game_start", { map = "dust2", time_limit = 300 })

-- Client: handle score update
net.receive("score_update", function(data)
  ui.set_text(score_label, tostring(data.score))
end)

-- Client: request to pick up an item
net.send_to_server("pickup_request", { entity_id = item_id })

local ping = net.get_ping(peer)
if ping > 200 then
  net.send(peer, "high_latency_warning", { ping = ping })
end

hook.add("Think", "server.capacity", function()
  if net.get_peer_count() >= 32 then
    game.set_state("full")
  end
end)

-- Kick an idle player
net.kick(idle_peer, "Kicked for inactivity")

local rx, tx = net.get_bandwidth(peer)
print(string.format("Rx: %d B/s  Tx: %d B/s", rx, tx))

if net.is_server() then
  -- server-only logic
  hook.add("PlayerSpawn", "server.spawn", on_player_spawn)
end

local npc = rawframe.spawn("enemies/zombie", Vec3.new(10, 0, 10))
net.replicate(npc, { rate = 20, radius = 100 })

-- Create a HUD health bar background
local hud = ui.create_frame(nil, {
  size     = UDim2.new(0.2, 0, 0.04, 0),
  position = UDim2.new(0.01, 0, 0.94, 0),
  background_color = Color3.new(0.1, 0.1, 0.1),
  corner_radius = 6,
})

local label = ui.create_text_label(hud, { text = "HP: 100" })

-- Update it later
ui.set_text(label, "HP: " .. tostring(player_health))

local title = ui.create_text_label(nil, {
  text       = "Round 1",
  font       = "Bold",
  font_size  = 32,
  text_color = Color3.new(1, 1, 1),
  size       = UDim2.new(0, 200, 0, 40),
  position   = UDim2.new(0.5, -100, 0.05, 0),
})

local btn = ui.create_text_button(menu, {
  text             = "Start Game",
  size             = UDim2.new(0, 160, 0, 44),
  position         = UDim2.new(0.5, -80, 0.5, 0),
  background_color = Color3.new(0.2, 0.6, 1),
  on_click = function()
    net.send_to_server("start_game", {})
  end,
})

local crosshair = ui.create_image_label(nil, {
  image    = "ui/crosshair.png",
  size     = UDim2.new(0, 32, 0, 32),
  position = UDim2.new(0.5, -16, 0.5, -16),
})

local list = ui.create_scroll_frame(panel, {
  size             = UDim2.new(1, 0, 0.8, 0),
  canvas_size      = UDim2.new(0, 0, 0, 800),
  scroll_direction = "vertical",
})

-- Animate health bar width based on HP
local pct = current_hp / max_hp
ui.set_size(hp_bar, UDim2.new(pct, 0, 1, 0))

ui.set_position(tooltip, UDim2.new(0, mouse_x + 10, 0, mouse_y + 10))

-- Flash red on damage
ui.set_color(hp_bar, Color3.new(1, 0.2, 0.2))
timer.after(0.3, function()
  ui.set_color(hp_bar, Color3.new(0.2, 0.8, 0.2))
end)

-- Fade out a notification
ui.tween(notification, 1.0, { transparency = 1.0 }, "ease_out", function()
  ui.destroy(notification)
end)

-- Slide HUD in from the left
ui.set_position(hud, UDim2.new(-0.3, 0, 0.9, 0))
ui.tween(hud, 0.4, {
  position = UDim2.new(0.01, 0, 0.9, 0),
}, "ease_out")

-- Remove HUD on game end
hook.add("RoundEnd", "hud.cleanup", function()
  ui.destroy(hud_root)
end)

-- Toggle pause menu
local paused = false
input.bind_action("TogglePause", "Escape", function()
  paused = not paused
  ui.set_visible(pause_menu, paused)
end)

ui.load_font("HUD", "fonts/inter_bold.ttf")
ui.load_font("Body", "fonts/inter_regular.ttf")

ui.set_font(damage_number, "HUD")

ui.set_font_size(header_label, 24)

ui.enable_rich_text(chat_line, true)
ui.set_text(chat_line, "<b>Admin</b>: <color=ff4444>Server restarting in 60s</color>")

local w, h = ui.get_screen_size()
print(string.format("Screen: %dx%d", w, h))

-- Draw a nametag above a player
local sx, sy, visible = ui.world_to_screen(rawframe.get_position(target))
if visible then
  ui.set_position(nametag, UDim2.new(0, sx - 50, 0, sy - 60))
  ui.set_visible(nametag, true)
end

ui.set_z_index(tooltip, 100)
ui.set_z_index(hud, 10)

-- Center-anchor a popup
ui.set_anchor(popup, 0.5, 0.5)
ui.set_position(popup, UDim2.new(0.5, 0, 0.5, 0))

local toolbar = ui.create_frame(hud)
ui.set_flex(toolbar, {
  direction = "row",
  gap       = 8,
  padding   = 4,
  align     = "center",
})

ui.add_context_menu_item(inventory_slot, "Drop Item", function()
  net.send_to_server("drop_item", { slot = slot_index })
end)

-- 3D gunshot at a position
local sound = audio.play_sound("sounds/gunshot.ogg", hit_pos, {
  volume = 0.8,
  pitch  = 1.0 + math.random() * 0.1,
})

local ambient = audio.play_sound("sounds/wind_loop.ogg", nil, {
  looping = true,
  volume  = 0.3,
})

-- Stop with a 1-second fade
timer.after(30, function()
  audio.stop_sound(ambient, 1.0)
end)

-- Reduce volume of background music during combat
audio.set_volume(bg_music, 0.2)

-- Slow-motion effect
audio.set_pitch(engine_sound, 0.6)

-- Attach engine sound to vehicle
hook.add("Think", "vehicle.audio", function()
  audio.set_position(engine_sound, rawframe.get_position(vehicle))
end)

hook.add("RenderStep", "audio.listener", function()
  local pos = camera.get_position()
  local fwd = camera.get_forward()
  audio.set_listener(pos, fwd, Vec3.new(0, 1, 0))
end)

if not audio.is_playing(footstep_sound) then
  footstep_sound = audio.play_sound("sounds/step.ogg", pos)
end

-- Preload combat sounds on map load
audio.preload("sounds/gunshot.ogg")
audio.preload("sounds/explosion.ogg")
audio.preload("sounds/footstep.ogg")

local rifle = weapon.create("weapons/assault_rifle")
weapon.equip(rifle, player)

-- Server-side fire handler
hook.add("WeaponFire", "my_mod.fire", function(player, weapon_ent)
  local origin = char.get_muzzle_position(player)
  local dir    = char.get_aim_direction(player)
  local result = weapon.fire(weapon_ent, origin, dir)

  if result.hit then
    print("Hit!", result.damage_dealt, "damage")
  end
end)

local pistol = weapon.create("weapons/pistol")
weapon.equip(pistol, player)

-- Drop weapon on death
hook.add("CharacterDied", "my_mod.drop", function(player)
  weapon.unequip(player)
end)

local mag, reserve = weapon.get_ammo(rifle)
ui.set_text(ammo_label, mag .. " / " .. reserve)

-- Give player a full loadout
weapon.set_ammo(rifle, 30, 120)

-- Auto-reload when empty
hook.add("WeaponAmmoEmpty", "my_mod.autoreload", function(player, weapon_ent)
  weapon.reload(weapon_ent)
end)

net.receive("ads_state", function(data)
  weapon.set_ads(held_weapon, data.ads)
end)

local spread = weapon.get_spread(rifle)
ui.set_size(crosshair_outer, UDim2.new(0, 16 + spread * 4, 0, 16 + spread * 4))

-- Make sniper extremely accurate when prone
if char.is_prone(player) then
  weapon.set_spread(sniper, 0.05)
end

weapon.apply_recoil(shotgun, 4.0, 1.5)

local current = weapon.get_equipped(player)
if current then
  local mag, _ = weapon.get_ammo(current)
  ui.set_text(ammo_label, tostring(mag))
end

-- Power-up: double damage for 10 seconds
weapon.set_damage(rifle, 80)
timer.after(10.0, function()
  weapon.set_damage(rifle, 40)
end)

-- Remove weapon on round reset
weapon.destroy(player_weapon)

-- Full heal on respawn
hook.add("PlayerSpawn", "my_mod.heal", function(player)
  char.set_health(player, 100)
  char.set_armor(player, 50)
end)

local hp = char.get_health(player)
if hp < 25 then
  net.send(peer, "low_health_warning", { hp = hp })
end

-- Explosion radius damage
local victims = physics.overlap_sphere(pos, 5)
for _, ent in ipairs(victims) do
  if rawframe.has_tag(ent, "character") then
    char.damage(ent, 80, "explosion", attacker)
  end
end

-- Medkit pickup
hook.add("ItemPickup", "medkit", function(player, item)
  if item.type == "medkit" then
    char.heal(player, 50)
  end
end)

-- Tank class gets more HP
char.set_max_health(player, 200)
char.set_health(player, 200)

local armor = char.get_armor(player)
ui.set_text(armor_label, tostring(math.floor(armor)))

char.set_armor(player, 100)

if char.is_alive(player) then
  char.damage(player, 10, "fire")
end

-- Slow player when injured
if char.get_health(player) < 30 then
  char.set_speed(player, 2.5)
else
  char.set_speed(player, 5.0)
end

local spd = char.get_speed(player)
print("Speed:", spd)

char.teleport(player, spawn.get_random_point())

local aim = char.get_aim_direction(player)
local origin = char.get_muzzle_position(player)
local hit = physics.raycast(origin, aim, 500)

local muzzle = char.get_muzzle_position(player)
audio.play_sound("sounds/gunshot.ogg", muzzle)

-- Force crouch in a low tunnel
char.set_crouching(player, true)

if char.is_grounded(player) then
  -- Allow jump input
end

-- Bounce pad
hook.add("CollisionEnter", "bounce_pad", function(ent, other)
  if rawframe.has_tag(other, "character") then
    char.apply_jump(other, 20)
  end
end)

local hit = physics.raycast(origin, dir, 500)
if hit then
  local group = char.get_hitgroup(hit.entity)
  if group == "head" then
    char.damage(owner, 100, "bullet")  -- headshot
  else
    char.damage(owner, 25, "bullet")
  end
end

-- Freeze all players during round start countdown
for _, p in ipairs(game.get_all_players()) do
  char.set_freeze(p, true)
end
timer.after(3.0, function()
  for _, p in ipairs(game.get_all_players()) do
    char.set_freeze(p, false)
  end
end)

hook.add("Think", "sprint.check", function()
  if input.is_key_down("LeftShift") and char.is_grounded(local_player) then
    char.set_speed(local_player, 8.0)
  else
    char.set_speed(local_player, 5.0)
  end
end)

hook.add("Think", "interact", function()
  if input.is_key_pressed("E") then
    local hit = physics.raycast(camera.get_position(), camera.get_forward(), 3)
    if hit and rawframe.has_tag(hit.entity, "interactable") then
      net.send_to_server("interact", { entity_id = hit.entity })
    end
  end
end)

local mx, my = input.get_mouse_position()
ui.set_position(tooltip, UDim2.new(0, mx + 12, 0, my + 8))

hook.add("Think", "look", function()
  local dx, dy = input.get_mouse_delta()
  camera.rotate(dy * 0.1, dx * 0.1)
end)

if input.is_mouse_down("Left") and weapon.get_equipped(player) then
  net.send_to_server("fire_request", {})
end

input.bind_action("Reload", "R", function()
  local w = weapon.get_equipped(local_player)
  if w then
    net.send_to_server("reload_request", {})
  end
end)

-- Disable reload action during cutscene
input.unbind_action("Reload")

-- Lock cursor during gameplay, release for menus
hook.add("GameStateChanged", "cursor", function(state)
  input.lock_cursor(state == "playing")
end)

if input.get_touch_count() > 0 then
  -- Mobile: show virtual joystick
  ui.set_visible(joystick_ui, true)
end

local tx, ty = input.get_touch_position(0)
if tx then
  -- first finger is down
end

local rx = input.get_gamepad_axis("RightX")
local ry = input.get_gamepad_axis("RightY")
camera.rotate(ry * 2, rx * 2)

if input.is_gamepad_button_down("A") and char.is_grounded(player) then
  char.apply_jump(player)
end

-- Rumble on taking damage
hook.add("CharacterDamaged", "rumble", function(player)
  input.vibrate(0.6, 0.2)
end)

local cam_pos = camera.get_position()
local hit = physics.raycast(cam_pos, camera.get_forward(), 500)

-- Cinematic intro: move camera to overview
camera.set_position(Vec3.new(0, 80, -30))
camera.look_at(Vec3.new(0, 0, 0))

local fwd = camera.get_forward()
local origin = camera.get_position()
local hit = physics.raycast(origin, fwd, 200)

camera.set_position(Vec3.new(10, 20, 10))
camera.look_at(rawframe.get_position(boss_entity))

-- ADS zoom
camera.set_fov(weapon.is_ads(rifle) and 40 or 75)

print("Current FOV:", camera.get_fov())

-- Switch to third-person on spawn
hook.add("PlayerSpawn", "cam_mode", function(player)
  camera.set_mode("third_person")
  camera.follow(player)
end)

camera.set_mode("third_person")
camera.follow(player, {
  distance = 5,
  offset   = Vec3.new(0, 1.5, 0),
  smooth   = 0.15,
})

-- Detach camera for death replay
hook.add("CharacterDied", "death_cam", function(player)
  camera.stop_follow()
  camera.set_position(rawframe.get_position(player) + Vec3.new(0, 3, -5))
end)

-- Shake camera on nearby explosion
local dist = Vec3.distance(camera.get_position(), explosion_pos)
if dist < 30 then
  camera.shake(1 - dist / 30, 0.5)
end

-- Bank camera when turning
local steer = vehicle.get_steering(car)
camera.set_roll(steer * -5)

local cam_rot = camera.get_rotation()
local right = Vec3.rotate(Vec3.new(1, 0, 0), cam_rot)

camera.set_clip(0.05, 2000)

hook.add("Think", "mouselook", function()
  local dx, dy = input.get_mouse_delta()
  camera.rotate(dy * 0.15, dx * 0.15)
end)

hook.add("PlayerConnect", "welcome", function(player)
  local name = player.get_name(player)
  net.broadcast("chat", { text = name .. " joined the game." })
end)

local uid = player.get_steam_id(player)
local banned = storage.get("bans", uid)
if banned then
  net.kick(player.get_peer(player), "You are banned.")
end

local peer = player.get_peer(player)
net.send(peer, "round_start", { countdown = 3 })

player.kick(afk_player, "Kicked: AFK")

player.set_team(new_player, red_team_id)

local tid = player.get_team(player)
if tid == red_team_id then
  print("Player is on red team")
end

local kills = player.get_kills(player)
ui.set_text(score_label, "Kills: " .. kills)

local kd = player.get_kills(p) / math.max(1, player.get_deaths(p))
print(string.format("K/D: %.2f", kd))

hook.add("CharacterDied", "scoreboard", function(victim, attacker)
  if attacker and rawframe.has_tag(attacker, "player") then
    player.add_kill(attacker)
    player.add_death(victim)
  end
end)

player.add_death(victim)

if not player.is_admin(player) then
  net.kick(player.get_peer(player), "Admin only command.")
  return
end

-- Promote by Steam ID
hook.add("PlayerConnect", "auto_admin", function(player)
  if player.get_steam_id(player) == "76561198000000000" then
    player.set_admin(player, true)
  end
end)

player.send_message(player, "You are the last survivor!")

local ping = player.get_ping(player)
ui.set_text(ping_label, ping .. "ms")

-- End round: show scores for all players
local players = player.get_all()
for _, p in ipairs(players) do
  print(player.get_name(p), player.get_kills(p))
end

if player.get_count() < 2 then
  game.set_state("waiting")
end

-- Create two teams at game start
local red  = team.create("Red",  { color = Color3.new(1, 0.2, 0.2), max_players = 8 })
local blue = team.create("Blue", { color = Color3.new(0.2, 0.4, 1), max_players = 8 })

-- Auto-balance: assign new player to smaller team
local function assign_team(player)
  local red_count  = #team.get_players(red_id)
  local blue_count = #team.get_players(blue_id)
  local target     = red_count <= blue_count and red_id or blue_id
  team.add_player(target, player)
end

-- Remove from team on disconnect
hook.add("PlayerDisconnect", "team.cleanup", function(player)
  team.remove_player(player)
end)

local reds = team.get_players(red_id)
print("Red team size:", #reds)

local rs = team.get_score(red_id)
local bs = team.get_score(blue_id)
ui.set_text(scoreboard, rs .. " — " .. bs)

-- Award point on flag capture
hook.add("FlagCaptured", "ctf.score", function(capturing_player)
  local tid = player.get_team(capturing_player)
  team.add_score(tid, 1)
end)

-- Clean up teams at round end
hook.add("RoundEnd", "team.cleanup", function()
  team.destroy(red_id)
  team.destroy(blue_id)
end)

for _, tid in ipairs(team.get_all()) do
  print("Team:", tid, "score:", team.get_score(tid))
end

-- Listen for player spawns
hook.add("PlayerSpawn", "my_mod.on_spawn", function(player)
  char.set_health(player, 100)
  local pos = spawn.get_random_point()
  rawframe.set_position(player, pos)
  print("Player spawned at", pos)
end)

-- Remove the listener when the round ends
hook.add("RoundEnd", "my_mod.cleanup", function()
  hook.remove("PlayerSpawn", "my_mod.on_spawn")
end)

-- Fire a custom hook and check if any mod cancels it
local cancelled = hook.run("PlayerTakeDamage", player, 25, "bullet")

if cancelled == false then
  print("Damage was cancelled by a mod")
end

local listeners = hook.get_table("Think")
for id, fn in pairs(listeners) do
  print("Listener:", id)
end

if game.get_state() == "playing" then
  -- Allow player actions
end

-- Start round when enough players connect
hook.add("PlayerConnect", "check_start", function()
  if player.get_count() >= 2 and game.get_state() == "waiting" then
    game.set_state("starting")
    timer.after(5.0, function()
      game.set_state("playing")
    end)
  end
end)

print("Playing on map:", game.get_map())

local limit = 300  -- 5 minute round
if game.get_elapsed_time() >= limit then
  game.end_round()
end

hook.add("Think", "round_timer", function()
  if game.get_state() == "playing" and game.get_elapsed_time() > 300 then
    game.end_round(nil)  -- time limit draw
  end
end)

local dt_expected = 1 / game.get_tick_rate()
print("Tick interval:", dt_expected, "seconds")

local first = game.get_player(1)
if first then
  print(player.get_name(first))
end

for _, p in ipairs(game.get_all_players()) do
  char.set_health(p, 100)
end

-- Register spawn points from map markers
for _, marker in ipairs(rawframe.find_by_tag("spawn_marker")) do
  spawn.add_point(rawframe.get_position(marker), {
    team_id = rawframe.has_tag(marker, "team_red") and red_id or blue_id,
  })
end

spawn.remove_point(destroyed_spawn_id)

hook.add("PlayerSpawn", "spawn.place", function(player)
  local tid = player.get_team(player)
  local pos = spawn.get_random_point(tid)
  char.teleport(player, pos)
end)

for _, sp in ipairs(spawn.get_all_points()) do
  print("Spawn at", sp.position, "team:", sp.team_id)
end

-- Spawn player far from enemies
local enemy_center = rawframe.get_position(enemy_team_leader)
local safe_pos = spawn.get_farthest_point(enemy_center, my_team_id)
char.teleport(player, safe_pos)

-- Respawn player 3 seconds after death
hook.add("CharacterDied", "respawn", function(player)
  timer.after(3.0, function()
    if rawframe.is_valid(player) then
      char.teleport(player, spawn.get_random_point())
      char.set_health(player, 100)
    end
  end)
end)

-- Bleed tick: deal 2 damage every second
local bleed_timer = timer.every(1.0, function()
  if not char.is_alive(wounded_player) then
    timer.remove(bleed_timer)
    return
  end
  char.damage(wounded_player, 2, "bleed")
end)

local t = timer.every(5.0, heal_player)

-- Stop healing when player leaves the zone
hook.add("ZoneExit", "stop_heal", function(player)
  timer.remove(t)
end)

local start = timer.get_time()
-- ... do work ...
local elapsed = timer.get_time() - start
print("Elapsed:", elapsed)

local rotation = 0
hook.add("Think", "spinner", function()
  rotation = rotation + 90 * timer.get_delta()  -- 90 deg/sec
  rawframe.set_rotation(wheel, Quat.from_axis_angle(Vec3.new(0, 1, 0), math.rad(rotation)))
end)

local info = mod.get_info()
print(info.name, "v" .. info.version, "by", info.author)

local cfg = mod.get_config()
local round_time = cfg.round_time or 300

mod.set_config("round_time", 180)
mod.set_config("friendly_fire", false)

-- Call an inventory mod's API
local item_count = mod.call("inventory_mod", "get_item_count", player, "ammo_556")

local utils  = mod.require("lib/utils")
local config = mod.require("config")

local mod_dir = mod.get_path()
audio.preload(mod_dir .. "/sounds/custom.ogg")

-- Expose an API for other mods
mod.export("get_leaderboard", function()
  return leaderboard_data
end)

if mod.is_loaded("premium_weapons") then
  weapon.create("weapons/railgun")
end

local ver = mod.get_version()
print("My mod version:", ver)

mod.log("Round started with " .. player.get_count() .. " players")
mod.log("Config missing key: round_time", "warn")

local kills = storage.get("player_stats", player_uid, 0)
print("Player has", kills, "lifetime kills")

-- Save kills on round end
storage.set("player_stats", player_uid, total_kills)

storage.delete("temp_data", session_id)

-- Top 10 players by kills
local rows = storage.query([[
  SELECT key, value FROM player_stats
  ORDER BY CAST(value AS INTEGER) DESC
  LIMIT 10
]])
for i, row in ipairs(rows) do
  print(i, row.key, row.value)
end

storage.execute([[
  CREATE TABLE IF NOT EXISTS bans (
    uid TEXT PRIMARY KEY,
    reason TEXT,
    expires INTEGER
  )
]])

local all_stats = storage.get_all("player_stats")
for uid, kills in pairs(all_stats) do
  print(uid, ":", kills, "kills")
end

if storage.has("bans", player_uid) then
  player.kick(player, "You are banned.")
end

-- Track total kills on the server
hook.add("CharacterDied", "stats.total", function()
  local total = storage.increment("server_stats", "total_kills")
  print("Total server kills:", total)
end)

hook.add("ServerShutdown", "db.flush", function()
  storage.flush()
end)

local ban_count = storage.get_size("bans")
print(ban_count, "players are banned")

http.get("https://api.example.com/leaderboard", function(status, body)
  if status == 200 then
    local data = game.json_decode(body)
    update_leaderboard_ui(data)
  else
    mod.log("HTTP error: " .. status, "warn")
  end
end)

local payload = '{"player":"' .. player_uid .. '","kills":' .. kills .. '}'
http.post("https://stats.myserver.com/submit", payload, function(status, body)
  if status ~= 200 then
    mod.log("Failed to submit stats: " .. status, "error")
  end
end, { ["Content-Type"] = "application/json" })

http.request({
  url    = "https://api.example.com/items/42",
  method = "DELETE",
  headers = { ["Authorization"] = "Bearer " .. api_token },
}, function(status, headers, body)
  print("DELETE status:", status)
end)

local jeep = vehicle.create("vehicles/jeep", Vec3.new(20, 0, 0))
net.replicate(jeep, { rate = 30 })

net.receive("drive_input", function(peer, data)
  local vehicle_ent = get_player_vehicle(peer)
  vehicle.set_throttle(vehicle_ent, data.throttle)
  vehicle.set_steering(vehicle_ent, data.steering)
end)

vehicle.set_steering(car, input.get_gamepad_axis("LeftX"))

if input.is_key_down("Space") then
  vehicle.set_brake(car, 1.0)
else
  vehicle.set_brake(car, 0.0)
end

local spd = vehicle.get_speed(car) * 3.6  -- convert to km/h
ui.set_text(speedometer, string.format("%.0f km/h", spd))

camera.set_roll(vehicle.get_steering(car) * -3)

hook.add("VehicleEnter", "driver_seat", function(player, vehicle_ent)
  vehicle.set_driver(vehicle_ent, player)
end)

-- Eject driver when vehicle health reaches 0
hook.add("VehicleDestroyed", "eject", function(vehicle_ent)
  vehicle.eject_driver(vehicle_ent)
end)

local driver = vehicle.get_driver(car)
if driver then
  print(player.get_name(driver), "is driving")
end

-- Repair vehicle at a mechanic
vehicle.set_health(car, 1000)

timer.after(30.0, function()
  if rawframe.is_valid(abandoned_car) then
    vehicle.destroy(abandoned_car)
  end
end)