diff --git a/browser/lib/plunder/templates.ts b/browser/lib/plunder/templates.ts
index 66a5a590..56fbc6c6 100644
--- a/browser/lib/plunder/templates.ts
+++ b/browser/lib/plunder/templates.ts
@@ -3,6 +3,7 @@ import { ipcRenderer } from 'electron';
 import { isKeyOf, assertInteger, isInteger } from '$global/guards';
 import { useUnitsStore } from '$renderer/stores/units';
 import { assertFarmUnit } from '$global/guards';
+import { Kronos } from '$global/constants';
 import { PlunderError } from '$browser/error';
 import { ipcInvoke } from '$renderer/ipc';
 import type { usePlunderConfigStore } from '$renderer/stores/plunder';
@@ -152,6 +153,15 @@ function parseUnitAmount(row: 'a' | 'b', fields: Element[]) {
     };
 };
 
+/**
+ * Calcula a razão entre a quantidade de recursos na aldeia-alvo e a capacidade de carga do modelo.
+ * @param resources Recursos na aldeia-alvo.
+ * @param template Modelo atacante.
+ */
+function calcResourceRatio(resources: number, template: PlunderTemplate) {
+    return resources / template.carry.value;
+};
+
 /**
  * Filtra todos os modelos de saque disponíveis de acordo com a quantidade de recursos na aldeia-alvo.
  * Caso a função retorne uma lista vazia, o ataque não deve ser enviado.
@@ -200,12 +210,12 @@ async function filterTemplates(info: PlunderTargetInfo, config: ReturnType<typeo
     // Isso impede que sejam enviadas tropas em excesso para a aldeia-alvo.
     // Quanto menor for a razão, maior a quantidade de tropas sendo enviada desnecessariamente.
     // Não é necessário filtrar os modelos com capacidade de carga menor que a quantidade de recursos, pois eles sempre são válidos.
-    bigger = bigger.filter((template) => resources / template.carry.value >= config.resourceRatio);
+    bigger = bigger.filter((template) => calcResourceRatio(resources, template) >= config.resourceRatio);
     return [...smaller, ...bigger];
 };
 
 export async function pickBestTemplate(info: PlunderTargetInfo, config: ReturnType<typeof usePlunderConfigStore>) {
-    if (config.useC) {
+    if (config.useC && config.useCPattern !== 'excess') {
         const templateC = await getTemplateC(info, config);
         if (templateC) return templateC;
 
@@ -221,13 +231,24 @@ export async function pickBestTemplate(info: PlunderTargetInfo, config: ReturnTy
         config.blindAttack &&
         config.blindAttackPattern === 'smaller'
     ) {
-        // Se a opção `blindAttack` estiver ativada e o padrão de seleção for `smaller`,
-        // seleciona o modelo com menor capacidade de carga.
+        // Se não houver informações sobre os recursos, a opção `blindAttack` estiver ativada
+        // e o padrão de seleção for `smaller`, seleciona o modelo com menor capacidade de carga.
         return templates.reduce((prev, curr) => prev.carry < curr.carry ? prev : curr);
     };
 
     // Do contrário, apenas seleciona o modelo com maior capacidade de carga.
-    return templates.reduce((prev, curr) => prev.carry > curr.carry ? prev : curr);
+    const best = templates.reduce((prev, curr) => prev.carry > curr.carry ? prev : curr);
+
+    if (
+        config.useC &&
+        config.useCPattern === 'excess' &&
+        calcResourceRatio(info.res.total, best) > config.useCWhenResourceRatioIsBiggerThan
+    ) {
+        const templateC = await getTemplateC(info, config);
+        if (templateC) return templateC;
+    };
+
+    return best;
 };
 
 async function getTemplateC(info: PlunderTargetInfo, config: ReturnType<typeof usePlunderConfigStore>) {
@@ -236,6 +257,7 @@ async function getTemplateC(info: PlunderTargetInfo, config: ReturnType<typeof u
         if (!button) return null;
 
         if (info.distance > config.maxDistanceC) return null;
+        if ((Date.now() - info.lastAttack) > config.ignoreOlderThanC * Kronos.Hour) return null;
 
         const json = button.getAttributeStrict('data-units-forecast');
         const cUnits = JSON.parse(json) as UnitAmount;
diff --git a/electron/database/plunder.ts b/electron/database/plunder.ts
index d6584974..7d02e672 100644
--- a/electron/database/plunder.ts
+++ b/electron/database/plunder.ts
@@ -31,25 +31,33 @@ export class PlunderConfig extends Model<InferAttributes<PlunderConfig>, InferCr
     declare readonly ignoreDelay: boolean;
     declare readonly blindAttack: boolean;
 
-    // Configurações
-    declare readonly wallLevelToIgnore: WallLevel;
-    declare readonly wallLevelToDestroy: WallLevel;
-    declare readonly destroyWallMaxDistance: number;
-    declare readonly attackDelay: number;
-    declare readonly resourceRatio: number;
-    declare readonly minutesUntilReload: number;
+    // Ataque
     declare readonly maxDistance: number;
     declare readonly ignoreOlderThan: number;
-    declare readonly plunderedResourcesRatio: number;
-    declare readonly pageDelay: number;
-    declare readonly villageDelay: number;
+    declare readonly attackDelay: number;
+    declare readonly resourceRatio: number;
+    declare readonly blindAttackPattern: BlindAttackPattern;
+
+    // Modelo C
+    declare readonly useCPattern: UseCPattern;
     declare readonly maxDistanceC: number;
+    declare readonly ignoreOlderThanC: number;
+    declare readonly useCWhenResourceRatioIsBiggerThan: number;
 
+    // Grupo
     declare readonly plunderGroupId: number | null;
     declare readonly fieldsPerWave: number;
+    declare readonly villageDelay: number;
 
-    declare readonly blindAttackPattern: BlindAttackPattern;
-    declare readonly useCPattern: UseCPattern;
+    // Muralha
+    declare readonly wallLevelToIgnore: WallLevel;
+    declare readonly wallLevelToDestroy: WallLevel;
+    declare readonly destroyWallMaxDistance: number;
+    
+    // Outros
+    declare readonly minutesUntilReload: number;
+    declare readonly plunderedResourcesRatio: number;
+    declare readonly pageDelay: number;
 };
 
 PlunderConfig.init({
@@ -65,6 +73,7 @@ PlunderConfig.init({
         }
     },
 
+    // Painel
     active: {
         type: DataTypes.BOOLEAN,
         allowNull: false,
@@ -101,34 +110,22 @@ PlunderConfig.init({
         defaultValue: false
     },
 
-    wallLevelToIgnore: {
-        type: DataTypes.INTEGER,
+    // Ataque
+    maxDistance: {
+        type: DataTypes.FLOAT,
         allowNull: false,
-        defaultValue: 1,
+        defaultValue: 20,
         validate: {
-            isWallLevel(value: unknown) {
-                assertWallLevel(value, DatabaseError);
-            }
+            min: 1,
+            isFloat: true
         }
     },
-    
-    wallLevelToDestroy: {
+    ignoreOlderThan: {
         type: DataTypes.INTEGER,
         allowNull: false,
-        defaultValue: 1,
-        validate: {
-            isWallLevel(value: unknown) {
-                assertWallLevel(value, DatabaseError);
-            }
-        }
-    },
-    destroyWallMaxDistance: {
-        type: DataTypes.FLOAT,
-        allowNull: false,
-        defaultValue: 20,
+        defaultValue: 10,
         validate: {
-            min: 1,
-            isFloat: true
+            isInt: true
         }
     },
     attackDelay: {
@@ -151,51 +148,63 @@ PlunderConfig.init({
             isFloat: true
         }
     },
-    minutesUntilReload: {
-        type: DataTypes.INTEGER,
+    blindAttackPattern: {
+        type: DataTypes.STRING,
         allowNull: false,
-        defaultValue: 10,
+        defaultValue: 'smaller' satisfies BlindAttackPattern,
         validate: {
-            min: 1,
-            max: 60,
-            isInt: true
+            isIn: [['smaller', 'bigger'] satisfies BlindAttackPattern[]]
         }
     },
-    maxDistance: {
+
+    // Modelo C
+    useCPattern: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        defaultValue: 'normal' satisfies UseCPattern,
+        validate: {
+            isIn: [['excess', 'normal', 'only'] satisfies UseCPattern[]]
+        }
+    },
+    maxDistanceC: {
         type: DataTypes.FLOAT,
         allowNull: false,
-        defaultValue: 20,
+        defaultValue: 10,
         validate: {
             min: 1,
             isFloat: true
         }
     },
-    ignoreOlderThan: {
+    ignoreOlderThanC: {
         type: DataTypes.INTEGER,
         allowNull: false,
-        defaultValue: 10,
+        defaultValue: 5,
         validate: {
             isInt: true
         }
     },
-    plunderedResourcesRatio: {
+    useCWhenResourceRatioIsBiggerThan: {
         type: DataTypes.FLOAT,
         allowNull: false,
-        defaultValue: 1,
+        defaultValue: 3,
         validate: {
-            min: 0.2,
-            max: 1,
+            min: 1,
             isFloat: true
         }
     },
-    pageDelay: {
+
+    // Grupo
+    plunderGroupId: {
         type: DataTypes.INTEGER,
+        allowNull: true
+    },
+    fieldsPerWave: {
+        type: DataTypes.FLOAT,
         allowNull: false,
-        defaultValue: 2000,
+        defaultValue: 10,
         validate: {
-            min: 100,
-            max: 60000,
-            isInt: true
+            min: 5,
+            isFloat: true
         }
     },
     villageDelay: {
@@ -208,7 +217,30 @@ PlunderConfig.init({
             isInt: true
         }
     },
-    maxDistanceC: {
+
+    // Muralha
+    wallLevelToIgnore: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 1,
+        validate: {
+            isWallLevel(value: unknown) {
+                assertWallLevel(value, DatabaseError);
+            }
+        }
+    },
+    
+    wallLevelToDestroy: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 1,
+        validate: {
+            isWallLevel(value: unknown) {
+                assertWallLevel(value, DatabaseError);
+            }
+        }
+    },
+    destroyWallMaxDistance: {
         type: DataTypes.FLOAT,
         allowNull: false,
         defaultValue: 20,
@@ -218,36 +250,37 @@ PlunderConfig.init({
         }
     },
 
-    plunderGroupId: {
+    // Outros
+    minutesUntilReload: {
         type: DataTypes.INTEGER,
-        allowNull: true
-    },
-    fieldsPerWave: {
-        type: DataTypes.FLOAT,
         allowNull: false,
         defaultValue: 10,
         validate: {
-            min: 5,
-            isFloat: true
+            min: 1,
+            max: 60,
+            isInt: true
         }
     },
-
-    blindAttackPattern: {
-        type: DataTypes.STRING,
+    plunderedResourcesRatio: {
+        type: DataTypes.FLOAT,
         allowNull: false,
-        defaultValue: 'smaller' satisfies BlindAttackPattern,
+        defaultValue: 1,
         validate: {
-            isIn: [['smaller', 'bigger'] satisfies BlindAttackPattern[]]
+            min: 0.2,
+            max: 1,
+            isFloat: true
         }
     },
-    useCPattern: {
-        type: DataTypes.STRING,
+    pageDelay: {
+        type: DataTypes.INTEGER,
         allowNull: false,
-        defaultValue: 'normal' satisfies UseCPattern,
+        defaultValue: 2000,
         validate: {
-            isIn: [['normal', 'only'] satisfies UseCPattern[]]
+            min: 100,
+            max: 60000,
+            isInt: true
         }
-    }
+    }  
 }, { sequelize, tableName: 'plunder_config', timestamps: true });
 
 export class PlunderHistory extends Model<InferAttributes<PlunderHistory>, InferCreationAttributes<PlunderHistory>> implements PlunderHistoryType {
diff --git a/electron/stores/plunder.ts b/electron/stores/plunder.ts
index 87e9ed6b..6d5952aa 100644
--- a/electron/stores/plunder.ts
+++ b/electron/stores/plunder.ts
@@ -1,4 +1,5 @@
 import { ref } from 'mechanus';
+import { Kronos } from '$global/constants';
 import { isInteger, isFiniteNumber } from '$global/guards';
 import type { WallLevel } from '$types/game';
 import type { Mechanus, MechanusRefOptions } from 'mechanus';
@@ -40,43 +41,29 @@ export function definePlunderStore(mechanus: Mechanus) {
 
 // Patterns.
 const blindAttackPatterns: BlindAttackPattern[] = ['smaller', 'bigger'];
-const useCPatterns: UseCPattern[] = ['normal', 'only'];
+const useCPatterns: UseCPattern[] = ['excess', 'normal', 'only'];
 
 export function definePlunderConfigStore(mechanus: Mechanus) {
-    const delayValidator = (): MechanusRefOptions<number> => {
-        const refOptions = { ...positiveIntegerRef };
-        refOptions.validator = (value: unknown): value is number => {
-            return isInteger(value) && value >= 100 && value <= 60000;
-        };
-        return refOptions;
-    };
-
-    const ratioValidator = (): MechanusRefOptions<number> => {
+    const finiteValidator = (min: number, max: number | null = null): MechanusRefOptions<number> => {
         const refOptions = { ...positiveNumberRef };
         refOptions.validator = (value: unknown): value is number => {
-            return isFiniteNumber(value) && value >= 0.2 && value <= 1;
+            if (max) return isFiniteNumber(value) && value >= min && value <= max;
+            return isFiniteNumber(value) && value >= min;
         };
         return refOptions;
     };
 
-    const minutesUntilReloadValidator = (): MechanusRefOptions<number> => {
+    const integerValidator = (min: number, max: number | null = null): MechanusRefOptions<number> => {
         const refOptions = { ...positiveIntegerRef };
         refOptions.validator = (value: unknown): value is number => {
-            return isInteger(value) && value >= 1 && value <= 60;
-        };
-        return refOptions;
-    };
-
-    const maxDistanceValidator = (min: number = 1): MechanusRefOptions<number> => {
-        const refOptions = { ...positiveNumberRef };
-        refOptions.validator = (value: unknown): value is number => {
-            return isFiniteNumber(value) && value >= min;
+            if (max) return isInteger(value) && value >= min && value <= max;
+            return isInteger(value) && value >= min;
         };
         return refOptions;
     };
 
+    // Painel
     const active = ref<boolean>(false, booleanRef);
-
     const ignoreWall = ref<boolean>(false, booleanRef);
     const destroyWall = ref<boolean>(false, booleanRef);
     const groupAttack = ref<boolean>(false, booleanRef);
@@ -84,24 +71,33 @@ export function definePlunderConfigStore(mechanus: Mechanus) {
     const ignoreDelay = ref<boolean>(false, booleanRef);
     const blindAttack = ref<boolean>(false, booleanRef);
 
-    const wallLevelToIgnore = ref<WallLevel>(1, wallLevelRef);
-    const wallLevelToDestroy = ref<WallLevel>(1, wallLevelRef);
-    const destroyWallMaxDistance = ref<number>(20, maxDistanceValidator());
-    const attackDelay = ref<number>(200, delayValidator());
-    const resourceRatio = ref<number>(0.8, ratioValidator());
-    const minutesUntilReload = ref<number>(10, minutesUntilReloadValidator());
-    const maxDistance = ref<number>(20, maxDistanceValidator());
+    // Ataque
+    const maxDistance = ref<number>(20, finiteValidator(1));
     const ignoreOlderThan = ref<number>(10, positiveIntegerRef);
-    const plunderedResourcesRatio = ref<number>(1, ratioValidator());
-    const pageDelay = ref<number>(2000, delayValidator());
-    const villageDelay = ref<number>(2000, delayValidator());
-    const maxDistanceC = ref<number>(20, maxDistanceValidator());
+    const attackDelay = ref<number>(200, integerValidator(100, Kronos.Minute));
+    const resourceRatio = ref<number>(0.8, finiteValidator(0.2, 1));
+    const blindAttackPattern = ref<BlindAttackPattern>('smaller', arrayIncludesRef(blindAttackPatterns));
+
+    // Modelo C
+    const useCPattern = ref<UseCPattern>('normal', arrayIncludesRef(useCPatterns));
+    const maxDistanceC = ref<number>(10, finiteValidator(1));
+    const ignoreOlderThanC = ref<number>(5, positiveIntegerRef);
+    const useCWhenResourceRatioIsBiggerThan = ref<number>(3, finiteValidator(1));
 
+    // Grupo
     const plunderGroupId = ref<number | null>(null, positiveIntegerOrNullRef);
-    const fieldsPerWave = ref<number>(10, maxDistanceValidator(5));
+    const fieldsPerWave = ref<number>(10, finiteValidator(5));
+    const villageDelay = ref<number>(2000, integerValidator(100, Kronos.Minute));
 
-    const blindAttackPattern = ref<BlindAttackPattern>('smaller', arrayIncludesRef(blindAttackPatterns));
-    const useCPattern = ref<UseCPattern>('normal', arrayIncludesRef(useCPatterns));
+    // Muralha
+    const wallLevelToIgnore = ref<WallLevel>(1, wallLevelRef);
+    const wallLevelToDestroy = ref<WallLevel>(1, wallLevelRef);
+    const destroyWallMaxDistance = ref<number>(20, finiteValidator(1));
+    
+    // Outros
+    const minutesUntilReload = ref<number>(10, integerValidator(1, 60));
+    const plunderedResourcesRatio = ref<number>(1, finiteValidator(0.2, 1));
+    const pageDelay = ref<number>(2000, integerValidator(100, Kronos.Minute));
     
     return mechanus.define('plunderConfig', {
         active,
@@ -112,24 +108,28 @@ export function definePlunderConfigStore(mechanus: Mechanus) {
         ignoreDelay,
         blindAttack,
 
-        wallLevelToIgnore,
-        wallLevelToDestroy,
-        destroyWallMaxDistance,
-        attackDelay,
-        resourceRatio,
-        minutesUntilReload,
         maxDistance,
         ignoreOlderThan,
-        plunderedResourcesRatio,
-        pageDelay,
-        villageDelay,
+        attackDelay,
+        resourceRatio,
+        blindAttackPattern,
+
+        useCPattern,
         maxDistanceC,
+        ignoreOlderThanC,
+        useCWhenResourceRatioIsBiggerThan,
 
         plunderGroupId,
         fieldsPerWave,
+        villageDelay,
 
-        blindAttackPattern,
-        useCPattern
+        wallLevelToIgnore,
+        wallLevelToDestroy,
+        destroyWallMaxDistance,
+        
+        minutesUntilReload,
+        plunderedResourcesRatio,
+        pageDelay
     } satisfies MechanusPlunderConfigStoreType);
 };
 
diff --git a/modules/components/ConfigPlunderGridAttack.vue b/modules/components/ConfigPlunderGridAttack.vue
index 535306b5..209caa33 100644
--- a/modules/components/ConfigPlunderGridAttack.vue
+++ b/modules/components/ConfigPlunderGridAttack.vue
@@ -50,7 +50,7 @@ const blindAttackOptions = [
 
             <NGridItem>
                 <LabelPopover>
-                    <template #trigger>Evitar relatórios mais antigos que</template>
+                    <template #trigger>Evitar mais antigos que</template>
                     <span>
                         Se o último ataque ocorreu a uma quantidade de horas superior a indicada, o Ares não atacará a
                         aldeia.
diff --git a/modules/components/ConfigPlunderGridTemplateC.vue b/modules/components/ConfigPlunderGridTemplateC.vue
index 2385aca2..49db9171 100644
--- a/modules/components/ConfigPlunderGridTemplateC.vue
+++ b/modules/components/ConfigPlunderGridTemplateC.vue
@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import { ref, watch } from 'vue';
 import { NDivider, NGrid, NGridItem, NSelect } from 'naive-ui';
-import { isDistance } from '$global/guards';
+import { isDistance, isFiniteNumber, isInteger } from '$global/guards';
 import InputNumber from '$renderer/components/InputNumber.vue';
 import LabelPopover from '$renderer/components/LabelPopover.vue';
 import type { PlunderConfigType, UseCPattern } from '$types/plunder';
@@ -17,12 +17,17 @@ const emit = defineEmits<{
 
 const useCPattern = ref<UseCPattern>(props.config.useCPattern);
 const maxDistanceC = ref<number>(props.config.maxDistanceC);
+const ignoreOlderThanC = ref<number>(props.config.ignoreOlderThanC);
+const useCWhenResourceRatioIsBiggerThan = ref<number>(props.config.useCWhenResourceRatioIsBiggerThan);
 
 watch(useCPattern, (v) => emit('update:config', 'useCPattern', v));
 watch(maxDistanceC, (v) => emit('update:config', 'maxDistanceC', v));
+watch(ignoreOlderThanC, (v) => emit('update:config', 'ignoreOlderThanC', v));
+watch(useCWhenResourceRatioIsBiggerThan, (v) => emit('update:config', 'useCWhenResourceRatioIsBiggerThan', v));
 
 const useCOptions = [
     { label: 'Normal', value: 'normal' },
+    { label: 'Quando em excesso', value: 'excess' },
     { label: 'Somente C', value: 'only' }
 ] satisfies NSelectPatternOption<UseCPattern>;
 </script>
@@ -55,7 +60,51 @@ const useCOptions = [
                 </LabelPopover>
             </NGridItem>
             <NGridItem>
-                <InputNumber v-model:value="maxDistanceC" :min="1" :max="9999" :step="1" :validator="(v) => isDistance(v)" />
+                <InputNumber
+                    v-model:value="maxDistanceC"
+                    :min="1"
+                    :max="9999"
+                    :step="1"
+                    :validator="(v) => isDistance(v)"
+                />
+            </NGridItem>
+
+            <NGridItem>
+                <LabelPopover>
+                    <template #trigger>Evitar mais antigos que</template>
+                    <span>
+                        O Ares não atacará usando o modelo C se o último ataque ocorreu a uma quantidade de horas superior a indicada.
+                    </span>
+                </LabelPopover>
+            </NGridItem>
+            <NGridItem>
+                <InputNumber
+                    v-model:value="ignoreOlderThanC"
+                    :min="1"
+                    :max="9999"
+                    :step="1"
+                    :validator="(v) => isInteger(v) && v >= 1"
+                />
+            </NGridItem>
+
+            <NGridItem>
+                <LabelPopover>
+                    <template #trigger>Usar C se a razão for maior que</template>
+                    <span>
+                        Uma razão de saque alta indica que a aldeia tem recursos além do que os modelos podem saquear.
+                        Através dessa opção, é possível atacar essas aldeias com recursos em excesso usando o modelo C.
+                    </span>
+                </LabelPopover>
+            </NGridItem>
+            <NGridItem>
+                <InputNumber
+                    v-model:value="useCWhenResourceRatioIsBiggerThan"
+                    :disabled="useCPattern !== 'excess'"
+                    :min="1"
+                    :max="9999"
+                    :step="1"
+                    :validator="(v) => isFiniteNumber(v) && v >= 1"
+                />
             </NGridItem>
         </NGrid>
     </div>
diff --git a/renderer/stores/plunder.ts b/renderer/stores/plunder.ts
index 34c2802c..e87a4d3d 100644
--- a/renderer/stores/plunder.ts
+++ b/renderer/stores/plunder.ts
@@ -27,25 +27,33 @@ export const usePlunderConfigStore = defineStore('plunder-config', () => {
     const ignoreDelay = ref<boolean>(false);
     const blindAttack = ref<boolean>(false);
 
-    // Configurações
-    const wallLevelToIgnore = ref<number>(1);
-    const wallLevelToDestroy = ref<number>(1);
-    const destroyWallMaxDistance = ref<number>(20);
-    const attackDelay = ref<number>(200);
-    const resourceRatio = ref<number>(0.8);
-    const minutesUntilReload = ref<number>(10);
+    // Ataque
     const maxDistance = ref<number>(20);
     const ignoreOlderThan = ref<number>(10);
-    const plunderedResourcesRatio = ref<number>(1);
-    const pageDelay = ref<number>(2000);
-    const villageDelay = ref<number>(2000);
-    const maxDistanceC = ref<number>(20);
+    const attackDelay = ref<number>(200);
+    const resourceRatio = ref<number>(0.8);
+    const blindAttackPattern = ref<BlindAttackPattern>('smaller');
+
+    // Modelo C
+    const useCPattern = ref<UseCPattern>('normal');
+    const maxDistanceC = ref<number>(10);
+    const ignoreOlderThanC = ref<number>(5);
+    const useCWhenResourceRatioIsBiggerThan = ref<number>(3);
 
+    // Grupo
     const plunderGroupId = ref<number | null>(null);
     const fieldsPerWave = ref<number>(10);
+    const villageDelay = ref<number>(2000);
 
-    const blindAttackPattern = ref<BlindAttackPattern>('smaller');
-    const useCPattern = ref<UseCPattern>('normal');
+    // Muralha
+    const wallLevelToIgnore = ref<number>(1);
+    const wallLevelToDestroy = ref<number>(1);
+    const destroyWallMaxDistance = ref<number>(20);
+    
+    // Outros
+    const minutesUntilReload = ref<number>(10);
+    const plunderedResourcesRatio = ref<number>(1);
+    const pageDelay = ref<number>(2000);
     
     function raw(): PlunderConfigType {
         return {
@@ -57,28 +65,33 @@ export const usePlunderConfigStore = defineStore('plunder-config', () => {
             ignoreDelay: ignoreDelay.value,
             blindAttack: blindAttack.value,
 
-            wallLevelToIgnore: wallLevelToIgnore.value,
-            wallLevelToDestroy: wallLevelToDestroy.value,
-            destroyWallMaxDistance: destroyWallMaxDistance.value,
-            attackDelay: attackDelay.value,
-            resourceRatio: resourceRatio.value,
-            minutesUntilReload: minutesUntilReload.value,
             maxDistance: maxDistance.value,
             ignoreOlderThan: ignoreOlderThan.value,
-            plunderedResourcesRatio: plunderedResourcesRatio.value,
-            pageDelay: pageDelay.value,
-            villageDelay: villageDelay.value,
+            attackDelay: attackDelay.value,
+            resourceRatio: resourceRatio.value,
+            blindAttackPattern: blindAttackPattern.value,
+
+            useCPattern: useCPattern.value,
             maxDistanceC: maxDistanceC.value,
+            ignoreOlderThanC: ignoreOlderThanC.value,
+            useCWhenResourceRatioIsBiggerThan: useCWhenResourceRatioIsBiggerThan.value,
 
             plunderGroupId: plunderGroupId.value,
             fieldsPerWave: fieldsPerWave.value,
+            villageDelay: villageDelay.value,
 
-            blindAttackPattern: blindAttackPattern.value,
-            useCPattern: useCPattern.value
+            wallLevelToIgnore: wallLevelToIgnore.value,
+            wallLevelToDestroy: wallLevelToDestroy.value,
+            destroyWallMaxDistance: destroyWallMaxDistance.value,
+            
+            minutesUntilReload: minutesUntilReload.value,
+            plunderedResourcesRatio: plunderedResourcesRatio.value,
+            pageDelay: pageDelay.value  
         };
     };
 
     return {
+        // Painel
         active,
         ignoreWall,
         destroyWall,
@@ -87,25 +100,35 @@ export const usePlunderConfigStore = defineStore('plunder-config', () => {
         ignoreDelay,
         blindAttack,
 
-        wallLevelToIgnore,
-        wallLevelToDestroy,
-        destroyWallMaxDistance,
-        attackDelay,
-        resourceRatio,
-        minutesUntilReload,
+        // Ataque
         maxDistance,
         ignoreOlderThan,
-        plunderedResourcesRatio,
-        pageDelay,
-        villageDelay,
+        attackDelay,
+        resourceRatio,
+        blindAttackPattern,
+
+        // Modelo C
+        useCPattern,
         maxDistanceC,
+        ignoreOlderThanC,
+        useCWhenResourceRatioIsBiggerThan,
 
+        // Grupo
         plunderGroupId,
         fieldsPerWave,
+        villageDelay,
 
-        blindAttackPattern,
-        useCPattern,
-
+        // Muralha
+        wallLevelToIgnore,
+        wallLevelToDestroy,
+        destroyWallMaxDistance,
+        
+        // Outros
+        minutesUntilReload,
+        plunderedResourcesRatio,
+        pageDelay,
+        
+        // Funções
         raw
     } satisfies PiniaPlunderConfigStoreType;
 });
diff --git a/types/plunder.ts b/types/plunder.ts
index 56e0958f..c459c5c8 100644
--- a/types/plunder.ts
+++ b/types/plunder.ts
@@ -19,20 +19,23 @@ export type PlunderInfoType = {
 /**
  * Padrão de ataque quando o Plunder não tem informações dos exploradores.
  * 
- * bigger: Ataca com a maior capacidade de carga possível.
+ * `bigger`: Ataca com a maior capacidade de carga possível.
  * 
- * smaller: Ataca com a menor capacidade de carga possível.
+ * `smaller`: Ataca com a menor capacidade de carga possível.
  */
 export type BlindAttackPattern = 'bigger' | 'smaller';
 
 /**
  * Padrão de ataque quando o Plunder está usando o modelo C.
  * 
- * normal: Tenta utilizar o modelo C, se não for possível, utiliza outro modelo.
+ * `normal`: Tenta utilizar o modelo C, se não for possível, utiliza outro.
  * 
- * only: Utiliza apenas o modelo C.
+ * `excess`: Utiliza o modelo C apenas se a razão entre a quantidade de recursos esperados e a
+ * capacidade de carga do modelo atacante for maior que o valor indicado em `useCWhenResourceRatioIsBiggerThan`.
+ * 
+ * `only`: Utiliza apenas o modelo C.
  */
-export type UseCPattern = 'normal' | 'only';
+export type UseCPattern = 'excess' | 'normal' | 'only';
 
 export type PlunderConfigType = {
     // Painel
@@ -51,23 +54,50 @@ export type PlunderConfigType = {
     /** Se ativado, o Plunder não levará em consideração as informações dos exploradores. */
     blindAttack: boolean;
 
-    // Configurações
+    // Ataque
+    /** Distância máxima para os ataques normais do Plunder. */
+    maxDistance: number;
+    /** Ignora aldeias cujo último ataque ocorreu há uma quantidade de horas superior à indicada. */
+    ignoreOlderThan: number;
+    /** Delay médio entre os ataques. */
+    attackDelay: number;
+    /** Razão entre a quantidade de recursos esperados e a capacidade de carga do modelo atacante. */
+    resourceRatio: number;
+    /** Determina o padrão de ataque quando o Plunder não tem informações dos exploradores. */
+    blindAttackPattern: BlindAttackPattern;
+
+    // Modelo C
+    /** Determina o padrão de ataque quando o Plunder está usando o modelo C. */
+    useCPattern: UseCPattern;
+    /** Distância máxima para ataques usando o modelo C. */
+    maxDistanceC: number;
+    /** Ao usar o modelo C, ignora aldeias cujo último ataque ocorreu há uma quantidade de horas superior à indicada. */
+    ignoreOlderThanC: number;
+    /**
+     * Utiliza o modelo C apenas se a razão entre a quantidade de recursos esperados e a
+     * capacidade de carga do modelo atacante for maior que o valor indicado.
+     */
+    useCWhenResourceRatioIsBiggerThan: number;
+
+    // Grupo
+    /** ID do grupo que será utilizado para atacar. */
+    plunderGroupId: number | null;
+    /** Máximo de campos por onda. */
+    fieldsPerWave: number;
+    /** Delay médio entre cada troca de aldeia. */
+    villageDelay: number;
+
+    // Muralha
     /** Nível da muralha a partir do qual ele deve ignorar. */
     wallLevelToIgnore: number;
     /** Nível da muralha a partir do qual ele deve demolir. */
     wallLevelToDestroy: number;
     /** Distância máxima para ataques de destruição de muralha. */
     destroyWallMaxDistance: number;
-    /** Delay médio entre os ataques. */
-    attackDelay: number;
-    /** Razão entre a quantidade de recursos esperados e a capacidade de carga do modelo atacante. */
-    resourceRatio: number;
+    
+    // Outros
     /** Minutos até que a página seja recarregada automaticamente. */
     minutesUntilReload: number;
-    /** Distância máxima para os ataques normais do Plunder. */
-    maxDistance: number;
-    /** Ignora aldeias cujo último ataque ocorreu há uma quantidade de horas superior à indicada. */
-    ignoreOlderThan: number;
     /**
      * Por padrão, o Plunder sempre assume que o modelo saqueou 100% de sua capacidade de carga.
      * No entanto, essa opção permite ao usuário alterar o valor padrão.
@@ -75,20 +105,6 @@ export type PlunderConfigType = {
     plunderedResourcesRatio: number;
     /** Delay médio entre cada troca de página. */
     pageDelay: number;
-    /** Delay médio entre cada troca de aldeia. */
-    villageDelay: number;
-
-    /** ID do grupo que será utilizado para atacar. */
-    plunderGroupId: number | null;
-    /** Máximo de campos por onda. */
-    fieldsPerWave: number;
-    /** Distância máxima para ataques usando o modelo C. */
-    maxDistanceC: number;
-
-    /** Determina o padrão de ataque quando o Plunder não tem informações dos exploradores. */
-    blindAttackPattern: BlindAttackPattern;
-    /** Determina o padrão de ataque quando o Plunder está usando o modelo C. */
-    useCPattern: UseCPattern;
 };
 
 export type PlunderPanelConfig = Pick<PlunderConfigType,