CM3D2CameraUtility.Plugin

using System;
using System.Reflection;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEngine;
using UnityInjector;
using UnityInjector.Attributes;

namespace CM3D2CameraUtility
{
    [PluginFilter("CM3D2x64"),
    PluginFilter("CM3D2x86"),
    PluginFilter("CM3D2VRx64"),
    PluginName("Camera Utility"),
    PluginVersion("1.1.0.1")]

    public class CameraUtility : PluginBase
    {
        private CameraMain mainCamera;
        private Transform mainCameraTransform;
        private Transform maidTransform;
        private Transform bg;
        private GameObject manEye;
        private Maid maid;

        private float defaultFOV = 35f;
        private bool allowUpdate = false;
        private bool occulusVR = false;
        private bool fpsMode = false;
        private bool eyetoCamToggle = false;

        private float cameraRotateSpeed = 1f;
        private float cameraFOVChangeSpeed = 0.25f;
        private float floorMoveSpeed = 0.05f;
        private float maidRotateSpeed = 2f;
        private float fpsModeFoV = 60f;

        private Vector3 testDirection = Vector3.zero;
        private int sceneLevel;
        private int frameCount = 0;

        private float fpsOffsetForward = 0.02f;
        private float fpsOffsetUp = 0.06f;

        ////以下の数値だと男の目の付近にカメラが移動しますが
        ////うちのメイドはデフォで顔ではなく喉元見てるのであんまりこっち見てくれません
        //private float fpsOffsetForward = 0.1f;
        //private float fpsOffsetUp = 0.12f;

        private KeyCode bgLeftMove = KeyCode.LeftArrow;
        private KeyCode bgRightMove = KeyCode.RightArrow;
        private KeyCode bgForwardMove = KeyCode.UpArrow;
        private KeyCode bgBackMove = KeyCode.DownArrow;
        private KeyCode bgUpMove = KeyCode.PageUp;
        private KeyCode bgDownMove = KeyCode.PageDown;
        private KeyCode bgLeftRotate = KeyCode.Delete;
        private KeyCode bgRightRotate = KeyCode.End;

        private Vector3 oldPos;
        private Vector3 oldTargetPos;
        private float oldDistance;
        private Quaternion oldRotation;
        private bool oldEyetoCamToggle;
        private int eyeToCamIndex = 0;

        public void Awake()
        {
            string path = Application.dataPath;
            occulusVR = path.Contains("CM3D2VRx64");
            GameObject.DontDestroyOnLoad(this);
            if (occulusVR)
            {
                bgLeftMove = KeyCode.J;
                bgRightMove = KeyCode.L;
                bgForwardMove = KeyCode.I;
                bgBackMove = KeyCode.K;
                bgUpMove = KeyCode.Alpha0;
                bgDownMove = KeyCode.P;
                bgLeftRotate = KeyCode.U;
                bgRightRotate = KeyCode.O;
            }
        }

        public void Start()
        {
            mainCameraTransform = Camera.main.gameObject.transform;
        }

        public void OnLevelWasLoaded(int level)
        {
            sceneLevel = level;

            GameObject[] array = UnityEngine.Object.FindObjectsOfType<GameObject>();
            foreach (var gameobject in array)
            {
                if (gameobject.name.IndexOf("Maid[0]") > -1)
                {
                    maidTransform = gameobject.transform;
                }
            }

            maid = GameMain.Instance.CharacterMgr.GetMaid(0);

            bg = GameObject.Find("__GameMain__/BG").transform;

            mainCamera = GameMain.Instance.MainCamera;


            if (maidTransform && bg && maid)
            {
                allowUpdate = true;
            }
            else
            {
                allowUpdate = false;
            }

            if (!occulusVR)
            {
                defaultFOV = Camera.main.fieldOfView;
            }

            fpsMode = false;
        }

        private void SaveCameraPos()
        {
            oldPos = mainCamera.GetPos();
            oldTargetPos = mainCamera.GetTargetPos();
            oldDistance = mainCamera.GetDistance();
            oldRotation = mainCameraTransform.transform.rotation;

        }

        private void LoadCameraPos()
        {
            mainCameraTransform.transform.rotation = oldRotation;
            mainCamera.SetPos(oldPos);
            mainCamera.SetTargetPos(oldTargetPos, true);
            mainCamera.SetDistance(oldDistance, true);
        }

        private Vector3 GetYotogiPlayPosition()
        {
            var field = mainCamera.GetType().GetField("m_vCenter", BindingFlags.GetField | BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Instance);
            return (Vector3)field.GetValue(mainCamera);
        }

        private void FirstPersonCamera()
        {
            if (sceneLevel == 14)
            {
                if (!occulusVR)
                {

                    if (!manEye)
                    {
                        if (frameCount == 60)
                        {
                            manEye = GameObject.Find("__GameMain__/Character/Active/AllOffset/Man[0]/Offset/_BO_mbody/ManBip/ManBip Spine/ManBip Spine1/ManBip Spine2/ManBip Neck/ManBip Head");
                            frameCount = 0;
                        }
                        else
                        {
                            frameCount++;
                        }
                    }
                    else
                    {
                        if (Input.GetKeyDown(KeyCode.F))
                        {
                            fpsMode = !fpsMode;
                            Console.WriteLine("fpsmode = " + fpsMode.ToString());
                            if (fpsMode)
                            {
                                SaveCameraPos();

                                Camera.main.fieldOfView = fpsModeFoV;
                                eyetoCamToggle = false;
                                maid.EyeToCamera(Maid.EyeMoveType.無し, 0f);

                                mainCameraTransform.transform.rotation = Quaternion.LookRotation(manEye.transform.up);
                            }
                            else
                            {

                                Vector3 cameraTargetPosFromScript = GetYotogiPlayPosition();

                                if (oldTargetPos != cameraTargetPosFromScript)
                                {
                                    Console.WriteLine("Position Changed!");
                                    oldTargetPos = cameraTargetPosFromScript;
                                }

                                LoadCameraPos();
                                Camera.main.fieldOfView = defaultFOV;

                                //mainCamera.ResetFromScriptOnTarget();
                                eyetoCamToggle = oldEyetoCamToggle;
                                oldEyetoCamToggle = eyetoCamToggle;
                            }
                        }

                        if (fpsMode)
                        {
                            Vector3 cameraTargetPosFromScript = GetYotogiPlayPosition();
                            if (oldTargetPos != cameraTargetPosFromScript)
                            {
                                Console.WriteLine("Position Changed!");
                                mainCameraTransform.transform.rotation = Quaternion.LookRotation(manEye.transform.up);
                                oldTargetPos = cameraTargetPosFromScript;

                            }

                            mainCamera.SetPos(manEye.transform.position + manEye.transform.up * fpsOffsetUp + manEye.transform.right * -fpsOffsetForward);

                            mainCamera.SetTargetPos(manEye.transform.position + manEye.transform.up * fpsOffsetUp + manEye.transform.right * -fpsOffsetForward, true);
                            mainCamera.SetDistance(0f, true);
                        }
                        else
                        {

                        }
                    }
                }
            }
        }

        private void ExtendedCameraHandle()
        {
            if (!occulusVR)
            {
                if (mainCameraTransform)
                {
                    //Equalsになっているが日本語キーボードだとセミコロン
                    if (Input.GetKey(KeyCode.Equals))
                    {
                        Camera.main.fieldOfView += -cameraFOVChangeSpeed;
                    }
                    //Semicolonになっているが日本語キーボードだとコロン
                    if (Input.GetKey(KeyCode.Semicolon))
                    {
                        Camera.main.fieldOfView = defaultFOV;
                    }
                    if (Input.GetKey(KeyCode.RightBracket))
                    {
                        Camera.main.fieldOfView += cameraFOVChangeSpeed;
                    }
                    if (Input.GetKey(KeyCode.Period))
                    {
                        mainCameraTransform.Rotate(0, 0, cameraRotateSpeed);
                    }
                    if (Input.GetKey(KeyCode.Slash))
                    {
                        mainCameraTransform.eulerAngles = new Vector3(
                            mainCameraTransform.rotation.eulerAngles.x,
                            mainCameraTransform.rotation.eulerAngles.y,
                            0f);
                    }
                    if (Input.GetKey(KeyCode.Backslash))
                    {
                        mainCameraTransform.Rotate(0, 0, -cameraRotateSpeed);
                    }
                }
            }
        }

        private void FloorMover(float moveSpeed, float rotateSpeed)
        {
            if (bg)
            {
                Vector3 forward = mainCameraTransform.TransformDirection(Vector3.forward);
                Vector3 right = mainCameraTransform.TransformDirection(Vector3.right);
                Vector3 up = mainCameraTransform.TransformDirection(Vector3.up);

                Vector3 direction = Vector3.zero;

                if (Input.GetKey(bgLeftMove))
                {
                    direction += new Vector3(right.x, 0f, right.z) * moveSpeed;
                }
                if (Input.GetKey(bgRightMove))
                {
                    direction += new Vector3(right.x, 0f, right.z) * -moveSpeed;
                }
                if (Input.GetKey(bgBackMove))
                {
                    direction += new Vector3(forward.x, 0f, forward.z) * moveSpeed;
                }
                if (Input.GetKey(bgForwardMove))
                {
                    direction += new Vector3(forward.x, 0f, forward.z) * -moveSpeed;
                }
                if (Input.GetKey(bgUpMove))
                {
                    direction += new Vector3(0f, up.y, 0f) * -moveSpeed;
                }
                if (Input.GetKey(bgDownMove))
                {
                    direction += new Vector3(0f, up.y, 0f) * moveSpeed;
                }

                bg.position += direction;

                if (Input.GetKey(bgLeftRotate))
                {
                    bg.RotateAround(maidTransform.transform.position, Vector3.up, rotateSpeed);
                }
                if (Input.GetKey(bgRightRotate))
                {
                    bg.RotateAround(maidTransform.transform.position, Vector3.up, -rotateSpeed);
                }
            }
        }

        private void LookAtThis()
        {
            if (Input.GetKeyDown(KeyCode.T))
            {
                if (eyeToCamIndex == Enum.GetNames(typeof(Maid.EyeMoveType)).Length - 1)
                {
                    eyetoCamToggle = false;
                    eyeToCamIndex = 0;
                }
                else
                {
                    eyeToCamIndex++;
                    eyetoCamToggle = true;
                }
                maid.EyeToCamera((Maid.EyeMoveType)eyeToCamIndex, 0f);
                Console.WriteLine("EyeToCam:{0}", eyeToCamIndex);

            }



            if (Input.GetKeyDown(KeyCode.G))
            {
                eyetoCamToggle = !eyetoCamToggle;
                //Console.WriteLine("Eye to Cam : {0}", eyetoCamToggle);
                if (!eyetoCamToggle)
                {
                    maid.EyeToCamera(Maid.EyeMoveType.無し, 0f);
                    eyeToCamIndex = 0;
                    Console.WriteLine("EyeToCam:{0}", eyeToCamIndex);
                }
                else
                {
                    maid.EyeToCamera(Maid.EyeMoveType.目と顔を向ける, 0f);
                    eyeToCamIndex = 5;
                    Console.WriteLine("EyeToCam:{0}", eyeToCamIndex);
                }
            }
        }

        private void TimeScaleChanger()
        {
            if (Input.GetKey(KeyCode.At))
            {
                Time.timeScale -= 0.01f;
            }
            if (Input.GetKey(KeyCode.LeftBracket))
            {
                Time.timeScale += 0.01f;
            }
            if (Input.GetKey(KeyCode.P))
            {
                Time.timeScale = 0f;
            }
            if (Input.GetKey(KeyCode.O))
            {
                Time.timeScale = 1f;
            }
        }

        public void Update()
        {
            if (allowUpdate)
            {
                float moveSpeed = floorMoveSpeed;
                float rotateSpeed = maidRotateSpeed;

                if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
                {
                    moveSpeed *= 0.1f;
                    rotateSpeed *= 0.1f;
                }


                //TimeScaleChanger();

                FirstPersonCamera();

                LookAtThis();

                ExtendedCameraHandle();

                FloorMover(moveSpeed, rotateSpeed);

            }
        }
    }
}