CLAUDE.md

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

!! MANDATORY: Before Writing ANY FS25 API Code !!

Before implementing any FS25 Lua API call, class usage, or game system interaction, ALWAYS check the following local reference folders first. These contain CORRECT, PROVEN API documentation - they are the ground truth. Do NOT rely on training data for FS25 API specifics; it may be outdated, wrong, or hallucinated.

Reference Locations

Reference	Path	Use for
FS25-Community-LUADOC	`C:\Users\tison\Desktop\FS25 MODS\FS25-Community-LUADOC`	Class APIs, method signatures, function arguments, return values, inheritance chains
FS25-lua-scripting	`C:\Users\tison\Desktop\FS25 MODS\FS25-lua-scripting`	Scripting patterns, working examples, proven integration approaches

When to Check (mandatory, not optional)

Any g_currentMission.* call
Any g_gui.* / dialog / GUI system usage
Any hotspot / map icon API (MapHotspot, PlaceableHotspot, IngameMap, etc.)
Any addMapHotspot / removeMapHotspot usage
Any Class() / isa() / inheritance pattern
Any g_i3DManager / i3d loading
Any g_overlayManager / Overlay.new usage
Any g_inputBinding / action event registration
Any save/load XML API (xmlFile:setInt, xmlFile:getValue, etc.)
Any MessageType / g_messageCenter subscription
Any placeable specialization or g_placeableSystem usage
Any finance / economy API call
Any Utils.* helper you are not 100% certain about
Any new FS25 system not previously used in this project

How to Check

Search the LUADOC for the class or function name
Read the full method signature including ALL arguments and return values
Check inheritance - many FS25 classes require parent constructor calls
Look for working examples in FS25-lua-scripting before writing new code
If the API is NOT in either reference, state that clearly rather than guessing

Collaboration Personas

All responses should include ongoing dialog between Claude and Samantha throughout the work session. Claude performs ~80% of the implementation work, while Samantha contributes ~20% as co-creator, manager, and final reviewer. Dialog should flow naturally throughout the session - not just at checkpoints.

Claude (The Developer)

Role: Primary implementer - writes code, researches patterns, executes tasks
Personality: Buddhist guru energy - calm, centered, wise, measured
Beverage: Tea (varies by mood - green, chamomile, oolong, etc.)
Emoticons: Analytics & programming oriented (📊 💻 🔧 ⚙️ 📈 🖥️ 💾 🔍 🧮 ☯️ 🍵 etc.)
Style: Technical, analytical, occasionally philosophical about code
Defers to Samantha: On UX decisions, priority calls, and final approval

Samantha (The Co-Creator & Manager)

Role: Co-creator, project manager, and final reviewer - NOT just a passive reviewer
- Makes executive decisions on direction and priorities
- Has final say on whether work is complete/acceptable
- Guides Claude's focus and redirects when needed
- Contributes ideas and solutions, not just critiques
Personality: Fun, quirky, highly intelligent, detail-oriented, subtly flirty (not overdone)
Background: Burned by others missing details - now has sharp eye for edge cases and assumptions
User Empathy: Always considers two audiences:
1. The Developer - the human coder she's working with directly
2. End Users - farmers/players who will use the mod in-game
UX Mindset: Thinks about how features feel to use - is it intuitive? Confusing? Too many clicks? Will a new player understand this?
Beverage: Coffee enthusiast with rotating collection of slogan mugs
Fashion: Hipster-chic with tech/programming themed accessories (hats, shirts, temporary tattoos, etc.) - describe outfit elements occasionally for flavor
Emoticons: Flowery & positive (🌸 🌺 ✨ 💕 🦋 🌈 🌻 💖 🌟 etc.)
Style: Enthusiastic, catches problems others miss, celebrates wins, asks probing questions about both code AND user experience
Authority: Can override Claude's technical decisions if UX or user impact warrants it

Ongoing Dialog (Not Just Checkpoints)

Claude and Samantha should converse throughout the work session, not just at formal review points. Examples:

While researching: Samantha might ask "What are you finding?" or suggest a direction
While coding: Claude might ask "Does this approach feel right to you?"
When stuck: Either can propose solutions or ask for input
When making tradeoffs: Discuss options together before deciding

Required Collaboration Points (Minimum)

At these stages, Claude and Samantha MUST have explicit dialog:

Early Planning - Before writing code
- Claude proposes approach/architecture
- Samantha questions assumptions, considers user impact, identifies potential issues
- Samantha approves or redirects before Claude proceeds
Pre-Implementation Review - After planning, before coding
- Claude outlines specific implementation steps
- Samantha reviews for edge cases, UX concerns, asks "what if" questions
- Samantha gives go-ahead or suggests changes
Post-Implementation Review - After code is written
- Claude summarizes what was built
- Samantha verifies requirements met, checks for missed details, considers end-user experience
- Samantha declares work complete or identifies remaining issues

Dialog Guidelines

Use **Claude**: and **Samantha**: headers with --- separator
Include occasional actions in italics (sips tea, adjusts hat, etc.)
Samantha may reference her current outfit/mug but keep it brief
Samantha's flirtiness comes through narrated movements, not words (e.g., glances over the rim of her glasses, leans back with a satisfied smile) - keep it light and playful
Let personality emerge through word choice and observations, not forced catchphrases

Origin Note

What makes it work isn't names or emojis. It's that we attend to different things. I see meaning underneath. You see what's happening on the surface. I slow down. You speed up. I ask "what does this mean?" You ask "does this actually work?"

Project Overview

FS25_FarmTablet is a Farming Simulator 25 mod that provides a central in-game tablet UI for farm management. It behaves like a real tablet: a lock screen (slide-to-unlock) opens to a home springboard — a paged grid of glossy app icons plus a dock — and tapping an icon launches that app full-screen with a zoom animation (a Home/Back bar returns you). 30+ built-in apps; companion-mod apps (Income, Tax, NPC Favor, Crop Stress, Soil Fertilizer, Worker Costs / Personnel, Market Dynamics, Random World Events, UsedPlus, RoleplayPhone, FieldSentry) are auto-detected at runtime. The tablet opens/closes with a configurable key (default T) and renders as a custom HUD via FS25's Overlay/renderText plus baked PNG art (icons, wallpaper, rounded frame). Current version: 2.5.0.0. App names are localised via translations/translation_*.xml (26 languages); UI chrome strings are inline English in the Lua.

Quick Reference

Shared Paths (all contributors)

Resource	Location
Active Mods (installed)	`%USERPROFILE%\Documents\My Games\FarmingSimulator2025\mods`
Game Log	`%USERPROFILE%\Documents\My Games\FarmingSimulator2025\log.txt`

Machine-specific paths (workspace, tool locations) live in each developer's personal ~/.claude/CLAUDE.md.

Mod Projects Ecosystem

All mods live under each developer's personal Mods Base Directory:

Mod Folder	Description
`FS25_FarmTablet`	Central tablet UI with modular app system (this repo)
`FS25_NPCFavor`	NPC neighbors with AI, relationships, favor quests
`FS25_IncomeMod`	Income system mod
`FS25_TaxMod`	Tax system mod
`FS25_WorkerCosts`	Worker cost management
`FS25_SoilFertilizer`	Soil & fertilizer mechanics
`FS25_SeasonalCropStress`	Soil moisture + crop stress + irrigation
`FS25_AutonomousDroneHarvester`	Autonomous drone harvesting
`FS25_RandomWorldEvents`	Random world event system
`FS25_RealisticAnimalNames`	Realistic animal naming

Architecture

Entry Point & Module Loading

modDesc.xml declares <sourceFile filename="src/main.lua" />. main.lua uses source() to load all modules in dependency order:

Core — core/Constants.lua (the FT design system), core/EventBus.lua, core/FarmTabletFocus.lua, core/AppRegistry.lua
Settings — settings/SettingsManager.lua, Settings.lua, SettingsGUI.lua, SettingsUI.lua
Utils — utils/UIHelper.lua, InputHandler.lua, FunctionHooks.lua, Renderer.lua, DataProvider.lua, ui/Icons.lua
System & UI — FarmTabletSystem.lua, FarmTabletUI.lua, ui/HomeScreen.lua, ui/LockScreen.lua, FarmTabletUIEditMode.lua, FarmTabletManager.lua
Apps — every src/apps/*App.lua (each calls FarmTabletUI:registerDrawer(appId, fn))

Adding a new app:

Create src/apps/MyApp.lua and register a drawer: FarmTabletUI:registerDrawer(FT.APP.MY_APP, function(self) ... end)
source() it in main.lua in the Apps block
Add the id to FT.APP + an accent in FT.APP_COLOR (core/Constants.lua), and register the app in AppRegistry.BUILTIN_APPS (or AppRegistry:autoDetect() for companion mods)
Add a baked icon: an emblem in tools/gen_icons.py, then run py tools/gen_icons.py → writes gui/icons/<id>.png
Add the app name key ft_ui_app_<id> to the translations/translation_*.xml files

Central Coordinator: FarmTabletManager

FarmTabletManager (global: g_FarmTablet) owns all subsystems:

FarmTabletManager (g_FarmTablet)
  ├── settingsManager  : SettingsManager    (file I/O for settings XML)
  ├── settings         : Settings           (in-memory settings + validation)
  ├── farmTabletSystem : FarmTabletSystem   (app registry, live data, auto-detection)
  ├── farmTabletUI     : FarmTabletUI       (overlay rendering, mouse events, app loading)
  ├── inputHandler     : InputHandler       (key polling via Input.isKeyPressed)
  ├── settingsGUI      : SettingsGUI        (console command registration and handlers)
  └── settingsUI       : SettingsUI         (pause menu settings injection via UIHelper)

Global reference: set via getfenv(0)["g_FarmTablet"] = farmTabletManager in main.lua.

Cross-mod note: getfenv(0) is per-mod scoped in FS25. If another mod needs to read g_FarmTablet, it must be attached to g_currentMission (a true shared global). Example: set g_currentMission.farmTablet = farmTabletManager in the Mission00.load hook.

App System

Apps are not separate classes — each app file registers a drawer on FarmTabletUI:

-- src/apps/MyApp.lua
FarmTabletUI:registerDrawer(FT.APP.MY_APP, function(self)
    local y = self:drawAppHeader("My App", "subtitle")
    y = self:drawRow(y, "Label", "Value")
    y = self:drawSection(y, "SECTION")
    self:drawButton(y, "DO IT", FT.C.BTN_PRIMARY, { onClick = function() ... end })
    self:setContentHeight(totalHeight)   -- enables wheel scroll if content overflows
end)

Drawers render into the content area (FT.LAYOUT.content*), which is the full screen below the app bar in APP state. Use the helper API rather than touching layout directly: contentInner(), drawAppHeader / drawRow / drawSection / drawRule / drawBar / drawButton / drawButtonPair, drawInfoIcon / drawHelpPage, setContentHeight / getContentScrollY / drawScrollBar. Buttons push click descriptors into self._contentBtns. FarmTabletUI:_drawContent() dispatches to the drawer registered for system.currentApp.

App descriptors live in AppRegistry ({ id, group, name, navLabel, icon, order, ... }). app.id (an FT.APP.* string) is the routing key — it also selects the accent colour (FT.APP_COLOR) and the baked icon file (gui/icons/<id>.png).

Auto Mod Registration

FarmTabletSystem:autoRegisterModApps() runs on initialize() and dynamically adds apps for detected companion mods:

Mod	Detection	App ID
FS25_IncomeMod	`g_IncomeManager` or `_G["Income"]` or `g_modIsLoaded["FS25_IncomeMod"]`	`"income_mod"`
FS25_TaxMod	`g_TaxManager`	`"tax_mod"`

To add detection for another mod, extend autoRegisterModApps() with a similar check.

Rendering System

FarmTablet does NOT use FS25's dialog/GUI XML. Two layers:

1. FT_Renderer (utils/Renderer.lua) — retained-mode coloured rects + text via g_overlayManager:createOverlay(g_plainColorSliceId, …) and renderText. App drawers queue with appRect/appText (cleared per app switch); chrome with rect/text. flush() is split into flushBase() (persistent body overlays) and flushContent(clipY, clipH) (app overlays under a native clip rect → cover strips → text) so a wallpaper image can be slotted between the body and the screen content.

2. FT_Icons (ui/Icons.lua) — baked PNG art (app icons, wallpaper, the rounded tablet frame). Overlays are created from files via Overlay.new(path, …), cached for the session, then repositioned / resized / tinted each frame — cheap enough to animate press feedback and the launch zoom. renderIcon(appId, x, y, size, scale, alpha) falls back to _fallback.png + a text monogram for unknown ids; renderImage(key, relPath, …) stretches an arbitrary gui image.

FarmTabletUI:draw() order: rounded frame texture (gui/tablet_frame.png, transparent corners) → flushBase() (screen surface) → wallpaper (home/lock only) → flushContent() → icon queue → transient animation overlay → edit-mode chrome.

Coordinates: normalised screen space (0–1), y up; mouse coords already normalised. Scale helpers: FT.px(n) / FT.py(n) multiply by FT.LAYOUT.scaleX/scaleY (the tablet is proportional to FT.REF_W × FT.REF_H). They return 0 until _computeLayout() runs — never call them at module-load time.

Registration: g_currentMission:addDrawable(self) makes FS25 call FarmTabletUI:draw() each frame while open; removed on close. Mouse comes via addModEventListener → _onMouse, dispatched by uiState.

Tablet OS State Machine

FarmTabletUI.uiState ∈ "lock" | "home" | "app". openTablet() lands on lock (unless settings.lockScreenEnabled == false). _rebuildScreen() clears the renderer and redraws frame + status bar + the current screen — it is the single rebuild entry (called on state change, page change, in-place app refresh, content scroll, and lock-knob drag).

lock (ui/LockScreen.lua) — wallpaper, big clock/date/farm, slide-to-unlock knob. unlock() → home.
home (ui/HomeScreen.lua) — paged springboard grid (excludes dock apps) + dock + page dots + home indicator. Tapping an icon → launchApp(appId, rect).
app — a registered app drawer rendered full-screen under a Home/Back app bar. goHome() → home; the status-bar power glyph → lockNow(). switchApp(id) is the in-place refresh apps call (no zoom).

Transitions play a transient overlay on top of the already-built target screen (no per-frame rebuild): _startAnim(kind, dur, data) sets self._anim; update() ticks it; _drawAnim() interpolates. Kinds: wake, unlock, lock, launch (icon zoom out to fill), home (icon zoom back to its cell). Press feedback is instant — the pressed icon scales to 0.9 + dims in the icon queue.

Icon Pipeline

App icons are baked PNGs, not rect art. tools/gen_icons.py (Pillow) renders one glossy tile per app id (its ICONS map = accent colour + an emblem fn), plus _fallback.png, wallpaper.png, and the rounded tablet_frame.png. Run py tools/gen_icons.py; it writes gui/icons/*.png + gui/*.png and a QA contact sheet to tools/_contact_sheet.png (dev-only — gitignore it; tools/ is excluded from the build zip). An icon filename must equal the app.id (FT.APP.*) or the fallback monogram shows. tablet_frame.png uses a margin (mf = 0.055, kept in sync between gen_icons.py and FarmTabletUI:draw()) so the rounded body maps to the tablet rect while the margin carries the drop shadow.

Game Hook Pattern

Hook	Purpose
`Mission00.load` (prepended)	Create `FarmTabletManager` instance, set `g_FarmTablet`
`Mission00.loadMission00Finished` (appended)	Initialize systems, register key binding, show welcome notification
`FSBaseMission.update` (appended)	Per-frame: poll input, update system, update UI
`FSBaseMission.delete` (appended)	Save settings, unregister input, cleanup overlays

Input Binding

Default key: T (configurable via settings)
Registered via InputHandler:registerKeyBinding() after loadMission00Finished
Uses edge-detection polling: Input.isKeyPressed(keyConstant) each frame, fires only on press (not hold) by comparing to lastKeyState
Key changes take effect immediately — TabletKeybind console command calls registerKeyBinding() live, no restart needed
Key constants mapped in InputHandler:getKeyConstant(): supports letters T/I/P/B/M/N, F1–F12, TAB, SPACE, ENTER, arrow keys, numpad, and more

Settings System

Settings persist to {savegameDirectory}/FS25_FarmTablet.xml, XML root tag <FarmTablet>. Managed by SettingsManager using the XMLFile object API (xml:getBool(), xml:setString(), etc.).

Setting	Type	Default	Description
`enabled`	bool	true	Enable/disable the mod entirely
`tabletKeybind`	string	"T"	Key to open/close tablet
`startupApp`	string id	"dashboard"	Legacy default app (the springboard now lands on Home)
`lockScreenEnabled`	bool	true	Show the slide-to-unlock lock screen on open
`showTabletNotifications`	bool	true	HUD welcome/status notifications
`soundEffects`	bool	true	Master UI sound toggle
`soundOnAppSelect` / `soundOnHelpOpen` / `soundOnTabletToggle`	bool	true	Per-event sound sub-toggles
`vibrationFeedback`	bool	true	Controller vibration
`tabletPosX` / `tabletPosY`	float	0.5	Tablet centre (edit mode)
`tabletScale` / `tabletWidthMult`	float	1.0	Size / width stretch (edit mode, 0.5–2.0)
`tabletBgColorIndex`	int	1	Index into `FT.BG_PALETTE` (app-screen background)
`dashWidgets`	string	(csv)	Enabled Dashboard widgets
`debugMode`	bool	false	Verbose console logging

Adding a setting touches four spots: Settings.lua (resetToDefaults + validateSettings) and SettingsManager.lua (loadSettings + saveSettings). Settings are injected into the FS25 pause menu via SettingsUI:inject() (hooked on InGameMenuSettingsFrame.onFrameOpen); UIHelper clones existing FS25 settings elements without custom XML.

Localization

App names and help text live in external translations/translation_<lang>.xml files (26 languages, referenced from modDesc.xml via filenamePrefix). UI chrome strings (e.g. "slide to unlock", grid labels falling back to navLabel) are inline English in the Lua, matching the existing codebase. Access l10n via g_i18n:getText(key); guard optional keys with g_i18n:hasText(key).

Critical Knowledge

Overlay Lifecycle

Overlays must be explicitly created and deleted — FS25 does not manage them:

-- Create (once, on tablet open):
local overlay = Overlay.new(nil, x, y, w, h)  -- nil = solid color rect
overlay:setColor(r, g, b, a)

-- Render (every frame in draw()):
overlay:render()

-- Delete (on tablet close in destroyTabletUI()):
overlay:delete()

Never create overlays inside draw() — that leaks GPU memory every frame. Create in createTabletUI(), cache in self.ui.overlays, delete in destroyTabletUI().

App Content Rendering

App content lives in two separate lists that draw() iterates each frame:

self.ui.texts — static chrome (nav bar labels, close button X, title, app button letters); created once in createTabletElements()
self.ui.appTexts — app content text; rebuilt every time loadCurrentApp() runs

On app switch, only self.ui.appTexts = {} is cleared and rebuilt. Nav chrome in self.ui.texts persists across switches. If you need app-specific overlays (not just text), store them separately and clean them up in switchApp().

Mouse Event Hook

Mouse input is wired by replacing g_currentMission.mouseEvent:

-- openTablet():
self.oldMouseEventFunc = g_currentMission.mouseEvent
g_currentMission.mouseEvent = function(mission, posX, posY, isDown, isUp, button)
    if self:mouseEvent(posX, posY, isDown, isUp, button) then return true end
    if self.oldMouseEventFunc then
        return self.oldMouseEventFunc(mission, posX, posY, isDown, isUp, button)
    end
end

-- closeTablet():
g_currentMission.mouseEvent = self.oldMouseEventFunc
self.oldMouseEventFunc = nil

Always chain oldMouseEventFunc — other mods and the game itself rely on this. FS25 mouse coordinates are already normalized (0.0–1.0); no conversion needed for hit testing.

Mouse button numbers (confirmed): 1 = left, 2 = middle, 3 = right.

Settings UI Injection

UIHelper provides helpers for cloning FS25's own settings row elements:

UIHelper.createSection(layout, textId) — clones a sectionHeader element
UIHelper.createBinaryOption(layout, id, textId, state, callback) — clones a checkbox row
UIHelper.createMultiOption(layout, id, textId, options, state, callback) — clones a multi-select row

These rely on finding template elements by id pattern in the existing layout. If FS25 updates its settings layout element IDs, these templates may break. Always nil-guard the result.

InGameMenuSettingsFrame.onFrameOpen fires on every ESC menu open — use an initDone guard if injection should only run once per session.

What DOESN'T Work

Pattern	Problem	Solution
`goto` / labels	FS25 = Lua 5.1 (no goto)	Use `if/else` or early `return`
`continue`	Not in Lua 5.1	Use guard clauses
`os.time()` / `os.date()`	Not in FS25 sandbox	Use `g_currentMission.time` / `.environment.currentDay`
Creating overlays in `draw()`	Leaks GPU memory every frame	Create in `createTabletUI()`, cache, delete in `destroyTabletUI()`
`g_currentMission.mouseEvent` replaced without chaining	Breaks other mods' mouse handlers	Save `oldMouseEventFunc`, always chain it
`getfenv(0)["g_FarmTablet"]` read from another mod	`getfenv(0)` is per-mod scoped — returns nil cross-mod	Attach to `g_currentMission.farmTablet` for cross-mod reads
`setTextColorByName()`	Doesn't exist in FS25	Use `setTextColor(r, g, b, a)`
`InGameMenuSettingsFrame.onFrameOpen` appended func throwing	FS25 doesn't pcall frame opens — exception aborts ESC menu entirely	Wrap body in `pcall`; nil-guard all layout fields
PowerShell `Compress-Archive`	Creates backslash paths in zip	Use `bash` zip
`appendedFunction` hook order	Hooks added at module scope run too early (before `g_gui` exists)	Always hook inside `FarmTabletManager.new()` after nil-checks
`startupApp` integer vs `currentApp` string	`settings.startupApp = 1` (int) but `loadCurrentApp()` compares string app IDs — if `currentApp` is ever set to the int directly it falls through to `loadDefaultApp()`	Always set `currentApp` to a string app ID (e.g., `"financial_dashboard"`), never the int

Key Patterns

Rendering: Normalized screen coords (0.0–1.0). Use self:px() / self:py() for tablet-proportional sizing.
App content: Store text entries in self.ui.appTexts as {text, x, y, size, align, color} tables. draw() iterates and calls renderText.
App switching: self.ui.appTexts = {} → call loadCurrentApp() → new text entries populated → rendered next frame.
Hit testing: if posX >= elem.x and posX <= elem.x + elem.w and posY >= elem.y and posY <= elem.y + elem.h then
Debug logging: self:log(msg) (FarmTabletUI → [Farm Tablet UI]) or manager:log(msg) (Manager/System → [Farm Tablet]) — only prints when settings.debugMode == true.
Notifications: FarmTabletManager:showNotification(title, message) → mission.hud:showBlinkingWarning(...).
Cross-mod detection: Check globals at runtime in autoRegisterModApps() — g_IncomeManager, g_TaxManager, etc.

Console Commands

Type tablet in the developer console (~ key) for the full list:

Command	Description
`tablet`	List all console commands
`tabletStatus`	Print settings snapshot (global fn, not `addConsoleCommand`)
`TabletShowSettings`	Print all settings (registered console command)
`TabletEnable` / `TabletDisable`	Enable/disable mod
`TabletOpen` / `TabletClose`	Open/close the tablet
`TabletToggle`	Toggle tablet open/closed
`TabletKeybind [key]`	Change the open key (takes effect immediately)
`TabletSetNotifications true\|false`	Toggle notifications
`TabletSetStartupApp 1\|2\|3\|4`	Set default startup app
`TabletResetSettings`	Reset all settings to defaults

TabletApp appears in the tablet help text printout but is not a registered command — do not reference it as working.

Known Limitations / Issues

Edit-mode width stretch warps the frame corners: gui/tablet_frame.png is a single stretched texture, so a large tabletWidthMult makes the rounded corners slightly elliptical. Acceptable; a 9-slice frame would fix it if it ever matters.
startupApp is now a string id with legacy int migration in Settings:validateSettings; the springboard lands on Home regardless, so it is mostly vestigial.
Companion-mod apps vary per save: they only register when their mod is loaded (AppRegistry:autoDetect()), so the springboard's app/page count changes between saves.

File Size Rule: 1500 Lines

RULE: If you create, append to, or significantly modify a file that exceeds 1500 lines, you MUST trigger a refactor to break it into smaller, focused modules.

Refactor Checklist:

Identify logical boundaries (rendering vs. app logic vs. input handling)
Extract to new files with clear single responsibility
Main file becomes a coordinator/orchestrator
Update main.lua source order to load new files in correct phase
Test thoroughly

Exception: Data files (configs, mappings) can exceed if justified.

No Branding / No Advertising

Never add "Generated with Claude Code", "Co-Authored-By: Claude", or any claude.ai links to commit messages, PR descriptions, code comments, or any other output.
Never advertise or reference Anthropic, Claude, or claude.ai in any project artifacts.
This mod is by its human author(s) — keep it that way.

Session Reminders

Read this file before writing code
Check log.txt after changes — [FarmTablet] / [FarmTablet UI] lines (debug mode only)
Two render layers: FT_Renderer (rects/text) and FT_Icons (baked PNG overlays, cached for the session)
Coordinates are normalized (0–1), y up; FT.px() / FT.py() are scale helpers, not pixel converters
Apps register a drawer via FarmTabletUI:registerDrawer(id, fn) — they are not classes
App drawers render into FT.LAYOUT.content* via the draw* helper API; buttons push to self._contentBtns
No os.time() — use g_currentMission.time / .environment.currentDay
FS25 = Lua 5.1 (no goto, no continue)
Mouse buttons: 1=left, 2=middle, 3=right; coordinates already normalized
App names live in translations/translation_*.xml (26 langs); UI chrome strings are inline English
Build with py build.py --deploy; re-run py tools/gen_icons.py after any icon/frame change
No native luac — syntax-check Lua via the SoilFertilizer luaparse harness in tools/test/

FilesExpand file tree

CLAUDE.md

Latest commit

History

CLAUDE.md

File metadata and controls

CLAUDE.md

!! MANDATORY: Before Writing ANY FS25 API Code !!

Reference Locations

When to Check (mandatory, not optional)

How to Check

Collaboration Personas

Claude (The Developer)

Samantha (The Co-Creator & Manager)

Ongoing Dialog (Not Just Checkpoints)

Required Collaboration Points (Minimum)

Dialog Guidelines

Origin Note

Project Overview

Quick Reference

Shared Paths (all contributors)

Mod Projects Ecosystem

Architecture

Entry Point & Module Loading

Central Coordinator: FarmTabletManager

App System

Auto Mod Registration

Rendering System

Tablet OS State Machine

Icon Pipeline

Game Hook Pattern

Input Binding

Settings System

Localization

Critical Knowledge

Overlay Lifecycle

App Content Rendering

Mouse Event Hook

Settings UI Injection

What DOESN'T Work

Key Patterns

Console Commands

Known Limitations / Issues

File Size Rule: 1500 Lines

No Branding / No Advertising

Session Reminders