API Playground

local v = rawframe.api_version()
      print("API v" .. tostring(v))

print("Engine: " .. rawframe.engine_version())

rawframe.log("Hello from Lua!")

if rawframe.is_server() then
      print("Server-side code")
      end

if rawframe.is_client() then
      print("Client-side code")
      end

rawframe.on_reload(function()
      print("Mod reloaded!")
      end)

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

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

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

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

      timer.delay(5.0, function()
      entity.destroy(box)
      print("Box destroyed.")
      end)

local copy = entity.clone(original_ent)

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

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

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

entity.set_rotation_quat(ent, 0, 0.707, 0, 0.707)

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

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

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

entity.set_mesh(ent, "models/barrel.gltf")

entity.set_skinned_mesh(ent, "models/character.gltf")

entity.load_mesh(ent, "models/crate.gltf")

entity.load_texture(ent, "textures/wood.ktx2")

entity.set_tag(chest, "lootable")
      entity.set_tag(chest, "interactable")

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

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

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

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

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

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

local boss = entity.create("enemies/boss")
      entity.set_name(boss, "FinalBoss_Arena1")

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

entity.set_layer(ent, value)

local val = entity.get_layer(ent)

entity.set_lod_group(ent, { 25, 50, 100 })

local lod = entity.get_lod_level(ent)

entity.remove_lod_group(ent)

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

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

entity.set_color(ent, value)

local val = entity.get_color(ent)

entity.set_opacity(ent, 0.5)

entity.set_frozen(ent, true)

local nearby = entity.find_in_sphere(pos, 10, "enemy")
      for _, e in ipairs(nearby) do
      character.damage(e, 50, "explosion")
      end

local in_zone = entity.find_in_box(Vec3.new(-5,0,-5), Vec3.new(5,10,5))
      print(#in_zone, "entities in zone")

local seen = entity.find_in_cone(origin, forward, 20, 45)
      for _, e in ipairs(seen) do print("In view:", e) end

local nearest_enemy = entity.find_nearest(pos, "enemy")
      if nearest_enemy then
      npc.follow(bot, nearest_enemy)
      end

local pickups = entity.find_by_class("Pickup")
      print(#pickups, "pickups remaining")

local n = entity.get_count_in_sphere(pos, 5, "enemy")
      if n > 3 then trigger_alert() end

entity.set_attribute(chest, "loot_tier", 3)
      entity.set_attribute(chest, "opened", false)

local tier = entity.get_attribute(chest, "loot_tier")
      print("Tier:", tier)

local attrs = entity.get_attributes(chest)
      for k, v in pairs(attrs) do print(k, v) end

entity.remove_attribute(chest, "loot_tier")

entity.on_attribute_changed(door, "locked", function(e, k, new, old)
      print("Door lock changed:", old, "->", new)
      end)

local parts = entity.get_descendants(vehicle)
      for _, p in ipairs(parts) do print("Part:", entity.get_name(p)) end

entity.set_class(pickup, "Pickup")

print("Class:", entity.get_class(e))

local checkpoints = entity.find_by_name("Checkpoint")
      print(#checkpoints, "checkpoints found")

local enemy_count = entity.count("enemy")
      if enemy_count == 0 then game.set_state("RoundEnd") end

local gun = entity.create_attachment(soldier, "hand_r", "weapons/rifle")

local muzzle = entity.get_attachment_world_pos(soldier, "muzzle")
      audio.play("sounds/gunshot", muzzle)

local origin = entity.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

physics.on_collision(ent, function(other, point, normal)
  print("Hit!", other)
end)

physics.off_collision(ent)

physics.on_collision_stay(ent, function(other)
  print("Still touching")
end)

physics.off_collision_stay(ent)

physics.clear_collision_callbacks(ent)

local box = entity.create("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.destroy_body(player)

physics.add_impulse(body, vec3.new(0, 100, 0))

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

-- 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 val = physics.get_angular_velocity(body)

physics.set_angular_velocity(body, value)

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

physics.set_friction(body, value)

local val = physics.get_friction(body)

physics.set_restitution(body, value)

local val = physics.get_restitution(body)

local val = physics.get_position(body)

local val = physics.get_rotation(body)

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

local val = physics.get_gravity(body)

local weld = physics.create_weld(body_a, body_b)

local hinge = physics.create_hinge(body_a, body_b, {
  axis = vec3.up(),
  min_angle = -90,
  max_angle = 90
})

local obj = physics.create_slider(params)

local rope = physics.create_rope(body_a, body_b, 5.0)

local spring = physics.create_spring(body_a, body_b, {
  stiffness = 100,
  damping = 10
})

physics.destroy_constraint(constraint_handle)

physics.set_constraint_break_force(body, value)

local val = physics.get_constraint_break_force(body)

physics.create_trigger(ent, { shape = "sphere", radius = 5 })

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

physics.optimize_broadphase()

physics.apply_buoyancy(body, water_level, 1.0)

local bodies = physics.query_aabb(vec3.new(-10, 0, -10), vec3.new(10, 5, 10))

physics.create_water({ level = 0, flow = vec3.zero() })

physics.set_water_level(body, value)

local val = physics.get_water_level(body)

physics.set_water_flow(body, value)

physics.remove_water(water_handle)

local rag = physics.create_ragdoll(character_ent)

physics.activate_ragdoll(ent)

physics.deactivate_ragdoll(ent)

physics.impulse_ragdoll(ent, "spine", vec3.new(0, 0, -500))

physics.destroy_ragdoll(ent)

physics.create_cloth(ent, { stiffness = 0.8 })

physics.destroy_cloth(ent)

physics.set_cloth_wind(body, value)

physics.pin_cloth_vertex()

physics.unpin_cloth_vertex()

local val = physics.get_cloth_vertex_count(body)

physics.set_layer_name(body, value)

local val = physics.get_layer_name(body)

local val = physics.get_layer_count(body)

local idx = physics.find_layer("characters")

local mask = physics.layer_mask(0, 1, 3)

physics.set_collision_pair(body, value)

local val = physics.get_collision_pair(body)

physics.set_layer_mask_row(body, value)

local val = physics.get_layer_mask_row(body)

physics.set_body_layer(body, value)

local val = physics.get_body_layer(body)

local bodies = physics.sphere_query(center, 10.0)

-- Launch a crate upward
      local crate = entity.create("props/crate", Vec3.new(0, 1, 0))
      physics.add_force(crate, Vec3.new(0, 500, 0))

physics.add_torque(top, Vec3.new(0, 10, 0))

physics.add_force_at(car, Vec3.new(0, 2000, 0), hit.position)

physics.set_gravity_factor(balloon, 0.0)

physics.set_mass(crate, 200)

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

physics.set_damping(ball, 0.1, 0.05)

local lin, ang = physics.get_damping(ball)

physics.enable_motion(platform, false)

if not physics.is_motion_enabled(platform) then
      physics.enable_motion(platform, true)
      end

physics.sleep(debris)

physics.wake(debris)

if physics.is_sleeping(boulder) then print("Boulder is at rest") end

local hits = physics.raycast_all(origin, dir, 50)
      for _, hit in ipairs(hits) do
      print("Hit:", hit.entity, hit.distance)
      end

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

local contacts = physics.get_contacts(player)
      for _, e in ipairs(contacts) do print("Touching:", e) end

if physics.overlap_test(pos, 2) then print("Something is here") end

local rope = physics.create_distance(anchor, bob, 0, 5)

physics.set_motor(door_hinge, 2.0, 500)

print(physics.get_constraint_type(c))

local joint = physics.create_ball_socket(torso, arm, shoulder_pos)

physics.create_align_position(follower, target)

physics.create_align_orientation(turret, base)

physics.create_no_collision(player, carried_object)

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

audio.play_3d("sounds/explosion.ogg", hit_position)

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

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

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

audio.set_master_volume(value)

local val = audio.get_master_volume()

audio.pause(music)

audio.resume(music)

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

local len = audio.get_length(music)
      print("Track length:", len, "s")

local t = audio.get_time(music)

audio.set_time(music, 30.0)

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

audio.set_loop(ambient, true)

audio.set_rolloff(explosion, 2.0)

audio.fade(music, 0.0, 3.0)  -- fade out over 3 seconds

audio.create_group("sfx")
      audio.create_group("music")

audio.set_group_volume("music", 0.5)

local snd = audio.play("sounds/theme.ogg")
      audio.assign_group(snd, "music")

print("Music volume:", audio.get_group_volume("music"))

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

local val = camera.get_mode()

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

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

camera.set_sensitivity(value)

camera.set_pitch_limit(value)

camera.set_distance(value)

camera.set_height(value)

camera.set_offset(value)

camera.set_shoulder(value)

-- 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

camera.set_zoom(1, 30, 0.3)

camera.set_target(1, player_ent)

camera.reset_target(1)

camera.set_near_far(value)

local val = camera.get_near_far()

camera.set_active(camera_ent)

character.set_walk_speed(peer_id, value)

local val = character.get_walk_speed(peer_id)

character.set_run_speed(peer_id, value)

local val = character.get_run_speed(peer_id)

character.set_crouch_speed(peer_id, value)

local val = character.get_crouch_speed(peer_id)

character.set_jump_power(peer_id, value)

local val = character.get_jump_power(peer_id)

character.set_max_jumps(peer_id, value)

local val = character.get_max_jumps(peer_id)

character.set_gravity_scale(peer_id, value)

local val = character.get_gravity_scale(peer_id)

character.set_air_control(peer_id, value)

local val = character.get_air_control(peer_id)

character.set_friction(peer_id, value)

local val = character.get_friction(peer_id)

character.set_step_height(peer_id, value)

local val = character.get_step_height(peer_id)

character.set_max_slope(peer_id, value)

local val = character.get_max_slope(peer_id)

character.set_capsule(peer_id, 0.4, 1.8)

character.set_crouch_height(peer_id, value)

local val = character.get_crouch_height(peer_id)

local val = character.get_move_state(peer_id)

if character.is_on_ground() then
  print("true")
end

if character.is_crouching() then
  print("true")
end

if character.is_sprinting() then
  print("true")
end

if character.is_in_air() then
  print("true")
end

character.set_move_type(peer_id, "fly")

character.freeze(peer_id, true)

character.set_noclip(peer_id, true)

character.set_godmode(peer_id, value)

local val = character.get_godmode(peer_id)

local val = character.get_velocity(peer_id)

character.set_velocity(peer_id, value)

character.add_impulse(peer_id, vec3.new(0, 500, 0))

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