Asset Management

Assets are files your game uses at runtime — textures, audio, data files, and more. The webgame.cloud console gives you a full workflow for uploading, organizing, and versioning assets.

Uploading Files

Upload assets by dragging files onto the Assets page or using the upload button. Files land in a staging area (uncommitted changes) where you can review them before committing.

You can upload multiple files at once. The console detects file types automatically and shows previews for images and playback for audio.

Staging and Committing

The asset workflow follows a commit-based model:

1. Upload — files appear as uncommitted changes
2. Review — check file names, sizes, and previews
3. Commit — finalize changes to make them available for bundles

This prevents accidental publishes and gives you a chance to batch related changes together.

Categories

Categories are folder-like groupings for your assets:

• Create categories from the Assets page sidebar
• Drag assets into categories, or assign during upload
• Nest categories for deeper organization (e.g. sprites/enemies/boss)
• Each asset belongs to exactly one category

Tags

Tags provide flexible cross-cutting labels:

• Add multiple tags per asset (e.g. hd, player, animated)
• Use tags to build smart bundle filters
• Batch-edit tags across multiple assets at once
• Tags are free-form text — create whatever taxonomy works for your game

Filtering and Search

The asset browser supports complex queries:

• By name — search by filename or partial match
• By category — filter to a specific category tree
• By tag — include or exclude specific tags
• By type — show only images, audio, JSON, etc.
• Combined — stack multiple filters for precise results

Asset Details

Click any asset to view:

• Full preview (images render inline, audio has playback controls)
• File metadata (size, type, dimensions for images)
• Category and tags
• Upload date and last modified timestamp

Bundles and Builds

Bundles define what to include in a delivery package. Builds are the output — optimized, versioned snapshots ready to serve via CDN.

Creating a Bundle

1. Go to the Bundles tab in your project
2. Click New Bundle
3. Give it a name (e.g. main-assets, audio-pack, hd-textures)
4. Configure asset filters to select which files to include

Bundle Filters

Bundles use tag and category filters to dynamically select assets:

• Include by tag — e.g. all assets tagged hd
• Include by category — e.g. everything under sprites/
• Combine filters — include sprites/ category AND player tag

When you add or remove assets that match the filter, the bundle contents update automatically on next build.

Bundle Settings

Each bundle has processing settings:

• Scale ratios — generate multiple resolutions (1x, 0.5x, 0.25x) for different device classes
• Compression — choose compression algorithm for images
• Rotation — enable texture rotation for tighter atlas packing

Triggering a Build

Once your bundle is configured:

1. Click Build on the bundle page
2. The build enters a queue and progresses through stages: queued → running → passed (or failed)
3. Watch progress in real time on the build detail page

Build History

Every build is versioned and stored:

• Tag builds for release management (e.g. v1.0, beta-3)
• Inspect contents — browse the files included in any build by type
• Compare builds — see what changed between versions
• Purge untagged — clean up test builds to free storage

CDN Delivery

Successful builds are automatically deployed to the global CDN:

• Assets are served from edge locations worldwide
• Each build gets a unique URL so you can switch versions without downtime
• Cache headers are configured for optimal performance
• Your game loads the build URL from a live config — update the URL to roll out a new version

Live Configs

Live configs let you change game behavior without deploying a new build. Update balance numbers, toggle features, schedule events — all from the console while players stay online.

How It Works

1. Define a schema that describes the shape of your config data
2. Create a config linked to that schema
3. Edit values through the auto-generated form editor
4. Publish — your game reads the updated config via the API

Changes are available immediately. No build, no deploy, no downtime.

Schemas

Schemas define the structure of your config data using JSON Schema:

Supported Types

Type	Description	Example
string	Text values	Player greeting message
number	Numeric values	Coin reward amount
boolean	True/false toggles	Feature flags
object	Nested groups	Enemy stats (hp, speed, damage)
array	Lists of values	Loot table entries

Creating a Schema

1. Go to the Schemas tab
2. Click New Schema
3. Use the visual editor to add fields, set types, and configure validation rules
4. Save the schema — it's now available for configs to reference

Schema Syncing

When you update a schema, existing configs may need to sync:

• The console detects when a config's schema has changed
• A sync action updates the config structure to match the new schema
• Existing values are preserved where possible
• New fields get default values

Config Editor

The config editor auto-generates a form from your schema:

• Boolean fields → toggle switches
• Number fields → number inputs with min/max validation
• String fields → text inputs or textareas
• Objects → collapsible sections with nested fields
• Arrays → add/remove/reorder items

This means non-technical team members can safely edit game configs without touching raw JSON.

Reading Configs in Your Game

Your game fetches configs via the webgame.cloud API:

GET /api/v1/projects/{slug}/configs/{configName}

The response is a JSON object matching your schema. Cache it locally and poll for updates, or use webhooks for instant propagation.

Teams

Collaborate with your studio by inviting team members with role-based access control. Each project has its own team with independent permissions.

Inviting Members

1. Go to the Team tab in your project
2. Click Invite Member
3. Enter their email address and select a role
4. They'll receive an email invitation to join the project

Pending invitations show in the team list until accepted.

Roles

Each team member is assigned a role that controls what they can do:

Role	Assets	Bundles	Builds	Configs	Team	Settings
Admin	Full	Full	Full	Full	Manage	Full
Developer	Full	Full	Full	Full	View	View
Artist	Upload	View	View	View	View	—
Translator	View	—	—	Edit	View	—
Guest	View	View	View	View	View	—

Role Details

• Admin — full control, including managing team members and project settings. Can transfer ownership.
• Developer — can manage assets, bundles, builds, and configs. Cannot modify team or settings.
• Artist — focused on asset work. Can upload and organize files but cannot modify bundles or configs.
• Translator — can edit config values (for localization) but cannot modify schemas or assets.
• Guest — read-only access to everything. Useful for stakeholders or QA.

Project Ownership

Every project has one owner:

• The owner has Admin-level permissions plus the ability to delete the project
• Ownership can be transferred to another Admin team member
• The transfer requires confirmation from both parties

Managing Members

From the Team tab you can:

• Change roles — promote or demote a member's access level
• Remove members — revoke access immediately
• Resend invites — nudge pending invitations