Player identity

func print_player():
    var user = WavedashSDK.get_user()
    var user_id = WavedashSDK.get_user_id()
    var username = WavedashSDK.get_username()
    print(user_id, " ", username, " ", user)

void PrintPlayer()
{
    var userId = Wavedash.SDK.GetUserId();
    var user = Wavedash.SDK.GetUser();
    Debug.Log($"{userId} {user?["username"]}");
}

local user = wavedash.get_user()
local user_id = wavedash.get_user_id()
local username = wavedash.get_username()
print(user_id, username, user)

const user = Wavedash.getUser();
const userId = Wavedash.getUserId();
const username = Wavedash.getUsername();
console.log(userId, username, user);

var name = WavedashSDK.get_username(peer_user_id)

string name = Wavedash.SDK.GetUsername(peerUserId);

local name = wavedash.get_username(peer_user_id)

const name = Wavedash.getUsername(peerUserId);

func send_to_my_backend():
    var response = await WavedashSDK.get_user_jwt()
    if not response.success:
        return
    var jwt = response.data
    # forward `jwt` to your own server in the Authorization header

async void SendToMyBackend()
{
    string jwt = await Wavedash.SDK.GetUserJwt();
    if (string.IsNullOrEmpty(jwt))
        return;
    // forward `jwt` to your own server in the Authorization header
}

local co = coroutine.create(function()
    local response = wavedash.get_user_jwt_async()
    if not response.success then
        return
    end

    local jwt = response.data
    -- forward `jwt` to your own server in the Authorization header
end)
assert(coroutine.resume(co))

const response = await Wavedash.getUserJwt();
if (response.success) {
  const jwt = response.data;
  // forward `jwt` to your own server in the Authorization header
}

func _ready():
    WavedashSDK.got_friends.connect(_on_got_friends)

func load_friends():
    WavedashSDK.list_friends()

func _on_got_friends(response):
    if response.get("success", false):
        for friend in response.get("data", []):
            print(friend["username"], " - Online: ", friend["isOnline"])

async void Start()
{
    var friends = await Wavedash.SDK.ListFriends();
    if (friends != null)
    {
        foreach (var friend in friends)
            Debug.Log($"{friend["username"]} - Online: {friend["isOnline"]}");
    }
}

local co = coroutine.create(function()
    local response = wavedash.list_friends_async()
    if response.success then
        for _, friend in ipairs(response.data) do
            print(friend.username, "- Online:", friend.isOnline)
        end
    end
end)
assert(coroutine.resume(co))

const response = await Wavedash.listFriends();
if (response.success) {
  response.data.forEach(friend => {
    console.log(`${friend.username} - Online: ${friend.isOnline}`);
  });
}

# Just the URL — cheap, synchronous
var url = WavedashSDK.get_user_avatar_url(user_id, WavedashConstants.AVATAR_SIZE_MEDIUM)

# Or: async helper that fetches + decodes to a Texture2D and emits a signal
func _ready():
    WavedashSDK.user_avatar_loaded.connect(_on_avatar_loaded)

func load_friend_avatar(user_id: String):
    WavedashSDK.get_user_avatar(user_id, WavedashConstants.AVATAR_SIZE_MEDIUM)

func _on_avatar_loaded(texture: Texture2D, user_id: String):
    if texture:
        $AvatarSprite.texture = texture

// Just the URL — cheap, synchronous
string url = Wavedash.SDK.GetUserAvatarUrl(userId, WavedashConstants.AvatarSize.MEDIUM);

// Or: async helper that fetches + decodes to a Texture2D
public async void LoadFriendAvatar(string userId)
{
    var texture = await Wavedash.SDK.GetUserAvatar(userId, WavedashConstants.AvatarSize.MEDIUM);
    if (texture != null)
        avatarImage.texture = texture;
}

local url = wavedash.get_user_avatar_url(user_id, wavedash.AVATAR_SIZE_MEDIUM)
if url then
    print("Avatar URL:", url)
end

const url = Wavedash.getUserAvatarUrl(userId, Wavedash.AvatarSize.MEDIUM);
if (url) {
  const img = new Image();
  img.src = url;
}

await WavedashSDK.update_user_presence({
    "status": "Traveling in a group",
    "details": "Eastfield Forest"
})

await Wavedash.SDK.UpdateUserPresence(new Dictionary<string, object> {
    { "status", "Traveling in a group" },
    { "details", "Eastfield Forest" }
});

local co = coroutine.create(function()
    local response = wavedash.update_user_presence_async(json.encode({
        status = "Traveling in a group",
        details = "Eastfield Forest",
    }))
    print("Presence updated:", response.success)
end)
assert(coroutine.resume(co))

await Wavedash.updateUserPresence({
  status: "Traveling in a group",
  details: "Eastfield Forest"
});

await WavedashSDK.update_user_presence({})

await Wavedash.SDK.UpdateUserPresence(new Dictionary<string, object>());

local co = coroutine.create(function()
    wavedash.update_user_presence_async(json.encode({}))
end)
assert(coroutine.resume(co))

await Wavedash.updateUserPresence({});