public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}

public class ModelScalingEnhancer {
    private float baseScale = 1.0f;
    private float hitScaleMultiplier = 1.2f;
    private float criticalHitScaleMultiplier = 1.5f;
    private float scaleDuration = 0.3f;
    private float scaleRecoveryRate = 0.02f;
    private float currentScale = baseScale;
    private boolean isScaling = false;
    private float scaleTimer = 0.0f;

    public void update(float deltaTime) {
        if (isScaling) {
            scaleTimer += deltaTime;
            if (scaleTimer >= scaleDuration) {
                isScaling = false;
                scaleTimer = 0.0f;
            } else {
                currentScale = Math.max(baseScale, currentScale - scaleRecoveryRate * deltaTime);
            }
        } else {
            currentScale = baseScale;
        }
    }

    public void onHit(boolean isCritical) {
        isScaling = true;
        scaleTimer = 0.0f;
        currentScale = baseScale * (isCritical ? criticalHitScaleMultiplier : hitScaleMultiplier);
    }

    public float getCurrentScale() {
        return currentScale;
    }

    public void setBaseScale(float scale) {
        baseScale = scale;
        currentScale = baseScale;
    }

    public void setScaleDuration(float duration) {
        scaleDuration = duration;
    }

    public void setHitScaleMultiplier(float multiplier) {
        hitScaleMultiplier = multiplier;
    }

    public void setCriticalHitScaleMultiplier(float multiplier) {
        criticalHitScaleMultiplier = multiplier;
    }
}
