public void Set(Character character)
{
if (character.currentLevel != level)
{
return;
}
if (character.characterCamera == null)
{
return;
}
CharacterCamera characterCamera = character.characterCamera;
characterCamera.minPosition = cameraMin;
characterCamera.maxPosition = cameraMax;
if (positionMin != Vector2.zero)
{
character.positionMin = positionMin;
}
if (positionMax != Vector2.zero)
{
character.positionMax = positionMax;
}
if (charactersHit.Count == 0)
{
initialHitEvent.Invoke();
}
charactersHit.Add(character);
character.characterCamera.cameraZone = this;
}
// ========================================================================
public virtual void Start()
{
rollingModeGroup.gameObject.SetActive(false);
groundModeGroup.gameObject.SetActive(false);
rollingAirModeGroup.gameObject.SetActive(false);
airModeGroup.gameObject.SetActive(false);
foreach (CharacterCapability capability in capabilities)
{
capability.StateInit(stateCurrent, "");
}
if (isLocalPlayer)
{
characterCamera = Instantiate(cameraPrefab).GetComponent <CharacterCamera>();
characterCamera.character = this;
characterCamera.UpdateDelta(0);
ObjTitleCard titleCard = ObjTitleCard.Make(this);
hud = Instantiate(hudPrefab).GetComponent <HUD>();
hud.character = this;
hud.Update();
}
respawnData.position = position;
Respawn();
}
static void CharacterCamera_LateUpdate_Post(CharacterCamera __instance)
{
if (__instance.m_targetCharacter.TargetingSystem.LockedCharacter != null)
{
__instance.m_cameraVertHolder.rotation *= Quaternion.Euler(_targetingPitchOffset, 0, 0);
}
}
void Start()
{
dashTimer = dashDelay;
controller = GetComponent <CharacterController>();
camera = cameraGO.GetComponent <CharacterCamera>();
headAimScript = player.GetComponent <HeadAim>();
playerAnimator = player.GetComponent <Animator>();
}
void OnJoinedRoom()
{
GameObject Character = PhotonNetwork.Instantiate("Character", Vector3.zero, Quaternion.identity, 0);
CharacterControl controller = Character.GetComponent <CharacterControl>();
controller.enabled = true;
CharacterCamera camera = Character.GetComponent <CharacterCamera>();
camera.enabled = true;
}
/// <summary>
/// Constructs the character and internal physics character controller.
/// </summary>
/// <param name="owningSpace">Space to add the character to.</param>
/// <param name="CameraToUse">Camera to attach to the character.</param>
public CharacterControllerInput(Space owningSpace, CharacterCamera CameraToUse, Vector3 position)
{
CharacterController = new CharacterController(position);
Space = owningSpace;
Space.Add(CharacterController);
Camera = CameraToUse;
Deactivate();
}
public CameraService(Contexts contexts) : base(contexts)
{
_context = contexts as GameContext;
_cameraData = Data.CameraData;
CharacterCamera = _cameraData._cameraSettings.CreateCharacterCamera();
CameraCinemachineBrain = CharacterCamera.GetComponent <CinemachineBrain>() ?? null;
#if (UNITY_EDITOR)
EditorApplication.playModeStateChanged += SaveCameraSettings;
#endif
}
protected override void Awake()
{
base.Awake();
_character = GameObject.FindGameObjectWithTag("Player").transform;
UnityCamera = Camera.main ?? FindObjectOfType <Camera>();
if (UnityCamera != null)
{
CameraTransform = UnityCamera.transform;
}
_fpsCam = FindObjectOfType <CharacterCamera>();
_orbitCam = FindObjectOfType <AnimOrbitCam>();
_activeCam = _fpsCam;
}
public override void OnJoinedRoom()
{
GameObject monster = PhotonNetwork.Instantiate("monsterprefab", Vector3.zero, Quaternion.identity, 0);
CharacterControl controller = monster.GetComponent <CharacterControl> ();
Debug.Log(controller.enabled);
controller.enabled = true;
CharacterCamera camera = monster.GetComponent <CharacterCamera> ();
Debug.Log(camera.enabled);
camera.enabled = true;
//monster.GetComponent<myThirdPersonController>().isControllable = true;
}
private CharacterCamera characterCamera; //wanted to not put this in, but it seems necessary in order to make this work
// Use this for initialization
void Start()
{
if (lockOnWhenNear)
{
CreateArmor();
}
if (lockOnWhenNear)
{
CreateTracker();
}
characterCamera = GetComponentInChildren <CharacterCamera>();
}
//Called when any user only joined the room
void OnJoinedRoom()
{
Debug.Log("Joined the room");
GameObject monster = PhotonNetwork.Instantiate("monsterprefab", Vector3.zero, Quaternion.identity, 0);
Debug.Log("Instantiate the gameobject");
CharacterControl controller = monster.GetComponent <CharacterControl>();
controller.enabled = true;
CharacterCamera camera = monster.GetComponent <CharacterCamera>();
camera.enabled = true;
}
private void Awake()
{
if (Instance == null)
{
Instance = this;
}
UIController = FindObjectOfType <MapUiController>();
UIController.GetComponent <CanvasGroup>().alpha = 1;
var mapInfo = Core.NetworkClient.State.MapLoginInfo;
if (mapInfo == null)
{
throw new Exception("Map Login info cannot be null");
}
Core.NetworkClient.HookPacket(ZC.NOTIFY_STANDENTRY11.HEADER, OnEntitySpawn);
Core.NetworkClient.HookPacket(ZC.NOTIFY_NEWENTRY11.HEADER, OnEntitySpawn);
Core.NetworkClient.HookPacket(ZC.NOTIFY_MOVEENTRY11.HEADER, OnEntitySpawn);
Core.NetworkClient.HookPacket(ZC.NOTIFY_VANISH.HEADER, OnEntityVanish);
Core.NetworkClient.HookPacket(ZC.NOTIFY_MOVE.HEADER, OnEntityMovement); //Others movement
Core.NetworkClient.HookPacket(ZC.NPCACK_MAPMOVE.HEADER, OnEntityMoved);
Core.NetworkClient.HookPacket(ZC.HP_INFO.HEADER, OnEntityHpChanged);
Core.NetworkClient.HookPacket(ZC.STOPMOVE.HEADER, OnEntityMovement);
Core.NetworkClient.HookPacket(ZC.NOTIFY_EFFECT2.HEADER, OnEffect);
Core.NetworkClient.HookPacket(ZC.RESURRECTION.HEADER, OnEntityResurrected);
Core.NetworkClient.HookPacket(ZC.SPRITE_CHANGE2.HEADER, OnSpriteChanged);
Core.NetworkClient.HookPacket(ZC.ACTION_FAILURE.HEADER, OnActionFailure);
Core.Instance.InitManagers();
Core.Instance.InitCamera();
Core.Instance.SetWorldLight(worldLight);
Core.Instance.BeginMapLoading(mapInfo.mapname);
//var entity = Core.EntityManager.SpawnPlayer(Core.NetworkClient.State.SelectedCharacter);
//Core.Session = new Session(entity, Core.NetworkClient.State.LoginInfo.AccountID);
//Core.Session.SetCurrentMap(mapInfo.mapname);
var entity = Session.CurrentSession.Entity as Entity;
entity.transform.position = new Vector3(mapInfo.PosX, Core.PathFinding.GetCellHeight(mapInfo.PosX, mapInfo.PosY), mapInfo.PosY);
/**
* Hack
*/
CharacterCamera charCam = GameObject.FindObjectOfType <CharacterCamera>();
charCam.SetTarget(entity.EntityViewer.transform);
entity.SetReady(true);
}
public static bool Prefix(CharacterCamera __instance, ref Vector2 ___m_cameraSmoothAutoInput, ref Vector2 ___m_cameraSmoothInput,
bool ___m_invertedVer, bool ___m_invertedHor, ref Vector2 ___m_smoothCameraInput, Transform ___m_cameraVertHolder, Transform ___m_horiControl,
Transform ___m_vertControl, CameraShaker ___m_shaker)
{
if (DisableMouseSmoothingMod.Enabled)
{
Override(__instance, ref ___m_cameraSmoothAutoInput, ref ___m_cameraSmoothInput, ___m_invertedVer, ___m_invertedHor,
ref ___m_smoothCameraInput, ___m_cameraVertHolder, ___m_horiControl, ___m_vertControl, ___m_shaker);
return(false);
}
return(true);
}
public virtual void Awake()
{
// must be on Awake because of Initialization Timing
_characterStats = new CharacterStats();
_characterStats.GetDataFromCharacterClass(_characterClass);
_characterHPMPManager = GetComponent <CharacterHPMPManager>();
_characterHPMPManager.InitializeLinkCharacter(this);
_characterLevelManager = GetComponent <CharacterLevelManager>();
_characterLevelManager?.Initialize(this);
_battleAI = GetComponent <BattleAI>();
_characterAbilities = GetComponent <CharacterAbilities>();
_characterAbilities?.InitializeCharacterAbilities();
_characterCamera = GetComponentInChildren <CharacterCamera>();
_characterBattleAnimator = GetComponentInChildren <CharacterBattleAnimator>();
}
private void Awake()
{
life = MaxLife;
// Setting up references.
groundCheck = transform.Find("GroundCheck");
ceilingCheck = transform.Find("CeilingCheck");
anim = GetComponent <Animator>();
rb = GetComponent <Rigidbody2D>();
kamehamehas = new Pool <Bullet>(kamehameha, 8, 16);
kamehamehas.automaticReuseUnavailables = true;
tornados = new Pool <Bullet>(special_tornado, 4, 8);
tornados.automaticReuseUnavailables = true;
cam = Camera.main.GetComponent <CharacterCamera>();
audio_process = AudioProcessor.Instance;
Enemy_manager = EnemyManager.Instance;
Bonus_manager = BonusManager.Instance;
}
public static void Postfix(
CharacterCamera __instance,
Transform ___m_cameraVertHolder
)
{
var self = __instance;
float targetAngle = -90;
float rotationAmount = ModConfig.offCenterAmount.Value;
Vector3 targetPosition = new Vector3(
self.LookAtTransform.transform.position.x,
self.LookAtTransform.transform.position.y,
self.LookAtTransform.transform.position.z
);
Vector3 playerPosition = new Vector3(
self.TargetCharacter.transform.position.x,
self.TargetCharacter.transform.position.y,
self.TargetCharacter.transform.position.z
);
if (self.LookAtTransform != null || self.OverrideTransform != null)
{
Vector3 targetDirection = targetPosition - playerPosition;
float angle = Vector3.Angle(targetDirection, self.TargetCharacter.transform.forward);
if (angle < targetAngle)
{
___m_cameraVertHolder.Rotate(-rotationAmount, 0f, 0f);
}
else if (angle > targetAngle)
{
___m_cameraVertHolder.Rotate(rotationAmount, 0f, 0f);
}
}
}
public void Update()
{
if ((LevelManager.current != null) && (LevelManager.current.characters.Count != 1))
{
stopTime = false;
}
if (canvas.worldCamera == null)
{
CharacterCamera characterCamera = FindObjectOfType <CharacterCamera>();
if (characterCamera != null)
{
canvas.worldCamera = characterCamera.camera;
}
else
{
canvas.worldCamera = FindObjectOfType <Camera>();
}
}
if (stopTime)
{
Time.timeScale = 0;
}
if (isComplete && destroyWhenDone && (destroyDelay > 0))
{
destroyDelay -= Utils.cappedUnscaledDeltaTime;
if (destroyDelay <= 0)
{
Complete();
Destroy(gameObject);
return;
}
}
material.SetFloat("_Brightness", brightness);
material.SetFloat("_RedOffset", redOffset);
material.SetFloat("_GreenOffset", greenOffset);
material.SetFloat("_BlueOffset", blueOffset);
if (fadeDelay > 0)
{
fadeDelay -= Utils.cappedUnscaledDeltaTime;
return;
}
if (fadeSpeed == 0)
{
return;
}
brightness += fadeSpeed * Utils.cappedUnscaledDeltaTime;
if ((fadeSpeed > 0) && (brightness >= brightnessMax))
{
Complete();
}
if ((fadeSpeed < 0) && (brightness <= brightnessMin))
{
Complete();
}
}
void Start()
{
anim = GetComponent <Animator>();
chCamera = GameObject.Find("MainCamera").GetComponent <CharacterCamera>();
}
public static bool Prefix(CharacterCamera __instance)
{
Override(__instance);
return(false);
}
void Start()
{
// Only enable sound and camera for player if it's the local player
if (isLocalPlayer) {
// Disable and Enable Cameras / AudioListener
try { GameObject.Find("Main Camera").SetActive(false); }
catch { }
characterCam.enabled = true;
audioListener.enabled = true;
//characterCam.transform.GetChild(0).GetComponent<Camera>().enabled = true;
//m_MouseLook.Init(transform, characterCam.transform);
}
cam = characterCam.GetComponent<CharacterCamera>();
stats = GetComponent<PlayerStats>();
Speed = stats ? stats.speed : Speed; // Only use speed from playerStats if it is not null
animNetwork = GetComponent<NetworkAnimator>();
animLocal = GetComponent<Animator>();
playerBehaviour = GetComponent<PlayerBehaviour>();
}
static private int GetPlayerID(CharacterCamera characterCamera) => characterCamera.TargetCharacter.OwnerPlayerSys.PlayerID;
void Start()
{
camera = cameraGO.GetComponent <CharacterCamera>();
//headAimScript = player.GetComponent<HeadAim>();
playerAnimator = player.GetComponent <Animator>();
}
internal static void Override(CharacterCamera __instance, ref Vector2 ___m_cameraSmoothAutoInput, ref Vector2 ___m_cameraSmoothInput,
bool ___m_invertedVer, bool ___m_invertedHor, ref Vector2 ___m_smoothCameraInput, Transform ___m_cameraVertHolder, Transform ___m_horiControl,
Transform ___m_vertControl, CameraShaker ___m_shaker)
{
if (__instance.TargetCharacter == null || !NetworkLevelLoader.Instance.IsOverallLoadingDone || MenuManager.Instance.IsReturningToMainMenu)
{
return;
}
if (__instance.transform.position.y < -500f)
{
__instance.CameraScript.farClipPlane = 200f;
}
else
{
__instance.CameraScript.farClipPlane = 26000f;
}
float delta = Time.deltaTime;
if (delta > 0.04f)
{
delta = 0.04f;
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// CHANGE: Removed ' * 0.5f ' from the RotateCameraVertical value.
Vector2 cameraMove = new Vector2(ControlsInput.RotateCameraHorizontal(__instance.TargetCharacter.OwnerPlayerSys.PlayerID),
ControlsInput.RotateCameraVertical(__instance.TargetCharacter.OwnerPlayerSys.PlayerID)); // * 0.5f));
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (__instance.TargetCharacter.CharacterUI)
{
float mouseSens = OptionManager.Instance.GetMouseSense(__instance.TargetCharacter.OwnerPlayerSys.PlayerID);
mouseSens /= 5f;
cameraMove *= mouseSens;
}
cameraMove.x = Mathf.Clamp(cameraMove.x, -30f, 30f);
cameraMove.y = Mathf.Clamp(cameraMove.y, -20f, 20f);
// Controller smoothing
if (ControlsInput.IsLastActionGamepad(__instance.TargetCharacter.OwnerPlayerSys.PlayerID))
{
if (cameraMove == Vector2.zero)
{
Vector3 targetPos = Vector3.zero;
if (!__instance.TargetCharacter.IsDead)
{
targetPos = __instance.TargetCharacter.transform.TransformVector(new Vector3(__instance.TargetCharacter.AnimMove.x,
0f,
__instance.TargetCharacter.AnimMove.y));
}
targetPos = __instance.transform.InverseTransformVector(targetPos);
float angle = Vector3.forward.AngleWithDir(targetPos, Vector3.up);
Vector2 lerpTo = Vector2.zero;
if (Mathf.Abs(angle) > 15f)
{
if (angle > 0f && angle < 30f)
{
angle = Mathf.Clamp(angle * 1.5f, 20f, 40f);
}
else if (angle > -30f && angle < 0f)
{
angle = Mathf.Clamp(angle * 1.5f, -20f, -40f);
}
angle /= 360f;
angle *= targetPos.magnitude;
lerpTo.x = angle * 0.3f;
}
float t = (lerpTo.magnitude < 0.1f)
? (Time.deltaTime * 5f)
: Mathf.Clamp(Time.deltaTime * 1f, 0f, 0.1f);
___m_cameraSmoothAutoInput = Vector2.Lerp(___m_cameraSmoothAutoInput, lerpTo, t);
}
else
{
___m_cameraSmoothAutoInput = Vector2.Lerp(___m_cameraSmoothAutoInput, Vector2.zero, Time.deltaTime * 20f);
}
cameraMove += ___m_cameraSmoothAutoInput;
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// CHANGE: Commenting out these next two lines:
//___m_cameraSmoothInput = Vector2.Lerp(___m_cameraSmoothInput, cameraMove, Mathf.Clamp(Time.deltaTime * 20f, 0f, 0.6f));
//cameraMove = ___m_cameraSmoothInput;
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (Global.ListenToDebugInput && Input.GetKeyDown(KeyCode.KeypadPeriod))
{
OptionManager.Instance.ChangeInvertMouseY(__instance.TargetCharacter.OwnerPlayerSys.PlayerID, !___m_invertedVer);
}
cameraMove.y *= (float)(___m_invertedVer ? -1 : 1);
cameraMove.x *= (float)(___m_invertedHor ? -1 : 1);
if (__instance.LookAtTransform != null)
{
cameraMove *= 0.1f;
}
if (__instance.InZoomMode)
{
cameraMove *= __instance.ZoomSensModifier;
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// CHANGE: Commenting out these next three lines:
//___m_smoothCameraInput = Vector2.Lerp(___m_smoothCameraInput, cameraMove, 15f * delta);
//___m_smoothCameraInput = Vector2.MoveTowards(___m_smoothCameraInput, cameraMove, 5f * delta);
//cameraMove = ___m_smoothCameraInput;
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
cameraMove *= ((__instance.LookAtTransform == null)
? __instance.FreeSense
: __instance.LockedSense) * (ControlsInput.IsLastActionGamepad(__instance.TargetCharacter.OwnerPlayerSys.PlayerID)
? delta
: 0.016f);
__instance.transform.Rotate(new Vector3(0f, cameraMove.x, 0f));
___m_cameraVertHolder.Rotate(new Vector3(-cameraMove.y, 0f, 0f));
// Vertical position / Lock-on
if (__instance.LookAtTransform != null || __instance.OverrideTransform != null)
{
Vector3 vertPosition;
if (!__instance.OverrideTransform)
{
Vector3 position = __instance.LookAtTransform.transform.position;
position.y -= 0.8f;
float diffToPlayer = Mathf.Abs(__instance.LookAtTransform.transform.position.y - __instance.transform.position.y);
float diffToTarget = Mathf.Abs(__instance.LookAtTransform.transform.position.y - __instance.TargetCharacter.transform.position.y);
float normalize = Mathf.Clamp(diffToPlayer * 0.5f, 1f, 10f);
vertPosition = position - __instance.transform.position;
float yCurve = __instance.YMinMaxCurve.Evaluate(Vector3.Distance(__instance.TargetCharacter.transform.position,
__instance.LookAtTransform.transform.position) * 0.1f);
float yNormalize = (diffToTarget < 5f) ? __instance.YMinMaxYDiffCurve.Evaluate(diffToTarget) : 1f;
yCurve *= yNormalize;
vertPosition.y = Mathf.Clamp(vertPosition.y, -yCurve * normalize, yCurve * normalize);
vertPosition.y -= 0.5f;
}
else
{
vertPosition = __instance.OverrideTransform.forward;
}
float vertAngle = Vector3.Angle(___m_cameraVertHolder.forward, vertPosition);
___m_cameraVertHolder.forward = Vector3.MoveTowards(___m_cameraVertHolder.forward,
vertPosition,
(__instance.RotSpeeds.x + vertAngle * __instance.RotSpeeds.y) * Time.deltaTime);
__instance.transform.rotation = Quaternion.Euler(0f, ___m_cameraVertHolder.rotation.eulerAngles.y, 0f);
}
Vector3 diffToVert = __instance.transform.InverseTransformDirection(___m_cameraVertHolder.forward);
float diffAngle = new Vector2(diffToVert.z, diffToVert.y).Angle(new Vector2(1f, 0f));
float normalizedAngle = 75f;
if (Mathf.Abs(diffAngle) > normalizedAngle)
{
normalizedAngle = (diffAngle > 0f)
? normalizedAngle
: (-normalizedAngle);
___m_cameraVertHolder.Rotate(diffAngle - normalizedAngle, 0f, 0f, Space.Self);
}
___m_cameraVertHolder.localRotation = Quaternion.Euler(___m_cameraVertHolder.localRotation.eulerAngles.x, 0f, 0f);
___m_horiControl.transform.rotation = __instance.transform.rotation;
___m_vertControl.transform.rotation = ___m_cameraVertHolder.rotation;
if (___m_shaker && !Global.GamePaused)
{
___m_shaker.RealPosition = __instance.CameraScript.transform.localPosition;
___m_shaker.RealRotation = Quaternion.identity;
}
if (s_updateZoomMethod == null)
{
s_updateZoomMethod = typeof(CharacterCamera).GetMethod("UpdateZoom", BindingFlags.NonPublic | BindingFlags.Instance);
}
s_updateZoomMethod.Invoke(__instance, new object[0]);
}
static public bool TryGetLocal(CharacterCamera characterCamera, out Data player) => TryGetLocal(GetPlayerID(characterCamera), out player);
void OnDisable()
{
instance = null;
}
void Start()
{
chCamera = GameObject.Find("MainCamera").GetComponent <CharacterCamera>();
}
static public Data GetLocal(CharacterCamera characterCamera) => GetLocal(GetPlayerID(characterCamera));
private void Awake()
{
life = MaxLife;
// Setting up references.
groundCheck = transform.Find("GroundCheck");
ceilingCheck = transform.Find("CeilingCheck");
anim = GetComponent<Animator>();
rb = GetComponent<Rigidbody2D>();
kamehamehas = new Pool<Bullet>(kamehameha, 8, 16);
kamehamehas.automaticReuseUnavailables = true;
tornados = new Pool<Bullet>(special_tornado, 4, 8);
tornados.automaticReuseUnavailables = true;
cam = Camera.main.GetComponent<CharacterCamera>();
audio_process = AudioProcessor.Instance;
Enemy_manager = EnemyManager.Instance;
Bonus_manager = BonusManager.Instance;
}
void Start()
{
cameraScript = cameraGO.GetComponent <CharacterCamera>();
}
