Skip to main content

Last Update: 2023-07-06

Relationship Between Island Adventures Case Studies

This document explains the relationship between the two Island Adventures case studies and how they complement each other to provide a comprehensive understanding of large-scale mod development for Don't Starve Together.

Overview of the Case Studies​

The Island Adventures mod is examined through two complementary case studies:

  1. Island Adventures Core - Focuses on the technical implementation and architecture
  2. Island Adventures Gameplay - Focuses on the gameplay systems and mechanics

These two documents are designed to be read together to gain a complete understanding of both the technical foundation and the gameplay design of this comprehensive mod.

Complementary Focus Areas​

Technical vs. Gameplay Perspectives​

The two case studies approach the same mod from different angles:

Island Adventures CoreIsland Adventures Gameplay
Code structure and organizationPlayer experience and game flow
Component architectureGameplay systems integration
Technical implementation detailsGame design decisions
Integration with DST's core systemsBalance considerations
Network synchronizationProgression systems

Example Comparison​

To illustrate how the two documents complement each other, consider how they each approach the ocean and sailing mechanics:

Island Adventures Core (Technical Focus):

-- From case-ia-core.md
function BoatTrawler:StartTrawling()
    self.trawling = true
    self.trawltime = 0
    self:SetTrawlDistance(0)
    self.inst:StartUpdatingComponent(self)
    self.inst:PushEvent("trawlstart")
end

-- Sea/Skyworthy (portal) implementation
local function OnActivate(inst, doer)
    if not inst:HasTag("active") then
        return false
    elseif not (doer ~= nil and doer:HasTag("player")) then
        return false, "NOTPLAYER"
    end

    local world = TheWorld
    if world == nil or world.net == nil then
        return false
    end

    local target_shard = nil
    for shard_id, _ in pairs(world.net.components.shardstate:GetConnectedShards()) do
        target_shard = shard_id
        break
    end

    if target_shard == nil then
        return false, "NOWORLD"
    end

    -- Initiate migration to other world
    TheWorld:PushEvent("ms_playerdespawnandmigrate", {
        player = doer, 
        worldid = target_shard,
        portal_id = inst.components.worldmigrator.id
    })
    
    return true
end

Island Adventures Gameplay (Gameplay Focus):

-- From case-island-adventures.md
function BoatPhysics:OnUpdate(dt)
    -- Apply wind forces
    if TheWorld.components.worldwind ~= nil then
        local wind_speed = TheWorld.components.worldwind:GetWindSpeed()
        local wind_direction = TheWorld.components.worldwind:GetWindDirection()
        
        -- Calculate wind force based on direction and sail state
        local sail_force = 0
        if self.has_sail and self.sail_raised then
            -- Calculate angle between boat and wind
            local boat_angle = self.inst.Transform:GetRotation() * DEGREES
            local angle_diff = math.abs(DiffAngle(boat_angle, wind_direction))
            
            if angle_diff < 45 * DEGREES then
                -- Wind is behind, strong push
                sail_force = wind_speed * TUNING.BOAT.WIND_FORCE * 1.5
            elseif angle_diff < 90 * DEGREES then
                -- Wind is to the side, moderate push
                sail_force = wind_speed * TUNING.BOAT.WIND_FORCE
            elseif angle_diff < 135 * DEGREES then
                -- Wind is at an angle, slight push
                sail_force = wind_speed * TUNING.BOAT.WIND_FORCE * 0.5
            else
                -- Wind is against, minimal push
                sail_force = wind_speed * TUNING.BOAT.WIND_FORCE * 0.1
            end
        end
        
        -- Apply force in boat's forward direction
        local angle = self.inst.Transform:GetRotation() * DEGREES
        local vx = math.cos(angle) * sail_force
        local vz = -math.sin(angle) * sail_force
        
        self.velocity_x = self.velocity_x + vx * dt
        self.velocity_z = self.velocity_z + vz * dt
    end

While both examples show code related to boats, the Core case study focuses on the component structure and integration with other systems, while the Gameplay case study emphasizes the physics simulation and how wind direction affects player experience.

Key Differences in Content​

Island Adventures Core​

The Core case study emphasizes:

  1. Project Structure - How files and directories are organized
  2. Custom Components - Detailed implementation of components like sailor, poisonable, etc.
  3. Network Integration - How multiplayer synchronization is handled
  4. Entity System Modifications - How the mod extends the base game's entity system
  5. World State Management - Technical details of managing world state variables

Island Adventures Gameplay​

The Gameplay case study emphasizes:

  1. Player Experience - How systems feel to the player
  2. Interconnected Systems - How weather, sailing, and other systems work together
  3. Progression Design - How players advance through the content
  4. Environmental Storytelling - How systems create emergent narrative
  5. Balance Considerations - How challenges and rewards are balanced

How to Use These Case Studies​

For Technical Learning​

If you're primarily interested in the technical aspects of mod development:

  1. Start with Island Adventures Core to understand the architecture
  2. Reference specific systems in Island Adventures Gameplay to see how they're designed from a player perspective
  3. Pay special attention to the component interactions and network synchronization in the Core study

For Gameplay Design Learning​

If you're primarily interested in gameplay design:

  1. Start with Island Adventures Gameplay to understand the player experience
  2. Reference Island Adventures Core when you need to understand how a particular feature is implemented
  3. Pay special attention to the balance considerations and interconnected systems in the Gameplay study

For Comprehensive Understanding​

For a complete understanding of large-scale mod development:

  1. Read both case studies in parallel, comparing how each feature is approached from both perspectives
  2. Consider how technical constraints influenced gameplay decisions and vice versa
  3. Study how the mod maintains the core feel of Don't Starve Together while adding substantial new content

Conclusion​

The Island Adventures case studies demonstrate the dual nature of mod development - technical implementation and gameplay design. By studying both perspectives, mod developers can gain insights into creating cohesive, well-structured, and engaging content for Don't Starve Together.

These case studies serve as complementary resources that, when used together, provide a comprehensive guide to developing large-scale mods that extend the base game in meaningful ways while maintaining compatibility and performance.

See Also​