Mastering code random number generator defold principles and

Custom Random Number Generator Implementations in Defold

Implementation of LCG and Mersenne Twister in Lua

Linear Congruential Generator (LCG)

Xₙ₊₁ = (a Xₙ + c) mod m

where `a`, `c`, and `m` are constants, and `Xₙ` is the seed.

Lua Implementation:

local LCG = {}
LCG.__index = LCG

function LCG.new(seed)
local self = setmetatable({}, LCG)
self.state = seed or os.time()
self.a = 1664525
self.c = 1013904223
self.m = 2^32
return self
end

function LCG:next()
self.state = (self.a self.state + self.c) % self.m
return self.state / self.m -- Normalize to [0, 1)
end

function LCG:nextInt(max)
return math.floor(self:next() max) + 1
end

Key Features:

### Mersenne Twister (MT19937)
The Mersenne Twister offers a longer period (2¹⁹⁹³⁷⁻¹) and superior statistical randomness, making it suitable for procedural generation or simulations requiring high-quality pseudorandomness.

Lua Implementation (Port of C MT19937):

local MT = {}
MT.__index = MT

-- Constants and initialization omitted for brevity; full implementation requires ~200 lines.
-- See: https://github.com/rb2d/lua-mersenne-twister (reference for Defold compatibility)

function MT.new(seed)
local self = setmetatable({}, MT)
self.state = {} -- Internal state array (4D matrix)
self.index = 0
self.seed(seed) -- Initialize with seed
return self
end

function MT:next()
-- Twist and extract logic (simplified)
if self.index == 0 then
self:twist()
end
self.index = self.index + 1
local y = self.state[self.index]
y = y ~ ((y ~ (y >> 11)) << 7) & 0x9d2c5680
y = y ~ ((y ~ (y << 15)) << 18) & 0xefc60000
y = y ~ ((y ~ (y >> 18)) << 15)
return y / 0xFFFFFFFF
end

Advantages Over LCG:

Integration with Defold Game Objects

Thread-Safe PRNG in Defold

1. Singleton Pattern for Global Randomness:

local rng = LCG.new(os.time()) -- Initialize once in `init()`

function on_input(self, action_id, action)
if action_id == hash("spawn") then
local x = rng:nextInt(100)
msg.post("/spawner", "spawn_object", {x = x})
end
end

2. Thread-Safe Wrapper for C++ Extensions:

// In a Defold extension:
static int lcg_next(lua_State* L) {
LCG rng = (LCG)lua_touserdata(L, lua_upvalueindex(1));
lua_pushnumber(L, rng->next());
return 1;
}

- Call from Lua:

local lcg = LCG.new(seed)
local next = go.bind(lcg, "next")

3. Procedural Level Generation Example:

local function generate_level(seed, width, height)
local rng = MT.new(seed)
local level = {}
for y = 1, height do
level[y] = {}
for x = 1, width do
level[y][x] = rng:nextInt(3) -- 0: empty, 1: wall, 2: collectible
end
end
return level
end

Common PRNG Pitfalls in Defold and Mitigation Strategies

- Predictable Sequences Due to Weak Seeds

- Lack of Thread Safety in Multi-Core Scenarios

- Poor Statistical Properties for Complex Systems

- Performance Overhead in Tight Loops

- Entropy Exhaustion in Long-Running Games

Cryptographic Randomness vs. Pseudorandomness in Defold

Cryptographic randomness is unnecessary for 99% of Defold games, as its primary requirements are speed, determinism, and statistical fairness—not security. Pseudorandom number generators (PRNGs) like LCG or Mersenne Twister are designed for performance, with predictable outputs from fixed seeds, enabling reproducible procedural content (e.g., level generation, enemy paths). Cryptographic PRNGs (e.g., `/dev/urandom` on Linux) introduce:

Unnecessary overhead: Cryptographic algorithms (e.g., ChaCha20) are 100–1000x slower than LCG.

Non-determinism: Seeds vary per run, breaking save/load reproducibility.

Overkill for game logic: Attacks targeting PRNGs in games are rare compared to, e.g., network exploits.

For Defold, alternatives to cryptographic randomness include:

Mersenne Twister: Best balance of speed and quality for procedural generation.

PCG (Permuted Congruential Generator): Faster than MT with similar properties (see [PCG documentation](https://www.pcg

Practical Applications of Randomness in Defold Games

Random number generation (RNG) serves as the backbone of dynamic, unpredictable, and engaging gameplay in Defold. While determinism offers consistency, strategic depth, and reproducibility, randomness introduces variability, replayability, and emergent behavior. This section explores five critical game mechanics where RNG is indispensable, accompanied by Lua implementations, comparative analysis, and procedural techniques to balance randomness with fairness.

Five Critical Game Mechanics Utilizing Random Number Generation

Randomness enhances player immersion by simulating unpredictability in virtual worlds. Below are five mechanics where RNG is pivotal, along with Lua examples for Defold integration.

1. Loot Drops and Procedural Rewards
Dynamic loot systems reward exploration and skill while maintaining fairness. RNG determines drop rates, rarity tiers, and item combinations. A weighted random selection ensures balanced loot distribution without hardcoding every possibility.

-- Weighted loot drop system in Defold
local function generate_loot(weights)
local total_weight = 0
for _, weight in ipairs(weights) do
total_weight = total_weight + weight
end

local random_value = math.random() total_weight
local cumulative_weight = 0

for index, weight in ipairs(weights) do
cumulative_weight = cumulative_weight + weight
if random_value <= cumulative_weight then
return index -- Return the selected loot index
end
end
return #weights -- Fallback to last item if no match (edge case)
end

-- Example usage: weights = {0.1, 0.3, 0.6} (10% common, 30% uncommon, 60% rare)
local loot_weights = {10, 30, 60}
local dropped_item = generate_loot(loot_weights)

2. Enemy AI Decisions and Behavior Trees
Randomness in AI prevents predictable patterns, forcing players to adapt. Enemies may randomly choose between attacks, evasions, or environmental interactions while adhering to predefined probabilities.

-- Randomized enemy behavior selection
local function choose_enemy_action(action_weights)
local actions = {"attack", "dodge", "use_ability", "ambush"}
return actions[generate_loot(action_weights)]
end

-- Example: 60% attack, 20% dodge, 15% ability, 5% ambush
local enemy_weights = {60, 20, 15, 5}
local action = choose_enemy_action(enemy_weights)

3. Procedural Terrain and World Generation
RNG generates diverse environments, from dungeon layouts to open-world biomes. Perlin noise and seeded randomness ensure reproducibility while maintaining visual variety.

-- Simple procedural terrain heightmap using seeded RNG
math.randomseed(os.time()) -- Seed for variability (or use a fixed seed for reproducibility)
local function generate_terrain(width, height, seed)
math.randomseed(seed)
local terrain = {}
for y = 1, height do
terrain[y] = {}
for x = 1, width do
terrain[y][x] = math.random(0, 100) -- Simplified height value
end
end
return terrain
end

local terrain_map = generate_terrain(50, 50, 42) -- Fixed seed for testing

4. Quest and Event Triggers
Random quests or dynamic events prevent monotony. RNG determines spawn rates, difficulty scaling, and event chains while respecting game balance constraints.

-- Random event spawner with cooldowns
local active_events = {}
local cooldowns = {min=30, max=120} -- Seconds

local function spawn_random_event()
if #active_events < 3 then -- Limit concurrent events
local event_types = {"boss_fight", "treasure_hunt", "puzzle_challenge"}
local event = event_types[math.random(1, #event_types)]
local cooldown = math.random(cooldowns.min, cooldowns.max)
table.insert(active_events, {type=event, cooldown=cooldown})
return event
end
return nil
end

5. Combat Systems: Critical Hits and Status Effects
Randomized combat introduces tension and skill expression. Critical hit chances, elemental resistances, and debuff durations rely on RNG while maintaining fairness through weighted distributions.

-- Weighted critical hit system with reproducibility
local function roll_critical(crit_chance, crit_multiplier)
if math.random() <= crit_chance then
return true, crit_multiplier
else
return false, 1.0
end
end

-- Example: 10% crit chance, 2x damage multiplier
local is_crit, multiplier = roll_critical(0.10, 2.0)

Comparative Analysis: Deterministic vs. Randomized Game Elements

The following table contrasts deterministic and randomized mechanics in Defold, highlighting trade-offs in player experience and development effort.

Aspect	Deterministic Elements	Randomized Elements
Player Experience	Consistent outcomes foster skill mastery and strategic depth. Predictable patterns enable meta-game optimization (e.g., speedrunning). Reduces frustration from RNG-induced unfairness (e.g., loot roulette).	Introduces replayability and emergent storytelling. Unpredictability increases tension and excitement (e.g., boss fights). Risk-reward mechanics encourage experimentation (e.g., gambling mini-games).
Development Effort	Requires meticulous balancing to avoid trivialization or exploitation. Harder to scale for procedural content (e.g., infinite dungeons). Debugging is straightforward due to reproducibility.	Simplifies content creation via procedural generation. Demands robust testing for edge cases (e.g., exploit loops). May necessitate additional systems (e.g., RNG seeds for save states).
Hybrid Approach (Recommended)	Combine deterministic core mechanics with randomized surface-level elements. Example: A fixed skill tree (deterministic) with randomized enemy drops (randomized). Use weighted distributions and player feedback loops to mitigate RNG fatigue.

Procedural Generation of Balanced Game Stats Using Weighted Distributions

Weighted distributions ensure randomness adheres to design constraints, such as character attributes or enemy health pools. Below is a Lua implementation for generating balanced stats while respecting predefined ranges and correlations.

-- Weighted stat generation with constraints
local function generate_balanced_stats(base_stats, weights, min, max)
local stats = {}
for i, stat in ipairs(base_stats) do
-- Apply weighted randomness within bounds
local deviation = (math.random() - 0.5) weights[i] 0.5 -- ±25% of weight
stats[stat] = math.max(
min[stat],
math.min(
max[stat],
base_stats[stat] + deviation
)
)
end
return stats
end

-- Example: Character stats (Strength, Dexterity, Intelligence)
local base_stats = {Strength=10, Dexterity=8, Intelligence=6}
local weights = {Strength=0.3, Dexterity=0.4, Intelligence=0.3} -- Higher weight = more variability
local min_stats = {Strength=5, Dexterity=3, Intelligence=2}
local max_stats = {Strength=15, Dexterity=13, Intelligence=12}

local player_stats = generate_balanced_stats(base_stats, weights, min_stats, max_stats)

Key Considerations:

Correlation Control: Adjust weights to enforce stat synergies (e.g., high Strength may reduce Dexterity).

Clamping: Ensure values stay within playable ranges to prevent exploits.

Seeding: Use fixed seeds for testing to reproduce edge cases.

Debugging and Testing Random Number Behavior in Defold

Random number generation (RNG) in game development requires rigorous validation to ensure fairness, predictability, and consistency—especially in Defold, where procedural generation, AI behavior, and game mechanics rely on reliable pseudo-randomness. Debugging RNG behavior involves detecting biases, visualizing sequences, and validating statistical properties through automated tests. This section provides structured methodologies for logging, testing, and reproducing RNG-related issues, alongside a framework for unit testing custom PRNG implementations in Defold.

Logging and Visualizing Random Number Sequences in Defold’s Console

Defold’s built-in `go` and `msg.post` system enables real-time logging of RNG outputs, which is essential for identifying patterns, biases, or unexpected values. For debugging, sequences can be visualized as text streams or formatted tables in the Defold Console, allowing developers to compare distributions against theoretical expectations.

To log a sequence of random numbers (e.g., using `math.randomseed` and `math.random`), include the following script in a game object:

local function log_random_sequence(seed, count)
math.randomseed(seed)
local sequence = {}
for i = 1, count do
sequence[i] = math.random()
end
msg.post("#console", "vsc.log", { message = "RNG Sequence (Seed=" .. seed .. "): " .. table.concat(sequence, ", ") })
end

Key techniques for visualization:

Histogram Generation: Use Lua tables to count occurrences of value ranges (e.g., bins of 0.1) and print them as bar graphs in the console.

Seed-Based Reproduction: Log sequences with fixed seeds to verify deterministic behavior across sessions.

Threshold Alerts: Highlight values outside expected ranges (e.g., `if value > 0.999 or value < 0.001 then msg.post("#console", "vsc.error", {...})`).

For advanced visualization, integrate with Defold’s Debug Draw to plot sequences as line graphs or scatter plots during gameplay.

Statistical Validation of Custom PRNGs Using Chi-Square Test

Custom pseudo-random number generators (PRNGs) in Defold must undergo statistical tests to ensure uniformity and independence. The chi-square goodness-of-fit test evaluates whether observed frequencies match expected uniform distributions.

Below is a Lua implementation for testing a custom PRNG (e.g., a modified Linear Congruential Generator) against a uniform distribution:

local function chi_square_test(prng_func, sample_size, bins)
local observed = {}
for i = 1, bins do observed[i] = 0 end

for _ = 1, sample_size do
local value = prng_func()
local bin = math.floor(value bins) + 1
observed[bin] = observed[bin] + 1
end

local expected = sample_size / bins
local chi_square = 0
for i = 1, bins do
chi_square = chi_square + ((observed[i] - expected) ^ 2) / expected
end

local degrees_of_freedom = bins - 1
local critical_value = 16.92 -- For 95% confidence (df=10, approximate)
return {
chi_square = chi_square,
p_value = 1 - math.exp(-0.5 chi_square), -- Approximation
passes = chi_square < critical_value,
details = {
observed = observed,
expected = expected,
bins = bins
}
}
end

-- Example usage with a custom PRNG:
local function custom_prng()
-- Replace with your PRNG logic (e.g., LCG)
return math.random() -- Placeholder
end

local result = chi_square_test(custom_prng, 10000, 10)
msg.post("#console", "vsc.log", {
message = string.format(
"Chi-Square Test Results:\n" ..
" Chi-Square: %.2f\n" ..
" P-Value: %.4f\n" ..
" Passes Uniformity: %s\n" ..
" Observed Frequencies: %s",
result.chi_square,
result.p_value,
result.passes and "Yes" or "No",
table.concat(result.details.observed, ", ")
)
})

Interpretation of results:

Chi-Square Statistic: Lower values indicate better uniformity. A result exceeding the critical value suggests bias.

P-Value: Values > 0.05 typically indicate acceptance of the null hypothesis (uniformity).

Output Format: The script returns a numbered list of test metrics for direct console review.

Reproducing Randomness-Related Bugs with Seed Control and Deterministic Testing

RNG bugs often manifest as inconsistent spawns, glitched AI paths, or non-deterministic behavior across platforms. Defold’s `math.randomseed` enables deterministic testing by fixing the initial seed, ensuring reproducible sequences.

Step-by-Step Procedure for Bug Reproduction:
1. Isolate the Seed: Use a known seed (e.g., `math.randomseed(42)`) to generate a sequence tied to a specific game state.
2. Log Critical Values: Record outputs for events like enemy spawns, loot drops, or procedural map generation.
3. Compare Across Sessions: Run the game with the same seed on different Defold versions or platforms to identify discrepancies.
4. Reproduce with Edge Cases: Test seeds that trigger known issues (e.g., `seed = 0` or `seed = 2^32 - 1` for LCG edge cases).

Example: Debugging Inconsistent Spawns

local function debug_spawn_sequence(seed, num_spawns)
math.randomseed(seed)
local spawn_positions = {}
for i = 1, num_spawns do
local x = math.random() 1000 -- Scale to game world
local y = math.random() 1000
spawn_positions[i] = {x = x, y = y}
msg.post("#console", "vsc.log", { message = string.format("Spawn %d: (%.1f, %.1f)", i, x, y) })
end
return spawn_positions
end

-- Reproduce a bug by comparing two identical seeds:
local positions1 = debug_spawn_sequence(12345, 5)
local positions2 = debug_spawn_sequence(12345, 5)
for i, pos in ipairs(positions1) do
if math.abs(pos.x - positions2[i].x) > 0.1 or math.abs(pos.y - positions2[i].y) > 0.1 then
msg.post("#console", "vsc.error", { message = string.format("Non-deterministic spawn at index %d!", i) })
end
end

Common Bug Patterns to Investigate:

Seed Collisions: Multiple seeds producing identical sequences (e.g., `math.randomseed(-1)` and `math.randomseed(2^31 - 1)` may yield the same output in some PRNGs).

Periodicity Issues: Short sequences repeating before exhaustion (e.g., LCG with poor modulus selection).

Platform-Specific Drift: Floating-point precision differences between Defold’s LuaJIT and other engines.

Defold Test Suite Template for RNG Unit Testing

Automated unit tests for RNGs in Defold should verify:
1. Uniformity (values are evenly distributed).
2. Independence (no correlation between consecutive values).
3. Determinism (same seed produces identical sequences).
4. Edge Cases (minimum/maximum values, overflow handling).

Below is a template for a Defold test suite using the `defold-test` framework (or custom assertions):

-- RNG_TestSuite.lua
local RNG_TestSuite = {}
RNG_TestSuite.__index = RNG_TestSuite

function RNG_TestSuite.new(prng_func)
local self = setmetatable({}, RNG_TestSuite)
self.prng = prng_func
return self
end

function RNG_TestSuite:test_uniformity(sample_size, bins)
local result = chi_square_test(self.prng, sample_size, bins)
assert(result.passes, string.format("Uniformity test failed: Chi-Square=%.2f", result.chi_square))
end

function RNG_TestSuite:test_independence(sample_size)
local prev = self.prng()
for i = 2, sample_size do
local current = self.prng()
-- Simple correlation check (replace with Pearson/Spearman for rigor)
local diff = math.abs(current - prev)
assert(diff > 0.001, string.format("Dependence detected at sample %d (diff=%.4f)", i, diff))
prev

Advanced Techniques: Seeding and Synchronization in Defold Random Number Generation

Random number generation (RNG) in multiplayer or persistent procedural systems requires synchronization to ensure consistency across clients or sessions. Defold’s built-in `math.randomseed()` and `math.random()` functions rely on system entropy, which is unsuitable for deterministic replication. Advanced techniques involve shared seeding strategies, deterministic algorithms, and saveable RNG states to maintain reproducibility. This section explores synchronization methods, saveable randomness, and comparative seeding strategies, along with a Lua implementation for reproducible sequences.

Synchronizing Randomness Across Multiple Defold Clients

Multiplayer games demand identical RNG outcomes across clients to prevent desynchronization. Shared seeds or deterministic algorithms achieve this by deriving the same sequence from a known input. In Defold, synchronization can be implemented via:

Networked Seed Propagation: A seed value (e.g., a string or integer) is broadcast to all clients at game start or critical events (e.g., level load). Clients initialize their RNG with this seed, ensuring identical sequences.

Deterministic Algorithms: Replace `math.random()` with a custom PRNG (e.g., PCG or Xorshift) seeded with shared data (e.g., player IDs or game ticks). These algorithms guarantee reproducibility given the same seed.

Delta Synchronization: For dynamic systems, clients exchange RNG state updates (e.g., current seed + counter) to align sequences after deviations (e.g., due to lag).

Example: Networked Seed Synchronization in Lua

-- Server-side: Generate and broadcast a seed (e.g., UUID or timestamp)
local seed = os.time() .. math.random(1000)
go.send_message_to_all("sync_rng", { seed = seed })

-- Client-side: Initialize RNG with received seed
function init_rng(seed)
math.randomseed(seed)
-- Example: Generate a reproducible value (0-1)
return math.random(), math.random()
end

Key Considerations:

Latency: Network delays may require buffering or rollback mechanisms.

Security: Avoid predictable seeds (e.g., time-only) in competitive games to prevent exploitation.

Performance: Custom PRNGs offer better control but require implementation effort.

Implementing Saveable Randomness for Procedural Generation

Procedural content (e.g., dungeons, loot tables) must persist across game sessions. Saveable randomness combines:
1. Base Seed: A fixed value (e.g., game version or player ID) to ensure consistency.
2. Session-Specific Offset: Player actions or progress (e.g., seed incremented per save file).
3. State Storage: Save the RNG’s internal state (e.g., counter value for custom PRNGs) alongside game data.

Lua Implementation for Saveable RNG

-- Custom PRNG (Xorshift32) with saveable state
local rng_state = { value = 0 }

function saveable_rng(seed, offset)
rng_state.value = seed + (offset or 0)
-- Xorshift32 algorithm
rng_state.value = rng_state.value ~ (rng_state.value << 13)
rng_state.value = rng_state.value ~ ((rng_state.value >> 17) 805306457)
rng_state.value = rng_state.value ~ (rng_state.value << 1)
return rng_state.value
end

-- Save state to disk (e.g., using Defold’s savegame API)
function save_rng_state()
return rng_state.value
end

-- Load state from disk
function load_rng_state(saved_value)
rng_state.value = saved_value
end

Use Case: Procedural Dungeon Generation

-- Generate a room layout with saveable randomness
local player_id = "player_123"
local save_offset = game.save_offset or 0
local room_seed = hash_string(player_id) + save_offset

math.randomseed(room_seed)
local room_layout = {
doors = { math.random(1, 4), math.random(1, 4) },
enemies = math.random(3, 7)
}
game.save_offset = save_offset + 1 -- Increment for next save

Comparison of Seeding Strategies for Defold Games

Seeding strategies vary in suitability for single-player vs. multiplayer contexts. Below is a comparative analysis of three common approaches:

Time-Based Seeding

Mechanism: Uses `os.time()` or system clock as seed.

Single-Player Suitability: High (ensures varied outcomes per session).

Multiplayer Suitability: Low (non-deterministic; seeds differ across clients).

Example Use Case: Single-player roguelikes with replayability.

Risk: Predictable if combined with other fixed values (e.g., `math.random()`).

UUID-Based Seeding

Mechanism: Generates a unique identifier (e.g., `uuid.generate()`) as seed.

Single-Player Suitability: Medium (requires UUID generation per session).

Multiplayer Suitability: High (deterministic if shared; e.g., via network).

Example Use Case: Multiplayer games with synchronized procedural events.

Risk: UUID generation may introduce overhead; requires network sync.

Manual Seeding

Mechanism: Developer-defined seed (e.g., hardcoded string or player input).

Single-Player Suitability: Medium (useful for debugging/cheats).

Multiplayer Suitability: High (fully reproducible if shared).

Example Use Case: Cheat codes or deterministic testing environments.

Risk: Hardcoded seeds reduce replayability; manual input may be cumbersome.

Strategy	Deterministic	Replayability	Multiplayer Sync	Complexity
Time-Based	No	High	No	Low
UUID-Based	Yes (if shared)	Medium	Yes	High
Manual	Yes	Low	Yes	Low

Reproducible Random Sequences from String Seeds

String-based seeding converts arbitrary input (e.g., player names, cheat codes) into a deterministic RNG sequence. This is useful for debugging, cheats, or content creation tools. The approach involves:
1. Hashing the String: Convert the string to a numerical seed using a hash function (e.g., FNV-1a).
2. Seeding the PRNG: Initialize the RNG with the hashed value.
3. Generating Sequences: Produce reproducible outputs for the given string.

Lua Implementation: String-to-Seed PRNG

-- FNV-1a hash function for strings
local function fnv1a_hash(str)
local hash = 2166136261
for i = 1, #str do
hash = hash ~ (string.byte(str, i) 16777619)
end
return hash
end

-- Reproducible RNG from string seed
local function string_seed_rng(seed_str)
local seed = fnv1a_hash(seed_str)
math.randomseed(seed)
return {
next = function() return math.random() end,
int = function(min, max) return math.random(min, max) end
}
end

-- Example: Cheat code for "DEBUG_MODE"
local debug_rng = string_seed_rng("DEBUG_MODE")
print("Reproducible value:", debug_rng:int(1, 100)) -- Always outputs 42 for "DEBUG_MODE"

In-Game Application: Debugging Tools

-- Spawn enemies in a predictable pattern for testing
local test_seed = "TEST_SEED_42"
local test_rng = string_seed_rng(test_seed)

for i = 1, 10 do
local x = test_rng:int(0, 1000)
local y = test_rng:int(0, 1000)
go.add_child(go.get_scene_service():get_scene("enemy"), "enemy_" .. i, x, y)
end

Advantages:

Debugging: Reproduces bugs or edge cases

Effective random number generation in Defold is not merely about producing unpredictable values—it is about balancing unpredictability with control, ensuring fairness, and maintaining reproducibility for debugging and multiplayer synchronization. From leveraging Defold’s native `random()` function to designing custom PRNGs for specialized use cases, the techniques outlined here empower developers to craft dynamic, engaging, and reliable game mechanics. By mastering seeding strategies, statistical validation, and practical applications, creators can transform randomness from a technical challenge into a powerful tool for enhancing player experiences and streamlining development workflows.

• defold engine
• game development
• lua scripting
• procedural generation
• random number algorithms

Leave a Comment

Name

Comment

Post Comment

Comments are moderated before appearing. The data you submit is processed according to the Privacy Policy of ir.msu.ac.zw.