ModLoader.cs

浏览该文件的文档.

using System.Xml.Linq;
using Engine;
using Engine.Graphics;
using GameEntitySystem;
using TemplatesDatabase;
 
namespace Game {
    public abstract class ModLoader {
        public ModEntity Entity;

        public virtual void __ModInitialize() { }

        public virtual void GetModFiles(string extension, Action<string, Stream> action, out bool skip) {
            skip = false;
        }

        public virtual void GetModFile(string filename, Action<Stream> stream, out bool skip, out bool fileFound) {
            skip = false;
            fileFound = false;
        }

        public virtual bool CompareModVersion(string currentVersion, string lastVersion) => true;

        public virtual void ModDispose() { }

        public virtual void ViewFogColor(float viewUnderWaterDepth, float viewUnderMagmaDepth, ref Color viewFogColor) { }

        public virtual void CalculateLighting(ref float brightness) { }

        public virtual void OnMinerHit(ComponentMiner miner,
            ComponentBody componentBody,
            Vector3 hitPoint,
            Vector3 hitDirection,
            ref float attackPower,
            ref float playerProbability,
            ref float creatureProbability,
            out bool hitted) {
            hitted = false;
        }

        public virtual void SetHitInterval(ComponentMiner miner, ref double hitInterval) { }

        public virtual void IsLevelSufficientForTool(ComponentMiner miner, int toolValue, ref bool canUse, out bool skip) {
            skip = false;
        }

        public virtual void OnMinerHit2(ComponentMiner componentMiner,
            ComponentBody componentBody,
            Vector3 hitPoint,
            Vector3 hitDirection,
            ref int durabilityReduction,
            ref Attackment attackment) { }

        public virtual void OnMinerDig(ComponentMiner miner, TerrainRaycastResult raycastResult, ref float digProgress, out bool digged) {
            digged = false;
        }

        public virtual void BeforeMinerPlace(ComponentMiner componentMiner,
            TerrainRaycastResult terrainRaycastResult,
            int x,
            int y,
            int z,
            BlockPlacementData placementData,
            out bool placementNotAllowed) {
            placementNotAllowed = false;
        }

        [Obsolete("该方法已过时，请使用OnMinerPlace重载")]
        public virtual void OnMinerPlace(ComponentMiner miner,
            TerrainRaycastResult raycastResult,
            int x,
            int y,
            int z,
            int value,
            out bool placed) {
            placed = false;
        }

        public virtual void OnMinerPlace(ComponentMiner miner,
            TerrainRaycastResult raycastResult,
            int x,
            int y,
            int z,
            int value,
            BlockPlacementData placementData,
            out bool placed) {
            placed = false;
        }

        public virtual bool SetRainAndSnowColor(ref Color rainColor, ref Color snowColor) => false;

        public virtual void SetFurnitureDesignColor(FurnitureDesign design, Block block, int value, ref int faceTextureSlot, ref Color color) { }

        [Obsolete("该方法已过时，请使用ProcessAttackment修改Attackment的击退和击晕属性")]
        public virtual void AttackPowerParameter(ComponentBody target,
            ComponentCreature attacker,
            Vector3 hitPoint,
            Vector3 hitDirection,
            ref float impulseFactor,
            ref float stunTimeFactor,
            ref bool recalculate) { }

        [Obsolete("使用另一个ClothingProcessSlotItems接口")]
        public virtual bool ClothingProcessSlotItems(ComponentPlayer componentPlayer, Block block, int slotIndex, int value, int count) => false;

        public virtual void ClothingSlotProcessCapacity(ComponentClothing componentClothing,
            int slotIndex,
            int blockValue,
            ref bool notToProcessVanilla,
            out int capacity) {
            capacity = 0;
        }
 
        public virtual void SetClothes(ComponentClothing componentClothing, ClothingSlot slot, IEnumerable<int> clothes) { }

        public virtual void OnEatPickable(ComponentEatPickableBehavior eatPickableBehavior, Pickable eatPickable, out bool dealed) {
            dealed = false;
        }

        public virtual bool OnPlayerSpawned(PlayerData.SpawnMode spawnMode, ComponentPlayer componentPlayer, Vector3 position) => false;

        public virtual void OnPlayerDead(PlayerData playerData) { }

        [Obsolete("该方法已弃用，请使用ProcessAttackment", true)]
        public virtual bool AttackBody(ComponentBody target,
            ComponentCreature attacker,
            Vector3 hitPoint,
            Vector3 hitDirection,
            ref float attackPower,
            bool isMeleeAttack) => false;

        public virtual void ProcessAttackment(Attackment attackment) { }

        public virtual void OnSetModel(ComponentModel componentModel, Model model, out bool isSet) {
            isSet = false;
        }
 
        [Obsolete("Use OnAnimateModel() instead")]
        public virtual void OnModelAnimate(ComponentCreatureModel componentCreatureModel, out bool skip) {
            skip = false;
        }

        public virtual void OnAnimateModel(ComponentModel componentModel, out bool skip) {
            skip = false;
        }

        public virtual void OnModelDrawExtra(ComponentModel componentModel, Camera camera, out bool skip) {
            skip = false;
        }

        public virtual void OnModelCalculateBones(ComponentModel componentModel, Camera camera, out bool skip) {
            skip = false;
        }

        public virtual void OnModelCalculateIsVisible(ComponentModel componentModel, Camera camera, out bool skip) {
            skip = false;
        }

        public virtual void RecalculateModelEyePosition(ComponentModel componentModel, ref Vector3 eyePosition) { }

        public virtual void RecalculateModelEyeRotation(ComponentModel componentModel, ref Quaternion eyeRotation) { }

        [Obsolete("护甲系统调整，该接口不再适用。对于调整护甲的结算顺序，请调用DecideArmorProtectionSequence接口；对于调整单件护甲的防御效果，请给被调整的护甲创建新的ClothingData。")]
        public virtual float ApplyArmorProtection(ComponentClothing componentClothing, float attackPower, bool appliedByOtherMods, out bool applied) {
            applied = false;
            return attackPower;
        }

        [Obsolete("You can update your factors in your mod components")]
        public virtual void OnLevelUpdate(ComponentLevel level) { }

        [Obsolete("You can update your factors in your mod components")]
        public virtual void OnFactorsUpdate(ComponentFactors componentFactors, float dt) { }

        public virtual void GuiUpdate(ComponentGui componentGui) { }

        public virtual void GuiDraw(ComponentGui componentGui, Camera camera, int drawOrder) { }

        public virtual void UpdateInput(ComponentInput componentInput, WidgetInput widgetInput) { }

        public virtual void DrawToScreen(ViewWidget viewWidget, Widget.DrawContext dc) { }

        public virtual void ClothingWidgetOpen(ComponentGui componentGui, ClothingWidget clothingWidget) { }

        public virtual void OnBlockExploded(SubsystemTerrain subsystemTerrain, int x, int y, int z, int value) { }

        public virtual void OnEntityAdd(Entity entity) { }

        public virtual void OnEntityRemove(Entity entity) { }

        public virtual void InitializeCreatureTypes(SubsystemCreatureSpawn spawn, List<SubsystemCreatureSpawn.CreatureType> creatureTypes) { }

        public virtual void SpawnEntity(SubsystemSpawn spawn, Entity entity, SpawnEntityData spawnEntityData, out bool spawned) {
            spawned = false;
        }

        public virtual void OnDespawned(Entity entity, ComponentSpawn componentSpawn) { }
 
        public virtual void CalculateExplosionPower(SubsystemExplosions subsystemExplosions, ref float explosionPower) { }

        public virtual void OnComponentBodyExploded(ComponentBody componentBody,
            ref Injury explosionInjury,
            ref Vector3 impulse,
            ref bool setOnFire,
            ref float fluctuation) { }

        public virtual void DeadBeforeDrops(ComponentHealth componentHealth, ref KillParticleSystem killParticleSystem, ref bool dropAllItems) { }

        public virtual void TerrainChangeCell(SubsystemTerrain subsystemTerrain, int x, int y, int z, int value, out bool skip) {
            skip = false;
        }

        [Obsolete("该方法已被弃用，请使用CalculateCreatureInjuryAmount, OnCreatureDying, OnCreatureDied代替", true)]
        public virtual void OnCreatureInjure(ComponentHealth componentHealth,
            float amount,
            ComponentCreature attacker,
            bool ignoreInvulnerability,
            string cause,
            out bool skip) {
            skip = false;
        }

        public virtual void CalculateCreatureInjuryAmount(Injury injury) { }

        public virtual void OnCreatureDying(ComponentHealth componentHealth, Injury injury) { }

        public virtual void OnCreatureDied(ComponentHealth componentHealth, Injury injury, ref int experienceOrbDrop, ref bool calculateInKill) { }

        public virtual void ChangeVisualEffectOnInjury(ComponentHealth componentHealth,
            float lastHealth,
            ref float redScreenFactor,
            ref bool playPainSound,
            ref int healthBarFlashCount,
            ref float creatureModelRedFactor) { }
 
        public virtual void OnCreatureSpiked(ComponentHealth componentHealth,
            SubsystemBlockBehavior spikeBlockBehavior,
            CellFace cellFace,
            float velocity,
            ref Injury blockInjury) { }

        public virtual Color ChangeSkyColor(Color oldColor, Vector3 direction, float timeOfDay, int temperature) => oldColor;

        public virtual void SetShaderParameter(Shader shader, Camera camera) { }

        public virtual void ModelShaderParameter(Shader shader,
            Camera camera,
            List<SubsystemModelsRenderer.ModelData> modelsData,
            float? alphaThreshold) { }

        public virtual void SkyDrawExtra(SubsystemSky subsystemSky, Camera camera) { }

        public virtual int GetMaxInstancesCount() => 7;

        public virtual void OnModelRendererDrawExtra(SubsystemModelsRenderer modelsRenderer,
            SubsystemModelsRenderer.ModelData modelData,
            Camera camera,
            float? alphaThreshold) { }

        public virtual void SetHitValueParticleSystem(HitValueParticleSystem hitValueParticleSystem, Attackment attackment) { }

        public virtual void OnSaveSpawnData(ComponentSpawn spawn, SpawnEntityData spawnEntityData) { }

        public virtual void OnReadSpawnData(Entity entity, SpawnEntityData spawnEntityData) { }

        public virtual void OnTerrainContentsGenerated(TerrainChunk chunk) { }

        public virtual void ToFreeChunks(TerrainUpdater terrainUpdater, TerrainChunk chunk, out bool keepWorking) {
            keepWorking = false;
        }

        // <param name="chunk"></param>
        public virtual bool ToAllocateChunks(TerrainUpdater terrainUpdater, TerrainUpdater.UpdateLocation[] locations) => false;

        [Obsolete("Use SubsystemUpdate(SubsystemUpdate subsystemUpdate, float dt)")]
        public virtual void SubsystemUpdate(float dt) { }
        public virtual void SubsystemUpdate(SubsystemUpdate subsystemUpdate, float dt) { }

        public virtual void OnProjectLoaded(Project project) { }

        public virtual void OnProjectDisposed() { }

        public virtual void BlocksInitalized() { }

        public virtual object BeforeGameLoading(PlayScreen playScreen, object item) => item;

        public virtual void OnLoadingStart(List<Action> actions) { }

        public virtual void OnLoadingFinished(List<Action> actions) { }

        public virtual void SaveSettings(XElement xElement) { }

        public virtual void LoadSettings(XElement xElement) { }

        public virtual void OnXdbLoad(XElement xElement) { }

        [Obsolete("Use ProjectXmlLoad(XElement xElement, WorldInfo worldInfo, ContainerWidget gameWidget)")]
        public virtual void ProjectXmlLoad(XElement xElement) { }
        public virtual void ProjectXmlLoad(XElement xElement, WorldInfo worldInfo, ContainerWidget gameWidget) { }

        public virtual void ProjectXmlSave(XElement xElement) { }

        public virtual void OnProjectXmlSaved(XElement xElement) { }

        public virtual void OnCraftingRecipeDecode(List<CraftingRecipe> m_recipes, XElement element, out bool decoded) {
            decoded = false;
        }

        public virtual bool MatchRecipe(string[] requiredIngredients, string[] actualIngredient, out bool matched) {
            matched = false;
            return false;
        }

        public virtual int DecodeResult(string result, out bool decoded) {
            decoded = false;
            return 0;
        }

        public virtual void DecodeIngredient(string ingredient, out string craftingId, out int? data, out bool decoded) {
            decoded = false;
            craftingId = string.Empty;
            data = null;
        }

        public virtual void OnCameraChange(ComponentPlayer m_componentPlayer, ComponentGui componentGui) { }

        public virtual void ManageCameras(GameWidget gameWidget) { }

        public virtual void OnCapture() { }

        public virtual void MenuPlayMusic(out string contentMusicPath) {
            contentMusicPath = string.Empty;
        }

        public virtual void IsTerrainSafeToGo(ComponentPilot componentPilot,
            Vector3 position,
            Vector3 direction,
            out bool isTerrainSafeToGo,
            out bool skipVanilla) {
            isTerrainSafeToGo = false;
            skipVanilla = false;
        }

        public virtual void IsPredator(ComponentFlyAwayBehavior flyAwayBehavior, Entity target, out bool isPredator, out bool skipVanilla) {
            isPredator = false;
            skipVanilla = false;
        }

        public virtual void CallNearbyCreaturesHelp(ComponentHerdBehavior herdBehavior,
            ComponentCreature target,
            float maxRange,
            float maxChaseTime,
            bool isPersistent,
            out bool skipVanilla) {
            skipVanilla = false;
        }

        public virtual void FindHerdCenter(ComponentCreature componentCreature, out Vector3? herdCenter, out bool skipVanilla) {
            herdCenter = null;
            skipVanilla = false;
        }

        public virtual void ScoreMount(ComponentRider componentRider, ComponentMount componentMount, out float? score) {
            score = null;
        }

        public virtual void OnTreasureGenerate(SubsystemTerrain subsystemTerrain,
            int x,
            int y,
            int z,
            int neighborX,
            int neighborY,
            int neighborZ,
            ref int blockValue,
            ref int count,
            out bool isGenerate) {
            isGenerate = false;
        }

        public virtual void OnWidgetConstruct(ref Widget widget) { }

        public virtual void OnWidgetContentsLoaded(Widget widget) { }

        public virtual void BeforeWidgetDrawItemRender(Widget.DrawItem drawItem,
            out bool skipVanillaDraw,
            out Action afterWidgetDraw,
            ref Rectangle scissorRectangle,
            Widget.DrawContext drawContext) {
            skipVanillaDraw = false;
            afterWidgetDraw = null;
        }

        public virtual void OnDrawItemAssigned(Widget.DrawContext drawContext) { }

        public virtual void OnModalPanelWidgetSet(ComponentGui componentGui, Widget oldWidget, Widget newWidget) { }

        public virtual void GenerateChunkVertices(TerrainChunk chunk, bool even) { }

        public virtual void GenerateChunkLightSources(DynamicArray<TerrainUpdater.LightSource> lightSources, TerrainChunk chunk) { }

        public virtual void CalculateSmoothLight(SubsystemTerrain subsystemTerrain, Vector3 p, ref float num) { }

        public virtual void WindowModeChanged(WindowMode mode) { }

        public virtual int DamageItem(Block block, int oldValue, int damageCount, Entity owner, out bool skipVanilla) {
            skipVanilla = false;
            return 0;
        }

        public virtual void OnProjectileHitTerrain(Projectile projectile,
            TerrainRaycastResult terrainRaycastResult,
            ref bool triggerBlocksBehavior,
            ref bool destroyCell,
            ref float impactSoundLoudness,
            ref bool projectileGetStuck,
            ref Vector3 velocityAfterHit,
            ref Vector3 angularVelocityAfterHit) { }

        public virtual void OnProjectileHitBody(Projectile projectile,
            BodyRaycastResult bodyRaycastResult,
            ref Attackment attackment,
            ref Vector3 velocityAfterAttack,
            ref Vector3 angularVelocityAfterAttack,
            ref bool ignoreBody) { }

        public virtual void OnProjectileDraw(Projectile projectile,
            SubsystemProjectiles subsystemProjectiles,
            Camera camera,
            int drawOrder,
            ref bool shouldDrawBlock,
            ref float drawBlockSize,
            ref Color drawBlockColor) { }

        public virtual void OnProjectileFlyOutOfLoadedChunks(Projectile projectile) { }

        public virtual void OnPickableDraw(Pickable pickable,
            SubsystemPickables subsystemPickables,
            Camera camera,
            int drawOrder,
            ref bool shouldDrawBlock,
            ref float drawBlockSize,
            ref Color drawBlockColor) { }

        public virtual void UpdateComponentBody(ComponentBody componentBody, float dt, bool skippedByOtherMods, out bool skipVanilla) {
            skipVanilla = false;
        }

        public virtual float? BodyCountInRaycast(ComponentBody componentBody, Ray3 ray, out bool skip) {
            skip = false;
            return null;
        }

        public virtual void OnMovingBlockSetAdded(ref SubsystemMovingBlocks.MovingBlockSet movingBlockSet,
            SubsystemMovingBlocks subsystemMovingBlocks,
            ref bool testCollision,
            out bool doNotAdd) {
            doNotAdd = false;
        }

        public virtual void OnMovingBlockSetRemoved(IMovingBlockSet movingBlockSet, SubsystemMovingBlocks subsystemMovingBlocks) { }

        public virtual void OnMovingBlockSetUpdate(IMovingBlockSet movingBlockSet,
            SubsystemMovingBlocks subsystemMovingBlocks,
            bool skippedByOtherMods,
            out bool skipVanilla) {
            skipVanilla = false;
        }

        public virtual void OnProjectileAdded(SubsystemProjectiles subsystemProjectiles,
            ref Projectile projectile,
            ValuesDictionary loadValuesDictionary) { }

        public virtual void OnPickableAdded(SubsystemPickables subsystemPickables, ref Pickable pickable, ValuesDictionary loadValuesDictionary) { }

        public virtual void SaveProjectile(SubsystemProjectiles subsystemProjectiles,
            Projectile projectile,
            ref ValuesDictionary valuesDictionary) { }

        public virtual void SavePickable(SubsystemPickables subsystemPickables, Pickable pickable, ref ValuesDictionary valuesDictionary) { }

        public virtual void OnBlockDug(ComponentMiner componentMiner,
            BlockPlacementData digValue,
            int cellValue,
            ref int durabilityReduction,
            ref bool mute,
            ref int playerDataDugAdd) {
            mute = false;
        }

        public virtual void ChangeGameTimeDelta(SubsystemTime subsystemTime, ref float dt) { }

        public virtual void OnIUpdateableAddOrRemove(SubsystemUpdate subsystemUpdate,
            IUpdateable updateable,
            bool toAdd1OrRemove0,
            bool skippedByOtherMods,
            out bool skip) {
            skip = false;
        }

        public virtual void OnIDrawableAdded(SubsystemDrawing subsystemDrawing, IDrawable drawable, bool skippedByOtherMods, out bool skip) {
            skip = false;
        }

        public virtual void OnFurnitureDesigned(FurnitureDesign furnitureDesign,
            bool designedFromExistingFurniture,
            ref int pickableCount,
            ref bool destroyDesignBlocks,
            ref int toolDamageCount) { }

        public virtual void OnInventorySlotWidgetDefined(InventorySlotWidget inventorySlotWidget, out List<Widget> childrenWidgetsToAdd) {
            childrenWidgetsToAdd = null;
        }

        public virtual void InventorySlotWidgetMeasureOverride(InventorySlotWidget inventorySlotWidget, Vector2 parentAvailableSize) { }

        public virtual void HandleMoveInventoryItem(InventorySlotWidget inventorySlotWidget,
            IInventory sourceInventory,
            int sourceSlotIndex,
            IInventory targetInventory,
            int targetSlotIndex,
            ref int count,
            out bool moved) {
            moved = false;
        }

        public virtual void OnInventorySlotWidgetCalculateSplitCount(
            InventorySlotWidget inventorySlotWidget,
            int totalItemCount,
            DragMode dragMode,
            ref int splitCount) { }

        public virtual void HandleInventoryDragProcess(InventorySlotWidget inventorySlotWidget,
            IInventory sourceInventory,
            int sourceSlotIndex,
            IInventory targetInventory,
            int targetSlotIndex,
            ref int processCapacity) { }

        public virtual void HandleInventoryDragMove(InventorySlotWidget inventorySlotWidget,
            IInventory sourceInventory,
            int sourceSlotIndex,
            IInventory targetInventory,
            int targetSlotIndex,
            bool skippedByOtherMods,
            out bool skip) {
            skip = false;
        }

        public virtual void OnPlayerControlSteed(ComponentPlayer componentPlayer, bool skippedByOtherMods, out bool skipVanilla) {
            skipVanilla = false;
        }

        public virtual void OnPlayerControlBoat(ComponentPlayer componentPlayer, bool skippedByOtherMods, out bool skipVanilla) {
            skipVanilla = false;
        }

        public virtual void OnPlayerControlOtherMount(ComponentPlayer componentPlayer, bool skippedByOtherMods, out bool skipVanilla) {
            skipVanilla = false;
        }

        public virtual void OnPlayerControlWalk(ComponentPlayer componentPlayer, bool skippedByOtherMods, out bool skipVanilla) {
            skipVanilla = false;
        }

        public virtual void OnPlayerInputInteract(ComponentPlayer componentPlayer,
            ref bool playerOperated,
            ref double timeIntervalLastActionTime,
            ref int priorityUse,
            ref int priorityInteract,
            ref int priorityPlace) { }

        public virtual void UpdatePlayerInputAim(ComponentPlayer componentPlayer,
            bool aiming,
            ref bool playerOperated,
            ref float timeIntervalAim,
            bool skippedByOtherMods,
            out bool skipVanilla) {
            skipVanilla = false;
        }

        public virtual void OnPlayerInputHit(ComponentPlayer componentPlayer,
            ref bool playerOperated,
            ref double timeIntervalHit,
            ref float meleeAttackRange,
            bool skippedByOtherMods,
            out bool skipVanilla) {
            skipVanilla = false;
        }

        public virtual void UpdatePlayerInputDig(ComponentPlayer componentPlayer,
            bool digging,
            ref bool playerOperated,
            ref double timeIntervalDig,
            bool skippedByOtherMods,
            out bool skipVanilla) {
            skipVanilla = false;
        }

        public virtual void OnPlayerInputDrop(ComponentPlayer componentPlayer, bool skippedByOtherMods, out bool skipVanilla) {
            skipVanilla = false;
        }

        public virtual void OnLightningStrike(SubsystemSky subsystemSky,
            ref Vector3 targetPosition,
            ref bool strike,
            ref float explosionPressure,
            ref bool setBodyOnFire) { }

        public virtual void OnTerrainBrushesCreated() { }

        public virtual void FindCoarseSpawnPosition(ITerrainContentsGenerator terrainContentsGenerator, ref Vector3 spawnPosition) { }

        public virtual void OnChaseBehaviorAttacked(ComponentChaseBehavior componentChaseBehavior,
            float chaseTimeBefore,
            ref float chaseTime,
            ref bool hitBody,
            ref bool playAttackSound) { }

        public virtual void OnChaseBehaviorAttackFailed(ComponentChaseBehavior componentChaseBehavior, ref float chaseTime) { }

        public virtual void CalculateFallDamage(ComponentHealth componentHealth, ref float damage) { }

        public virtual void OnLocomotionStopped(ComponentLocomotion componentLocomotion, ref bool fallsOnDeathOrStun) { }

        public virtual void OnComponentLocomotionLoaded(ComponentLocomotion componentLocomotion,
            ref float mobWalkSpeedFactor,
            ref float mobFlySpeedFactor,
            ref float mobSwimSpeedFactor,
            ref bool disableCreativeFlyInSurvivalMode) { }

        public virtual void OnDispenserDispensePickable(ComponentDispenser componentDispenser, ref Pickable pickable, ref int removeSlotCount) { }

        public virtual void OnDispenserShoot(ComponentDispenser componentDispenser,
            ref Projectile projectile,
            ref bool canDispensePickable,
            ref int removeSlotCount) { }

        public virtual void DispenserChooseItemToDispense(ComponentDispenser componentDispenser, ref int slot, ref int value, out bool chosen) {
            chosen = false;
        }

        public virtual void LoadWorldInfoWidget(WorldInfo worldInfo, XElement savedWorldItemNode, ref ContainerWidget worldInfoWidget) { }

        [Obsolete("Override EditBlockDescriptionScreen(Dictionary<string,string> blockProperties, int blockValue) instead.")]
        public virtual void EditBlockDescriptionScreen(Dictionary<string, string> blockProperties) { }

        public virtual void EditBlockDescriptionScreen(Dictionary<string, string> blockProperties, int blockValue) { }

        public virtual void EditRecipeScreenWidget(RecipaediaRecipesScreen screen) { }

        public virtual void UpdateCreaturePropertiesInBestiaryDescriptionScreen(BestiaryDescriptionScreen bestiaryDescriptionScreen,
            BestiaryCreatureInfo bestiaryCreatureInfo,
            ValuesDictionary entityValuesDictionary) { }

        public virtual void LoadCreatureInfoInBestiaryScreen(BestiaryScreen bestiaryScreen,
            ContainerWidget creatureInfoWidget,
            BestiaryCreatureInfo bestiaryCreatureInfo,
            ValuesDictionary entityValuesDictionary) { }

        public virtual void ResetOptionsForNonCreativeMode(WorldSettings worldSettings,
            EnvironmentBehaviorMode environmentBehaviorModeBefore,
            TimeOfDayMode timeOfDayModeBefore,
            bool areWeatherEffectsEnabledBefore,
            bool areSurvivalMechanicsEnabledBefore) { }

        public virtual void CraftingRecipesManagerInitialize(List<CraftingRecipe> recipes, ref bool sort) { }

        public virtual void CraftingRecipesManagerInitialized() { }

        public virtual void PlayInGameMusic() { }
 
        [Obsolete("Use TerrainContentsGenerator24Initialize")]
        public virtual void TerrainContentsGenerator23Initialize(ITerrainContentsGenerator terrainContentsGenerator,
            SubsystemTerrain subsystemTerrain) { }
 
        public virtual void TerrainContentsGenerator24Initialize(ITerrainContentsGenerator terrainContentsGenerator,
            SubsystemTerrain subsystemTerrain) { }
 
        public virtual void PrepareModels(SubsystemModelsRenderer subsystemModelsRenderer, Camera camera, bool skippedByOtherMods, out bool skip) {
            skip = false;
        }
 
        public virtual void RenderModels(SubsystemModelsRenderer subsystemModelsRenderer,
            Camera camera,
            int drawOrder,
            bool skippedByOtherMods,
            out bool skip) {
            skip = false;
        }

        public virtual void UpdateDeathCameraWidget(PlayerData playerData, ref bool disableVanillaTapToRespawnAction, ref bool respawn) { }

        public virtual void OnComponentBodyExplodedStart(ComponentBody componentBody,
            Vector3 explosionCenter,
            float explosionPressure,
            ref float shakeStrength) { }

        public virtual void GrowPlant(SubsystemPlantBlockBehavior subsystemPlantBlockBehavior,
            int x,
            int y,
            int z,
            int pollPass,
            out bool skipVanilla) {
            skipVanilla = false;
        }

        public virtual void OnProjectileTurnIntoPickable(Projectile projectile, ref Pickable pickable) { }

        public virtual void EntityComponentsInitialized(Entity entity, List<KeyValuePair<int, Component>> componentList) { }

        public virtual void ProjectBeforeSubsystemsAndEntitiesLoad(Project project) { }

        public virtual void OnScreenEntered(Screen screen, object[] screenParameters) { }

        public virtual void OnScreenLeaved(Screen screen) { }

        public virtual void BeforeWidgetUpdate(Widget widget) { }

        public virtual void AfterWidgetUpdate(Widget widget) { }
 
        public virtual void OnChaseBehaviorStartChasing(ComponentChaseBehavior chaseBehavior) { }
        public virtual void OnChaseBehaviorStopChasing(ComponentChaseBehavior chaseBehavior) { }

        public virtual void ChaseBehaviorScoreTarget(ComponentChaseBehavior chaseBehavior, ComponentCreature creatureToBeTarget, ref float score) { }
 
        public virtual void UpdateChaseBehaviorLookingForTarget(ComponentChaseBehavior chaseBehavior) { }
        public virtual void UpdateChaseBehaviorChasing(ComponentChaseBehavior chaseBehavior) { }

        public virtual void DecideLoot(ComponentLoot componentLoot, List<BlockDropValue> dropValues) { }

        public virtual void OnMainMenuScreenCreated(MainMenuScreen mainMenuScreen,
            StackPanelWidget leftBottomBar,
            StackPanelWidget rightBottomBar) { }

        [Obsolete("Use OnMainMenuScreenCreated instead.")]
        public virtual void OnMainMenuScreenUpdate(MainMenuScreen mainMenuScreen, StackPanelWidget leftBottomBar, StackPanelWidget rightBottomBar) { }

        [Obsolete("You can update your factors in your mod components.")]
        public virtual void OnFactorsGenerate(ComponentFactors componentFactors) { }

        public virtual void DecideArmorProtectionSequence(ComponentClothing componentClothing,
            Attackment attackment,
            float randomNumber,
            List<int> clothesList) { }

        public virtual void ApplyProtectionBeforeClothes(ComponentClothing componentClothing,
            Attackment attackment,
            ref float attackPowerAfterProtection) { }

        public virtual void ApplyProtectionAfterClothes(ComponentClothing componentClothing,
            Attackment attackment,
            List<int> listAfterProtection,
            ref float attackPowerAfterProtection) { }

        public virtual void InitializeClothingSlots() { }

        public virtual void OnPlayerModelWidgetMeasureOverride(PlayerModelWidget playerModelWidget) { }

        public virtual void IsCrosshairVisible(ComponentAimingSights componentAimingSights, ref bool isVisible) { }

        public virtual IEnumerable<KeyValuePair<string, object>> GetKeyboardMappings() {
            yield break;
        }

        public virtual IEnumerable<KeyValuePair<string, object>> GetGamepadMappings() {
            //ValuesDictionary valuesDictionary = [];
            //valuesDictionary.SetValue("ModifierKey", Engine.Input.GamePadButton.LeftShoulder);
            //valuesDictionary.SetValue("ActionKey", Engine.Input.GamePadButton.X);
            //yield return new("TimeOfDay", valuesDictionary);
            yield break;
        }

        public virtual IEnumerable<KeyValuePair<string, int>> GetCameraList() {
            yield break;
        }

        public virtual void InitKeyCompatibleGroups() { }

        public virtual void OnSettingsScreenCreated(SettingsScreen settingsScreen, out Dictionary<ButtonWidget, Action> buttonsToAdd) {
            buttonsToAdd = [];
        }

        public virtual void ModifyLogColor(string text, ref Color color) { }

        public virtual void PlayerDataFirstUpdate(PlayerData playerData) { }

        public virtual void RecalculateCameraProjection(Camera camera, ref Matrix projectionMatrix) { }

        public virtual void OnProjectileRaycastBody(ComponentBody componentBody, Projectile projectile, float distance, out bool ignore) {
            ignore = false;
        }

        public virtual void ClothingProcessSlotItems(ComponentClothing componentClothing,
            int slotIndex,
            ref int inputValue,
            ref int inputCount,
            ref int processedValue,
            ref int processedCount,
            bool skippedByOtherMods,
            out bool skipVanilla) {
            skipVanilla = false;
        }
 
        [Obsolete(
            "该接口有误，建议使用另一个同名接口ClothingProcessSlotItems(ComponentClothing componentClothing,int slotIndex,ref int inputValue,ref int inputCount,ref int processedValue,ref int processedCount,bool skippedByOtherMods,out bool skipVanilla)"
        )]
        public virtual void ClothingProcessSlotItems(ComponentPlayer componentPlayer,
            int slotIndex,
            ref int inputValue,
            ref int inputCount,
            ref int processedValue,
            ref int processedCount,
            bool skippedByOtherMods,
            out bool skipVanilla) {
            skipVanilla = false;
        }

        public virtual void OnModelDataDrawing(SubsystemModelsRenderer.ModelData modelData,
            ModelShader modelShader,
            Camera camera,
            SubsystemModelsRenderer subsystemModelsRenderer,
            out bool skip) {
            skip = false;
        }

        public virtual void OnFirstPersonModelDrawing(ComponentFirstPersonModel componentFirstPersonModel,
            Camera camera,
            int itemValue,
            ref Matrix matrix,
            out bool skip) {
            skip = false;
        }

        public virtual void OnEntityBehaviorBlockInteracted(object raycastResult,
            bool isInitialNull,
            ref ComponentBlockEntity componentBlockEntity) { }

        public virtual void OnAppendModelMeshPart(BlockMesh blockMesh,
            ModelMeshPart meshPart,
            Matrix matrix,
            bool makeEmissive,
            bool flipWindingOrder,
            bool doubleSided,
            bool flipNormals,
            Color color,
            out bool skip) {
            skip = false;
        }

        public virtual void OnAppendModelMesh(BlockMesh blockMesh, BlockMesh blockMesh1, out bool skip) {
            skip = false;
        }

        public virtual void OnVitalStatsEat(
            ComponentVitalStats vitalStats,
            ref int value,
            ref bool skipVanilla,
            out bool eatSuccess) {
            // 默认返回进食失败，模组可重写修改
            eatSuccess = false;
        }

        public virtual void OnVitalStatsUpdateFood(
            ComponentVitalStats vitalStats,
            ref float food,
            ref float gameTimeDelta,
            ref bool skipVanilla) { }

        public virtual void OnVitalStatsUpdateStamina(
            ComponentVitalStats vitalStats,
            ref float stamina,
            ref float gameTimeDelta,
            ref bool skipVanilla) { }

        public virtual void OnVitalStatsUpdateSleep(
            ComponentVitalStats vitalStats,
            ref float sleep,
            ref float gameTimeDelta,
            ref bool skipVanilla) { }

        public virtual void OnVitalStatsUpdateTemperature(
            ComponentVitalStats vitalStats,
            ref float temperature,
            ref float gameTimeDelta,
            ref bool skipVanilla) { }

        public virtual void OnVitalStatsUpdateWetness(
            ComponentVitalStats vitalStats,
            ref float wetness,
            ref float gameTimeDelta,
            ref bool skipVanilla) { }
    }
}