client: transfer bugfixes + autoclaim transfers

client/apps/game-docs/docs/components/DefendingArmies.tsx

@@ -1,13 +1,13 @@
-import { DEFENSE_NAMES } from "@bibliothecadao/types";
+import { GUARD_SLOT_NAMES } from "@bibliothecadao/types";
 import { section, table } from "./styles";
 
 // Component 2: Defense Slots by Realm Level
 export const RealmDefenseSlotsTable = () => {
   const defenseSlots = [
-    { level: "Settlement", slots: 1, slotName: DEFENSE_NAMES[0] },
-    { level: "City", slots: 2, slotName: DEFENSE_NAMES[1] },
-    { level: "Kingdom", slots: 3, slotName: DEFENSE_NAMES[2] },
-    { level: "Empire", slots: 4, slotName: DEFENSE_NAMES[3] },
+    { level: "Settlement", slots: 1, slotName: GUARD_SLOT_NAMES[0] },
+    { level: "City", slots: 2, slotName: GUARD_SLOT_NAMES[1] },
+    { level: "Kingdom", slots: 3, slotName: GUARD_SLOT_NAMES[2] },
+    { level: "Empire", slots: 4, slotName: GUARD_SLOT_NAMES[3] },
   ];
 
   return (
@@ -44,10 +44,10 @@ export const RealmDefenseSlotsTable = () => {
 // Component 2b: Blitz Defense Slots by Realm Level
 export const BlitzRealmDefenseSlotsTable = () => {
   const defenseSlots = [
-    { level: "Settlement", slots: 1, slotName: DEFENSE_NAMES[0] },
-    { level: "City", slots: 2, slotName: DEFENSE_NAMES[1] },
-    { level: "Kingdom", slots: 3, slotName: DEFENSE_NAMES[2] },
-    { level: "Empire", slots: 4, slotName: DEFENSE_NAMES[3] },
+    { level: "Settlement", slots: 1, slotName: GUARD_SLOT_NAMES[0] },
+    { level: "City", slots: 2, slotName: GUARD_SLOT_NAMES[1] },
+    { level: "Kingdom", slots: 3, slotName: GUARD_SLOT_NAMES[2] },
+    { level: "Empire", slots: 4, slotName: GUARD_SLOT_NAMES[3] },
   ];
 
   return (

client/apps/game/src/hooks/store/use-automation-store.ts

@@ -1,4 +1,8 @@
-import { calculatePresetAllocations, RealmPresetId } from "@/utils/automation-presets";
+import {
+  calculatePresetAllocations,
+  calculateResourceBootstrapAllocation,
+  RealmPresetId,
+} from "@/utils/automation-presets";
 import { configManager } from "@bibliothecadao/eternum";
 import { ResourcesIds } from "@bibliothecadao/types";
 import { create } from "zustand";
@@ -382,12 +386,33 @@ export const useAutomationStore = create<ProductionAutomationState>()(
           return existing;
         }
 
-        const newConfig = createDefaultResourceSettings(
+        const baseConfig = createDefaultResourceSettings(
           resourceId,
           { autoManaged: options?.autoManaged ?? true, label: options?.label },
           options?.defaults,
         );
 
+        let newConfig = baseConfig;
+        if (realm && realm.presetId === null) {
+          const configWithResource: RealmAutomationConfig = {
+            ...realm,
+            resources: {
+              ...realm.resources,
+              [resourceId]: baseConfig,
+            },
+          };
+          const bootstrapAllocation = calculateResourceBootstrapAllocation(configWithResource, resourceId);
+          if (bootstrapAllocation && bootstrapAllocation.resourceToResource > 0) {
+            newConfig = {
+              ...baseConfig,
+              percentages: {
+                resourceToResource: bootstrapAllocation.resourceToResource,
+                laborToResource: bootstrapAllocation.laborToResource,
+              },
+            };
+          }
+        }
+
         set((state) => {
           const realmConfig = state.realms[realmId];
           if (!realmConfig) return state;
@@ -429,11 +454,20 @@ export const useAutomationStore = create<ProductionAutomationState>()(
 
           const current = realm.resources[resourceId] ?? createDefaultResourceSettings(resourceId);
           const updatedPercentages = normalizePercentages({ ...current.percentages, ...percentages }, resourceId);
+          const changed =
+            updatedPercentages.resourceToResource !== current.percentages.resourceToResource ||
+            updatedPercentages.laborToResource !== current.percentages.laborToResource;
+
+          if (!changed && realm.resources[resourceId]) {
+            return state;
+          }
+
           const nextState = {
             realms: {
               ...state.realms,
               [realmId]: {
                 ...realm,
+                presetId: realm.presetId !== null ? null : realm.presetId,
                 resources: sanitizeRealmResources(
                   {
                     ...realm.resources,

client/apps/game/src/hooks/store/use-transfer-automation-store.ts

@@ -7,11 +7,16 @@ const resolveCurrentGameId = (): string => {
   try {
     const season = configManager.getSeasonConfig();
     return `${season.startSettlingAt}-${season.startMainAt}-${season.endAt}`;
-  } catch (_error) {
+  } catch {
     return "unknown";
   }
 };
 
+export interface TransferAutomationResourceConfig {
+  resourceId: ResourcesIds;
+  amount: number;
+}
+
 export interface TransferAutomationEntry {
   id: string;
   active: boolean;
@@ -22,24 +27,16 @@ export interface TransferAutomationEntry {
   destinationEntityId: string;
   destinationName?: string;
   resourceIds: ResourcesIds[];
-  resourceConfigs?: Array<{
-    resourceId: ResourcesIds;
-    mode: "percent" | "flat";
-    percent?: number; // 5..90 when mode = percent
-    flatPercent?: number; // 1..90 when mode = flat (percent of current balance at execution time)
-    flatAmount?: number; // explicit human amount when mode = flat
-  }>;
-  amountMode?: "percent" | "flat"; // default percent for v1
-  percent: number; // 5..90 when amountMode = percent
-  flatAmount?: number; // human units per resource when amountMode = flat
+  resourceConfigs?: TransferAutomationResourceConfig[];
   intervalMinutes: number; // 5..60 (used when active)
   lastRunAt?: number;
   nextRunAt?: number | null;
 }
 
-type NewEntry = Omit<TransferAutomationEntry, "id" | "createdAt" | "lastRunAt" | "nextRunAt" | "active" | "gameId"> & {
+type NewEntry = Omit<TransferAutomationEntry, "id" | "createdAt" | "nextRunAt" | "active" | "gameId"> & {
   active?: boolean;
   gameId?: string;
+  lastRunAt?: number;
 };
 
 interface TransferAutomationState {
@@ -53,16 +50,6 @@ interface TransferAutomationState {
   pruneForGame: (gameId: string) => void;
 }
 
-const clampPercent = (value: number): number => {
-  if (!Number.isFinite(value)) return 5;
-  return Math.min(90, Math.max(5, Math.round(value)));
-};
-
-const clampInterval = (minutes: number): number => {
-  if (!Number.isFinite(minutes)) return 5;
-  return Math.min(60, Math.max(5, Math.round(minutes)));
-};
-
 const getBlockNowMs = (): number => {
   const { currentBlockTimestamp } = getBlockTimestamp();
   return currentBlockTimestamp * 1000;
@@ -71,21 +58,57 @@ const getBlockNowMs = (): number => {
 const generateId = () => {
   if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
     try {
-      return (crypto as any).randomUUID();
-    } catch (_) {}
+      return (crypto as Crypto & { randomUUID: () => string }).randomUUID();
+    } catch {
+      // ignore and fall through to timestamp-based id
+    }
   }
   return `ta_${Date.now()}_${Math.floor(Math.random() * 1e6)}`;
 };
 
+const sanitizeResourceConfigs = (raw: unknown, fallbackAmount?: number): TransferAutomationEntry["resourceConfigs"] => {
+  if (!Array.isArray(raw) || raw.length === 0) return undefined;
+  const sanitized: TransferAutomationResourceConfig[] = [];
+  raw.forEach((item) => {
+    if (!item || typeof item !== "object") return;
+    const candidate = item as { resourceId?: unknown; amount?: unknown };
+    if (typeof candidate.resourceId !== "number") return;
+    const sourceAmount =
+      typeof candidate.amount === "number" && Number.isFinite(candidate.amount) ? candidate.amount : fallbackAmount;
+    const normalizedAmount =
+      typeof sourceAmount === "number" && Number.isFinite(sourceAmount) ? Math.max(0, Math.floor(sourceAmount)) : 0;
+    sanitized.push({
+      resourceId: candidate.resourceId,
+      amount: normalizedAmount,
+    });
+  });
+  return sanitized.length > 0 ? sanitized : undefined;
+};
+
+const buildConfigsFromResources = (
+  resourceIds: ResourcesIds[],
+  fallbackAmount?: number,
+): TransferAutomationEntry["resourceConfigs"] => {
+  const fallback = Number.isFinite(fallbackAmount) ? Math.max(0, Math.floor(fallbackAmount as number)) : 0;
+  if (resourceIds.length === 0) return undefined;
+  return resourceIds.map((rid) => ({
+    resourceId: rid,
+    amount: fallback,
+  }));
+};
+
 export const useTransferAutomationStore = create<TransferAutomationState>()(
   persist(
-    (set, get) => ({
+    (set) => ({
       entries: {},
       add: (raw) => {
         const id = generateId();
         const now = getBlockNowMs();
         const active = raw.active ?? true;
         const gameId = raw.gameId ?? resolveCurrentGameId();
+        const resourceIdsArray = Array.from(new Set(raw.resourceIds || [])).filter(
+          (r) => typeof r === "number",
+        ) as ResourcesIds[];
         const entry: TransferAutomationEntry = {
           id,
           createdAt: now,
@@ -95,15 +118,12 @@ export const useTransferAutomationStore = create<TransferAutomationState>()(
           sourceName: raw.sourceName,
           destinationEntityId: String(raw.destinationEntityId),
           destinationName: raw.destinationName,
-          resourceIds: Array.from(new Set(raw.resourceIds || [])).filter(
-            (r) => typeof r === "number",
-          ) as ResourcesIds[],
-          amountMode: raw.amountMode ?? "percent",
-          percent: clampPercent(raw.percent),
-          flatAmount: typeof raw.flatAmount === "number" ? Math.max(0, Math.floor(raw.flatAmount)) : undefined,
-          intervalMinutes: clampInterval(raw.intervalMinutes),
-          lastRunAt: undefined,
-          nextRunAt: active ? now + clampInterval(raw.intervalMinutes) * 60_000 : null,
+          resourceIds: resourceIdsArray,
+          resourceConfigs:
+            sanitizeResourceConfigs(raw.resourceConfigs) ?? buildConfigsFromResources(resourceIdsArray, undefined),
+          intervalMinutes: Math.max(1, Math.round(raw.intervalMinutes ?? 1)),
+          lastRunAt: raw.lastRunAt,
+          nextRunAt: active ? now + Math.max(1, Math.round(raw.intervalMinutes ?? 1)) * 60_000 : null,
         };
         set((state) => ({ entries: { ...state.entries, [id]: entry } }));
         return id;
@@ -112,15 +132,18 @@ export const useTransferAutomationStore = create<TransferAutomationState>()(
         set((state) => {
           const prev = state.entries[id];
           if (!prev) return state;
+          const updatedInterval =
+            patch.intervalMinutes !== undefined
+              ? Math.max(1, Math.round(patch.intervalMinutes))
+              : Math.max(1, Math.round(prev.intervalMinutes || 1));
           const next: TransferAutomationEntry = {
             ...prev,
             ...patch,
-            amountMode: patch.amountMode ?? prev.amountMode ?? "percent",
-            percent: patch.percent !== undefined ? clampPercent(patch.percent) : prev.percent,
-            flatAmount:
-              patch.flatAmount !== undefined ? Math.max(0, Math.floor(patch.flatAmount as number)) : prev.flatAmount,
-            intervalMinutes:
-              patch.intervalMinutes !== undefined ? clampInterval(patch.intervalMinutes) : prev.intervalMinutes,
+            intervalMinutes: updatedInterval,
+            resourceConfigs:
+              patch.resourceConfigs !== undefined
+                ? sanitizeResourceConfigs(patch.resourceConfigs)
+                : prev.resourceConfigs,
           };
 
           return { entries: { ...state.entries, [id]: next } };
@@ -138,10 +161,11 @@ export const useTransferAutomationStore = create<TransferAutomationState>()(
           if (!prev) return state;
           const isActive = active ?? !prev.active;
           const now = getBlockNowMs();
+          const intervalMinutes = Math.max(1, Math.round(prev.intervalMinutes || 1));
           const next: TransferAutomationEntry = {
             ...prev,
             active: isActive,
-            nextRunAt: isActive ? now + clampInterval(prev.intervalMinutes) * 60_000 : null,
+            nextRunAt: isActive ? now + intervalMinutes * 60_000 : null,
           };
           return { entries: { ...state.entries, [id]: next } };
         }),
@@ -150,9 +174,10 @@ export const useTransferAutomationStore = create<TransferAutomationState>()(
           const prev = state.entries[id];
           if (!prev) return state;
           const now = base ?? getBlockNowMs();
+          const intervalMinutes = Math.max(1, Math.round(prev.intervalMinutes || 1));
           const next: TransferAutomationEntry = {
             ...prev,
-            nextRunAt: now + clampInterval(prev.intervalMinutes) * 60_000,
+            nextRunAt: now + intervalMinutes * 60_000,
           };
           return { entries: { ...state.entries, [id]: next } };
         }),
@@ -170,56 +195,45 @@ export const useTransferAutomationStore = create<TransferAutomationState>()(
       version: 3,
       storage: createJSONStorage(() => localStorage),
       partialize: (state) => ({ entries: state.entries }),
-      migrate: (persisted: any, version) => {
+      migrate: (persisted: unknown) => {
         if (!persisted || typeof persisted !== "object") return { entries: {} };
-        const rawEntries = (persisted as any).entries ?? {};
+        const rawEntries = (persisted as { entries?: unknown }).entries;
+        if (!rawEntries || typeof rawEntries !== "object") return { entries: {} };
         const entries: Record<string, TransferAutomationEntry> = {};
-        Object.entries(rawEntries).forEach(([id, value]) => {
-          const v = value as TransferAutomationEntry;
-          if (!v || typeof v !== "object") return;
-          const resourceIds = Array.isArray(v.resourceIds)
-            ? (v.resourceIds.filter((r) => typeof r === "number") as ResourcesIds[])
-            : [];
-          const percent = clampPercent((v as any).percent ?? 5);
-          const intervalMinutes = clampInterval((v as any).intervalMinutes ?? 5);
-          let resourceConfigs: TransferAutomationEntry["resourceConfigs"] | undefined;
-          if (Array.isArray((v as any).resourceConfigs)) {
-            resourceConfigs = ((v as any).resourceConfigs as any[])
-              .map((c) => ({
-                resourceId: c.resourceId,
-                mode: c.mode === "flat" ? "flat" : "percent",
-                percent: typeof c.percent === "number" ? clampPercent(c.percent) : undefined,
-                flatPercent:
-                  typeof c.flatPercent === "number" ? Math.min(90, Math.max(1, Math.floor(c.flatPercent))) : undefined,
-                flatAmount: typeof c.flatAmount === "number" ? Math.max(0, Math.floor(c.flatAmount)) : undefined,
-              }))
-              .map((c) => ({
-                resourceId: c.resourceId,
-                mode: c.mode,
-                percent: c.percent,
-                flatPercent: (c as any).flatPercent,
-                flatAmount: (c as any).flatAmount,
-              })) as any;
-          }
+        Object.entries(rawEntries as Record<string, unknown>).forEach(([id, value]) => {
+          if (!value || typeof value !== "object") return;
+          const persistedEntry = value as Record<string, unknown>;
+          const resourceIdsRaw = Array.isArray(persistedEntry.resourceIds) ? persistedEntry.resourceIds : [];
+          const resourceIds = resourceIdsRaw.filter((r): r is ResourcesIds => typeof r === "number");
+          const intervalMinutes =
+            typeof persistedEntry.intervalMinutes === "number"
+              ? Math.max(1, Math.round(persistedEntry.intervalMinutes))
+              : 5;
+          const fallbackAmount =
+            typeof persistedEntry.flatAmount === "number"
+              ? Math.max(0, Math.floor(persistedEntry.flatAmount))
+              : undefined;
+          const resourceConfigs =
+            sanitizeResourceConfigs(persistedEntry.resourceConfigs, fallbackAmount) ??
+            buildConfigsFromResources(resourceIds, fallbackAmount);
           entries[id] = {
             id,
-            createdAt: typeof v.createdAt === "number" ? v.createdAt : Date.now(),
-            active: Boolean((v as any).active),
-            gameId: typeof (v as any).gameId === "string" ? (v as any).gameId : resolveCurrentGameId(),
-            sourceEntityId: String((v as any).sourceEntityId ?? "0"),
-            sourceName: (v as any).sourceName,
-            destinationEntityId: String((v as any).destinationEntityId ?? "0"),
-            destinationName: (v as any).destinationName,
+            createdAt: typeof persistedEntry.createdAt === "number" ? persistedEntry.createdAt : Date.now(),
+            active: Boolean(persistedEntry.active),
+            gameId: typeof persistedEntry.gameId === "string" ? persistedEntry.gameId : resolveCurrentGameId(),
+            sourceEntityId: String(persistedEntry.sourceEntityId ?? "0"),
+            sourceName: typeof persistedEntry.sourceName === "string" ? persistedEntry.sourceName : undefined,
+            destinationEntityId: String(persistedEntry.destinationEntityId ?? "0"),
+            destinationName:
+              typeof persistedEntry.destinationName === "string" ? persistedEntry.destinationName : undefined,
             resourceIds,
             resourceConfigs,
-            amountMode: (v as any).amountMode ?? "percent",
-            percent,
-            flatAmount:
-              typeof (v as any).flatAmount === "number" ? Math.max(0, Math.floor((v as any).flatAmount)) : undefined,
             intervalMinutes,
-            lastRunAt: typeof (v as any).lastRunAt === "number" ? (v as any).lastRunAt : undefined,
+            lastRunAt: typeof persistedEntry.lastRunAt === "number" ? persistedEntry.lastRunAt : undefined,
             nextRunAt:
-              (v as any).nextRunAt === null || typeof (v as any).nextRunAt === "number" ? (v as any).nextRunAt : null,
+              persistedEntry.nextRunAt === null || typeof persistedEntry.nextRunAt === "number"
+                ? (persistedEntry.nextRunAt as number | null)
+                : null,
           };
         });
         return { entries };