using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using BepInEx;

using BepInEx.Configuration;

using HarmonyLib;

using System.IO;

using UnityEngine;

// Possible TODOS:

// maybe? don't open the map when in build mode.

// don't move camera when build menu is open and mouse is moving around.

// disallow and deactivate when swimming

// deactivate when taking damage

namespace Valheim_Build_Camera

{

[BepInPlugin(MID, PluginName, VERSION)]

[BepInProcess("valheim.exe")]

[HarmonyPatch] // The empty annotation marks the class as a patch class.

// Harmony will consider the class and its methods.

public class Valheim_Build_Camera : BaseUnityPlugin

{

private const string MID = "org.gittywithexcitement.plugins.valheim.buildCamera";

private const string VERSION = "1.6.1";

private const string PluginName = "Build Camera";

private static ConfigFile configFile = new ConfigFile(Path.Combine(Paths.ConfigPath, "Build Camera.cfg"), true);

private static ConfigEntry<float> distanceCanBuildFromAvatar

= configFile.Bind("General", "Distance_Can_Build_From_Avatar", 100f,

"Distance from your avatar that you can build or repair. (Valheim default is 8)");

private static ConfigEntry<float> distanceCanBuildFromWorkbench

= configFile.Bind("General", "Distance_Can_Build_From_Workbench", 100f,

"Distance from nearest workbench/stonecutter/etc. that you can build or repair. (Valheim default is 20)");

private static ConfigEntry<float> cameraRangeMultiplier

= configFile.Bind("General", "Camera_Range_Multiplier", 1f,

"Changes maximum range camera can move away from the build station. 1 means the build station's" +

" range, 2 means twice the build station range, etc.");

private static ConfigEntry<float> cameraMoveSpeedMultiplier

= configFile.Bind("General", "Camera_Move_Speed_Multiplier", 3f,

"Multiplies the speed at which the build camera pans (i.e. moves around).");

private static ConfigEntry<bool> moveWithRespectToWorld

= configFile.Bind("General", "Move_With_Respect_To_World", false,

"When true, camera panning input (e.g. pressing WASD) moves the camera with respect to the " +

"world coordinates. This means that turning the camera has no effect on the direction of " +

"movement. For example, pressing W will always move the camera toward the world's 'North', " +

"as opposed to the direction the camera is currently facing.");

private static ConfigEntry<KeyboardShortcut> toggleBuildMode =

configFile.Bind("Hotkeys", "Toggle_build_mode", new KeyboardShortcut(UnityEngine.KeyCode.B),

"See https://docs.unity3d.com/ScriptReference/KeyCode.html for the names of all key codes. To " +

"add one or more modifier keys, separate them with +, like so: Toggle_build_mode = B + LeftControl");

private static ConfigEntry<bool> verboseLogging

= configFile.Bind("General", "Verbose_Logging", false,

"When true, increases verbosity of logging. Enable this if you're wondering why you're unable " +

"to enable the Build Camera.");

// This is how we "add" member variables to a class of the game.

private static Dictionary<Player, bool> inBuildMode = new Dictionary<Player, bool>();

private static BepInEx.Logging.ManualLogSource log;

struct BuildCameraView

{

/// <summary>

/// Turns the view left/right.

/// </summary>

public float yaw;

/// <summary>

/// Turns the view up/down.

/// </summary>

public float pitch;

}

/// <summary>

/// The current pitch and yaw of the build camera.

/// </summary>

private static BuildCameraView buildCameraViewDirection =

new BuildCameraView { pitch = 0, yaw = 0 };

void Awake()

{

var harmony = new Harmony(MID);

harmony.PatchAll();

log = BepInEx.Logging.Logger.CreateLogSource(PluginName);

}

[HarmonyPrefix]

[HarmonyPatch(typeof(Player), "Awake")]

public static void Player_Awake(ref float ___m_maxPlaceDistance)

{

if (___m_maxPlaceDistance < distanceCanBuildFromAvatar.Value)

{

log.LogDebug($"in Player_Awake, changing maxPlaceDistance from {___m_maxPlaceDistance} to {distanceCanBuildFromAvatar.Value}");

___m_maxPlaceDistance = distanceCanBuildFromAvatar.Value;

}

else

{

log.LogDebug($"Not changing distanceCanBuildFromAvatar (AKA maxPlaceDistance) as it seems another mod has already changed it.");

}

}

[HarmonyPrefix]

[HarmonyPatch(typeof(CraftingStation), "Start")]

public static void CraftingStation_Start(ref CraftingStation __instance, ref float ___m_rangeBuild)

{

if (___m_rangeBuild < distanceCanBuildFromWorkbench.Value)

{

log.LogDebug($"in CraftingStation_Start, changing rangeBuild from {___m_rangeBuild} to {distanceCanBuildFromWorkbench.Value}");

___m_rangeBuild = distanceCanBuildFromWorkbench.Value;

}

else

{

log.LogDebug($"Not changing distanceCanBuildFromWorkbench (AKA rangeBuild) as it seems another mod has already changed it.");

}

}

static void LogWhenVerbose(string s)

{

if (verboseLogging.Value)

{

Player.m_localPlayer.Message(MessageHud.MessageType.TopLeft, s);

log.LogInfo(s);

}

}

// Returns true when the player has Build Mode activated.

static bool InBuildMode()

{

return (bool)Player.m_localPlayer && inBuildMode[Player.m_localPlayer];

}

static void DisableBuildMode()

{

inBuildMode[Player.m_localPlayer] = false;

}

static void EnableBuildMode()

{

inBuildMode[Player.m_localPlayer] = true;

// When entering build mode, we reset the view direction of the build

// camera, so that it matches the player's current direction. Thus, when

// entering build mode, there is no (abrupt) change to the camera.

var r = Player.m_localPlayer.m_eye.transform.rotation;

buildCameraViewDirection.pitch = r.eulerAngles.x;

buildCameraViewDirection.yaw = r.eulerAngles.y;

Player.m_localPlayer.Message(MessageHud.MessageType.TopLeft, "Entering Build Mode.");

}

/// <summary>

/// Returns true when player is the local player.

/// </summary>

/// <param name="player"></param>

/// <returns></returns>

static bool IsLocalPlayer(in Player player)

{

return (bool)Player.m_localPlayer && player == Player.m_localPlayer;

}

static readonly String[] toolNames

= new String[] { "$item_hammer", "$item_cultivator", "$item_hoe", "$PlumgaPlantItShovel", "$PlumgaClutterTool" , "$ImprovedHammer" };

/// <summary>

/// Returns true when the item is a Build Camera-compatible tool such as hammer.

/// </summary>

/// <param name="itemData"></param>

/// <returns></returns>

static bool IsTool(in ItemDrop.ItemData itemData)

{

return toolNames.Contains(itemData?.m_shared.m_name)

&& itemData?.m_shared.m_itemType == ItemDrop.ItemData.ItemType.Tool;

}

/// <summary>

/// Returns true when this player has a Build Camera-compatible tool such as

/// hammer equipped.

/// </summary>

/// <param name="player"></param>

/// <returns></returns>

static bool ToolIsEquipped(in Player player)

{

// Tools are always equipped in the right hand.

return IsTool(player.m_rightItem);

}

/// <summary>

/// Returns true when build mode should be deactivated: the hammer is

/// unequipped.

/// </summary>

/// <param name="player"></param>

/// <returns></returns>

static bool ShouldDeactivateBuildMode(in Player player)

{

return !ToolIsEquipped(player);

}

/// <summary>

/// When game calls Player.SetLocalPlayer, DisableBuildMode

/// </summary>

[HarmonyPatch(typeof(Player), "SetLocalPlayer")]

[HarmonyPostfix]

static void InitializeNotInBuildMode()

{

DisableBuildMode();

}

/// <summary>

/// Skip the game's Update when in build mode, to disallow actions like

/// Interact(). Only allow UpdatePlacement.

/// </summary>

/// <param name="__instance"></param>

/// <param name="__runOriginal"></param>

[HarmonyPatch(typeof(Player), "Update")]

[HarmonyPrefix]

static void Update_Prefix_Player(ref Player __instance, ref bool __runOriginal)

{

if (IsLocalPlayer(__instance) && InBuildMode())

{

if (ShouldDeactivateBuildMode(__instance))

{

// The user might have unequipped the hammer (e.g. by using hotbar

// items or unequipping via the inventory), so deactivate build mode.

DisableBuildMode();

__runOriginal = true;

}

else

{

__runOriginal = false;

// Allow hotkeys so that hammer can be unequipped, which exits build mode

// game source: Player.Update

if (__instance.TakeInput())

{

if (Input.GetKeyDown(KeyCode.Alpha1))

{

__instance.UseHotbarItem(1);

}

if (Input.GetKeyDown(KeyCode.Alpha2))

{

__instance.UseHotbarItem(2);

}

if (Input.GetKeyDown(KeyCode.Alpha3))

{

__instance.UseHotbarItem(3);

}

if (Input.GetKeyDown(KeyCode.Alpha4))

{

__instance.UseHotbarItem(4);

}

if (Input.GetKeyDown(KeyCode.Alpha5))

{

__instance.UseHotbarItem(5);

}

if (Input.GetKeyDown(KeyCode.Alpha6))

{

__instance.UseHotbarItem(6);

}

if (Input.GetKeyDown(KeyCode.Alpha7))

{

__instance.UseHotbarItem(7);

}

if (Input.GetKeyDown(KeyCode.Alpha8))

{

__instance.UseHotbarItem(8);

}

if (ZInput.GetButtonDown("Hide") || ZInput.GetButtonDown("JoyHide"))

{

if ((__instance.GetRightItem() != null || __instance.GetLeftItem() != null)

&& !__instance.InAttack())

{

__instance.HideHandItems();

}

}

__instance.UpdatePlacement(true, Time.deltaTime);

}

}

}

else

{

__runOriginal = true;

}

}

/// <summary>

/// Enters Build Mode when the bound key is pressed and various conditions

/// hold (e.g. hammer is equipped, player is close to a crafting station).

///

/// Exits Build Mode when the bound key is pressed.

/// </summary>

/// <param name="__instance"></param>

[HarmonyPatch(typeof(Player), "Update")]

[HarmonyPostfix]

static void Update_Postfix_Player(ref Player __instance)

{

if (IsLocalPlayer(__instance) && toggleBuildMode.Value.IsDown() && __instance.TakeInput())

{

if (!InBuildMode() && ToolIsEquipped(__instance) && BuildStationInRange(__instance))

{

EnableBuildMode();

return;

}

else if (InBuildMode())

{

DisableBuildMode();

return;

}

}

if (IsLocalPlayer(__instance) && toggleBuildMode.Value.IsDown())

{

if (!__instance.TakeInput())

{

LogWhenVerbose("Build Mode not enabled because chat, console, menu, inventory, map, or similar is open.");

}

else if (!ToolIsEquipped(__instance))

{

LogWhenVerbose("Build Mode not enabled because hammer is not equipped.");

}

else if (!BuildStationInRange(__instance))

{

LogWhenVerbose("Build Mode not enabled because no build station (e.g. workbench) is in range.");

}

}

}

/// <summary>

/// Stops the player's avatar from moving when in build mode.

/// </summary>

/// <param name="__result"></param>

/// <param name="__runOriginal"></param>

[HarmonyPatch(typeof(PlayerController), "TakeInput")]

[HarmonyPrefix]

static void TakeInput_PlayerController(ref bool __result, ref bool __runOriginal)

{

if (InBuildMode())

{

__result = false;

__runOriginal = false;

}

else

{

__runOriginal = true;

}

}

// *** Camera ***

/// <summary>

/// A crafting station (e.g. workbench) near the player.

/// </summary>

struct NearbyCraftingStation

{

public Vector3 position;

// Distance from the player

public float distance;

// The valid build range for this specific crafting station. Apparently

// each station may have a different build range.

public float rangeBuild;

}

/// <summary>

/// Returns the NearestBuildStation. It can be a workbench or a stone cutting bench.

/// </summary>

/// <param name="playerOrCamera"></param>

/// <returns></returns>

static NearbyCraftingStation? GetNearestBuildStation(in Vector3 playerOrCamera)

{

if (CraftingStation.m_allStations.Count == 0)

{

return null;

}

else

{

List<NearbyCraftingStation> nearbyCraftingStations = new List<NearbyCraftingStation>();

foreach (CraftingStation station in CraftingStation.m_allStations)

{

nearbyCraftingStations.Add(new NearbyCraftingStation

{

position = station.transform.position,

distance = Vector3.Distance(station.transform.position, playerOrCamera),

rangeBuild = station.m_rangeBuild

});

}

return nearbyCraftingStations.OrderBy(x => x.distance).First();

}

}

/// <summary>

/// Returns true when a build/craft station is within range.

///

/// Note that range is determined by the specific build/craft station. The

/// range is *not* multiplied by cameraRangeMultiplier. That is, we expect

/// the player to enter build mode while within the build range of a

/// crafting station. The camera may stray outside of the building range,

/// but all pieces will (presumably) be placed within build range.

/// </summary>

/// <param name="player"></param>

/// <returns></returns>

static bool BuildStationInRange(in Player player)

{

var maybeStation = GetNearestBuildStation(player.transform.position);

if (maybeStation is NearbyCraftingStation nearbyCraftingStation)

{

return nearbyCraftingStation.distance <= nearbyCraftingStation.rangeBuild;

}

else

{

return false;

}

}

/// <summary>

/// Prevents the game camera from going out of range of the nearest build

/// station (multiplied by the cameraRangeMultiplier).

/// </summary>

/// <param name="__instance"></param>

static void StayNearWorkbench(ref GameCamera __instance)

{

var maybeStation = GetNearestBuildStation(__instance.transform.position);

if (maybeStation is NearbyCraftingStation nearbyCraftingStation)

{

if (nearbyCraftingStation.distance

> nearbyCraftingStation.rangeBuild * cameraRangeMultiplier.Value)

{

float error = nearbyCraftingStation.distance

- nearbyCraftingStation.rangeBuild * cameraRangeMultiplier.Value;

Vector3 towardStation = nearbyCraftingStation.position - __instance.transform.position;

Vector3 correction = error * towardStation.normalized;

__instance.transform.position = __instance.transform.position + correction;

}

}

else

{

DisableBuildMode();

}

}

/// <summary>

/// Prevents the game camera from going below ground.

/// </summary>

/// <param name="__instance"></param>

static void StayAboveGround(ref GameCamera __instance)

{

if (ZoneSystem.instance.GetGroundHeight(__instance.transform.position, out float height))

{

if (__instance.transform.position.y < height)

{

Vector3 p = __instance.transform.position;

p.y = height;

__instance.transform.position = p;

}

}

}

/// <summary>

/// Updates buildCameraViewDirection (based on mouse and controller

/// movement) and returns the pitch and yaw as a quanternion.

/// </summary>

/// <param name="dt"></param>

/// <returns></returns>

static Quaternion UpdateBuildCameraViewDirection(float dt)

{

// Game source: GameCamera.UpdateFreeFly(float dt)

buildCameraViewDirection.yaw +=

(PlayerController.m_mouseSens * Input.GetAxis("Mouse X"))

+ (ZInput.GetJoyRightStickX() * 110f * dt);

float polarity = PlayerController.m_invertMouse ? -1 : 1;

float pitchUnchecked =

buildCameraViewDirection.pitch -

polarity

* ((PlayerController.m_mouseSens * Input.GetAxis("Mouse Y"))

- (ZInput.GetJoyRightStickY() * 110f * dt));

buildCameraViewDirection.pitch = Mathf.Clamp(pitchUnchecked, -89f, 89f);

return

Quaternion.Euler(0f, buildCameraViewDirection.yaw, 0f) * Quaternion.Euler(buildCameraViewDirection.pitch, 0f, 0f);

}

/// <summary>

/// Returns the untransformed (i.e. unaffected by current camera view

/// direction) vector by which the GameCamera should move (i.e. pan).

///

/// Movement is based on keyboard (and controller) input.

/// </summary>

/// <returns></returns>

static Vector3 UntransformedMovementVector(float dt)

{

// Game source: GameCamera.UpdateFreeFly(float dt)

Vector3 vector = Vector3.zero;

if (ZInput.GetButton("Left"))

{

vector -= Vector3.right;

}

if (ZInput.GetButton("Right"))

{

vector += Vector3.right;

}

if (ZInput.GetButton("Forward"))

{

vector += Vector3.forward;

}

if (ZInput.GetButton("Backward"))

{

vector -= Vector3.forward;

}

if (ZInput.GetButton("Jump") || ZInput.GetButton("JoyJump"))

{

vector += Vector3.up;

}

if (ZInput.GetButton("Crouch") || ZInput.GetButton("JoyCrouch"))

{

vector -= Vector3.up;

}

// I'm not sure if this is correct, but I'm going to normalize before

// accounting for analog (joystick) movements. I would *not* want to

// normalize after accounting for analog movement, because that would ruin

// the whole point of having an analog input.

vector.Normalize();

vector += Vector3.right * ZInput.GetJoyLeftStickX();

vector += -Vector3.forward * ZInput.GetJoyLeftStickY();

float baseSpeed =

ZInput.GetButton("Run") ? Player.m_localPlayer.m_runSpeed : Player.m_localPlayer.m_walkSpeed;

// When I use m_walkSpeed to move the build camera, it moves very slow,

// much slower than the avatar's walking speed. m_walkSpeed is used in

// Character.UpdateWalking, but that function is so dense, I don't

// understand why the avatar walks faster. So we speed up the build

// camera's movement by cameraMoveSpeedMultiplier.

return vector * (dt * baseSpeed * cameraMoveSpeedMultiplier.Value);

}

/// <summary>

/// Pans and rotates the camera based on user input (e.g. mouse movement and WASD).

///

/// Assumes that Build Mode is activated.

/// </summary>

/// <param name="dt"></param>

/// <param name="__instance"></param>

static void UpdateBuildCamera(float dt, ref GameCamera __instance)

{

// Game source: GameCamera.UpdateFreeFly(float dt)

if (!Console.IsVisible() && Player.m_localPlayer.TakeInput() && !Hud.IsPieceSelectionVisible())

{

var untransformed = UntransformedMovementVector(dt);

Vector3 moveBy = moveWithRespectToWorld.Value

? untransformed : __instance.transform.TransformVector(untransformed);

__instance.transform.position += moveBy;

StayNearWorkbench(ref __instance);

StayAboveGround(ref __instance);

__instance.transform.rotation = UpdateBuildCameraViewDirection(dt);

}

}

/// <summary>

/// Decides if build camera is enabled and the game camera should free fly, or not.

/// </summary>

/// <param name="dt"></param>

/// <param name="__instance"></param>

/// <param name="__runOriginal"></param>

[HarmonyPatch(typeof(GameCamera), "UpdateCamera")]

[HarmonyPrefix]

static void UpdateCamera(float dt, ref GameCamera __instance, ref bool __runOriginal)

{

if (InBuildMode())

{

UpdateBuildCamera(dt, ref __instance);

__runOriginal = false;

}

else

{

__runOriginal = true;

}

}

}

}