static public GameCameraParams Create()
{
GameCameraParams model = (GameCameraParams)ScriptableObject.CreateInstance <GameCameraParams>();
model.name = InitialName;
return(model);
}
public override CameraParams Clone()
{
GameCameraParams param = Create();
param.name = string.Format("{0}(Clone)", name);
param.gameCamera = gameCamera;
param.distance = distance;
param.pitch = pitch;
param.yawOffset = yawOffset;
param.heightOffset = heightOffset;
param.useTargetLocalSpace = useTargetLocalSpace;
param.yawFlipped = yawFlipped;
param.clipNear = clipNear;
return(param);
}
public void SwitchToBattleResultCamera()
{
EB.Debug.Log("[CombatCamera]SwitchToBattleResultCamera");
DisableBlurEffect();
CameraMotion motion = GlobalCameraMotionData.Instance.GetCameraMotion(m_battleResultCameraData);
if (motion != null)
{
List <GameObject> targets = new List <GameObject>();
targets.Add(m_skill_select_lookat_locator);
GameCameraParams gameCameraParams = (GameCameraParams)motion.camera;
CameraLerp motion_lerp = motion.cameraLerpOverride;
EnterInteractionCamera(ref targets, ref gameCameraParams, motion_lerp);
}
}
public void EnterNpcCameraMotion(GameObject target)
{
if (!IsUseCameraEffect)
{
return;
}
List <GameObject> targets = new List <GameObject>();
targets.Add(target);
GameCameraParams gameCameraParams = GlobalCameraData.Instance.FindGameCameraParamsByName("NpcDialogueData");
CameraLerp motion_lerp = GlobalCameraData.Instance.FindGameCameraLerpByName("dialogue lerp"); //npcDialogueCamMotion.cameraLerpOverride
EnterInteractionCamera(ref targets, ref gameCameraParams, motion_lerp);
HideMainMenu();
}
private void OnTriggerExit(Collider collision)
{
if (!playerController._isLocalPlayer)
{
return;
}
GameObject other = collision.gameObject;
string npc_id = other.name;
if (SceneLogicManager.CurrentSceneLogic != null)
{
string scene_name = SceneLogicManager.CurrentSceneLogic.CurrentSceneName;
if (IsFunctionNPC(npc_id, scene_name))
{
if (PlayerController.onCollisionExit != null)
{
PlayerController.CurNpcCollision = null;
PlayerController.onCollisionExit(collision.gameObject.name);
}
}
}
LTCameraTrigger ct = other.GetComponent <LTCameraTrigger>();
if (ct != null)
{
Camera mainCam = getMainCamera();
if (mainCam != null)
{
PlayerCameraComponent pcc = mainCam.GetComponent <PlayerCameraComponent>();
if (pcc != null)
{
//pcc.ResetCameraState();
GameCameraParams gameCameraParams = GlobalCameraData.Instance.FindGameCameraParamsByName("game cam default");
CameraLerp motion_lerp = GlobalCameraData.Instance.FindGameCameraLerpByName("dialogue lerp");
List <GameObject> listGO = new List <GameObject>();
listGO.Add(mDMono.gameObject);
pcc.EnterInteractionCamera(ref listGO, ref gameCameraParams, motion_lerp);
}
}
}
}
public void OnTeamsVictoryListener()
{
if (!string.IsNullOrEmpty(m_teamsSpawnCameraData) && m_teams_victory_lookat_locator != null)
{
CameraMotion motion = GlobalCameraMotionData.Instance.GetCameraMotion(m_teamsSpawnCameraData);
if (motion != null)
{
try
{
// stop lerp back
DOTween.KillAll(true);
}
catch (System.IndexOutOfRangeException e)
{
EB.Debug.LogError(e.ToString());
}
_runningBehaviors.Clear();
List <GameObject> targets = new List <GameObject>();
targets.Add(m_teams_victory_lookat_locator);
GameCameraParams gameCameraParams = (GameCameraParams)motion.camera;
if (gameCameraParams == null)
{
Debug.LogError("OnTeamsVictoryListener gameCameraParams is null");
}
CameraLerp motion_lerp = motion.cameraLerpOverride;
if (motion_lerp == null)
{
Debug.LogError("OnTeamsVictoryListener motion_lerp is null");
}
else
{
motion_lerp.dialogueCameraLerpTime = 5f;
motion_lerp.hangonTime = int.MaxValue;
}
EnterInteractionCamera(ref targets, ref gameCameraParams, motion_lerp);
}
}
}
public void BlendCurrentCamera(ref List <GameObject> targets, float distOffset, float pitchOffset, float yawOffset, float heightOffset, CameraLerp lerp)
{
GameCameraParams param = ScriptableObject.CreateInstance <GameCameraParams>();
if (param == null)
{
EB.Debug.LogError("Failed to create GameCameraParams instance in CombatCamera.BlendCurrentCamera");
}
if (targets == null || targets.Count == 0)
{
return;
}
Vector3 target_pos = GameUtils.CalculateBoundsWithOffset(targets).center;
Vector3 camera_pos = transform.position;
float dist = Vector3.Distance(camera_pos, target_pos);
param.distance = dist + distOffset;
param.pitch = pitchOffset;
param.yawOffset = yawOffset;
param.heightOffset = heightOffset;
EnterInteractionCamera(ref targets, ref param, lerp);
}
public GameCameraBehavior(ref List <GameObject> targets, ref GameCameraParams newParams, CameraBase playerCamera)
{
_targets = targets;
_params = newParams;
SetGameCameraPositionAndRotation(CalculateTargetPosition(), playerCamera);
}
public virtual BlendedCameraBehavior EnterInteractionCamera(ref List <GameObject> targets, ref GameCameraParams gameCamParams, CameraLerp lerp)
{
GameCameraBehavior newGameCamera = new GameCameraBehavior(ref targets, ref gameCamParams, this);
return(AddNewBehavior(newGameCamera, lerp));
}
public override BlendedCameraBehavior EnterInteractionCamera(ref List <GameObject> targets, ref GameCameraParams gameCamParams, CameraLerp lerp)
{
_curCameraMotion = base.EnterInteractionCamera(ref targets, ref gameCamParams, lerp);
//_runningBehaviors[1].behavior.SetRotation(targets[0].transform.rotation);
return(null);
}
// public override void EnterInteractionCamera(ref List<GameObject> targets, ref GameCameraParams gameCamParams, CameraLerp lerp)
public override BlendedCameraBehavior EnterInteractionCamera(ref List <GameObject> targets, ref GameCameraParams gameCamParams, CameraLerp lerp)
{
base.EnterInteractionCamera(ref targets, ref gameCamParams, lerp);
_gameCameraPosition = transform.position;
_gameCameraRotation = transform.rotation;
if (m_lookat_locator != null)
{
_blendedResult.lookAt = m_lookat_locator.transform.position;
Vector3 lookForward = m_lookat_locator.transform.position - transform.position;
lookForward.Normalize();
_blendedResult.rotation = Quaternion.LookRotation(lookForward);
_blendedResult.distFromLookAt = Vector3.Distance(transform.position, m_lookat_locator.transform.position);
}
MainCamera.nearClipPlane = gameCamParams.clipNear;//增加对摄像机近裁剪面的控制
State = MotionState.Lerping;
return(null);
}
private void OnTriggerEnter(Collider collision)
{
if (!playerController._isLocalPlayer || SceneLogicManager.CurrentSceneLogic == null)
{
return;
}
GameObject other = collision.gameObject;
string npc_id = other.name;
string scene_name = SceneLogicManager.CurrentSceneLogic.CurrentSceneName;
if (IsFunctionNPC(npc_id, scene_name))
{
if (HasUIModel(npc_id, scene_name, "DeliveryDart") && AlliancesManager.Instance.DartData.State == eAllianceDartCurrentState.Transfering)
{
GlobalMenuManager.Instance.CloseMenu("LTApplyHelpUI");
NpcColliderUI.DeliveryDart();
}
else
{
var ht = Johny.HashtablePool.Claim();
ht.Add("npc", npc_id);
ht.Add("scene", scene_name);
MainLandEncounterTemplate met = SceneTemplateManager.GetMainLandsNPCData(scene_name, npc_id);
if (met.role == "area")
{
ht.Add("area", true);
}
if (PlayerController.onCollisionOpen != null)
{
PlayerController.CurNpcCollision = collision;
PlayerController.onCollisionOpen(ht);
}
}
LTCameraTrigger ct = other.GetComponent <LTCameraTrigger>();
if (ct != null)
{
Camera mainCam = getMainCamera();
if (mainCam != null)
{
PlayerCameraComponent pcc = mainCam.GetComponent <PlayerCameraComponent>();
if (pcc != null)
{
if (!string.IsNullOrEmpty(ct.triggerGameCameraParamName))
{
GameCameraParams gameCameraParams = GlobalCameraData.Instance.FindGameCameraParamsByName(ct.triggerGameCameraParamName);
CameraLerp motion_lerp = GlobalCameraData.Instance.FindGameCameraLerpByName("dialogue lerp");
List <GameObject> listGO = new List <GameObject>();
listGO.Add(mDMono.gameObject);
pcc.EnterInteractionCamera(ref listGO, ref gameCameraParams, motion_lerp);
}
}
}
else
{
GameObject cam = GameObject.Find("Main Camera");
if (cam != null)
{
PlayerCameraComponent pcc = cam.GetComponent <PlayerCameraComponent>();
if (pcc != null)
{
EB.Debug.Log("Can Find Main Camera!");
if (!string.IsNullOrEmpty(ct.triggerGameCameraParamName))
{
GameCameraParams gameCameraParams = GlobalCameraData.Instance.FindGameCameraParamsByName(ct.triggerGameCameraParamName);
CameraLerp motion_lerp = GlobalCameraData.Instance.FindGameCameraLerpByName("dialogue lerp");
List <GameObject> listGO = new List <GameObject>();
listGO.Add(mDMono.gameObject);
pcc.EnterInteractionCamera(ref listGO, ref gameCameraParams, motion_lerp);
}
}
}
}
}
}
else if (other.name.Equals("NPCSpawns_F")) //与决斗场模型碰撞，需移动到出生点
{
playerController.transform.position = SceneManager.HeroStart; //如果是角斗场雕像，跳转到初始位置
}
else
{
LTCameraTrigger ct = other.GetComponent <LTCameraTrigger>();
if (ct != null)
{
Camera mainCam = getMainCamera();//Camera.main;
if (mainCam != null)
{
PlayerCameraComponent pcc = mainCam.GetComponent <PlayerCameraComponent>();
if (pcc != null)
{
if (!string.IsNullOrEmpty(ct.triggerGameCameraParamName))
{
GameCameraParams gameCameraParams = GlobalCameraData.Instance.FindGameCameraParamsByName(ct.triggerGameCameraParamName);
CameraLerp motion_lerp = GlobalCameraData.Instance.FindGameCameraLerpByName("dialogue lerp");
List <GameObject> listGO = new List <GameObject>();
listGO.Add(mDMono.gameObject);
pcc.EnterInteractionCamera(ref listGO, ref gameCameraParams, motion_lerp);
}
}
}
}
}
}
// turn on the type of camera we need for this conversation step
static public void SetUpNewCamera(Dialogue.DialogueData.DialoguePointCamera conversation, CharacterModel inputCaller, List <Dialogue.DialogueData.DialoguePoint> dialoguePoints)
{
if (null == conversation.camera)
{
return;
}
CameraLerp cameraLerp = (null != conversation.cameraLerpOverride) ? conversation.cameraLerpOverride : GlobalDialogueData.Instance.defaultDialogueLerp;
System.Type cameraType = conversation.camera.GetType();
if (typeof(GameCameraParams) == cameraType)
{
if (null != Camera.main)
{
CameraBase cameraComponent = Camera.main.GetComponent <CameraBase>();
GameCameraParams gameCameraParams = (GameCameraParams)conversation.camera;
switch (conversation.targets)
{
case Dialogue.DialogueData.DialoguePointCamera.CameraTargets.localPlayer:
if (gameCameraParams.gameCamera)
{
cameraComponent.EnterFixedOffsetGameCamera(cameraLerp);
}
else
{
PlayerController controller = PlayerManager.LocalPlayerController();
if (null != controller)
{
List <GameObject> target = new List <GameObject>();
target.Add(controller.gameObject);
cameraComponent.EnterInteractionCamera(ref target, ref gameCameraParams, cameraLerp);
}
}
break;
case Dialogue.DialogueData.DialoguePointCamera.CameraTargets.all:
List <GameObject> targets = new List <GameObject>();
Interaction.GetAllInteractionParticipants(ref targets, dialoguePoints);
if (targets.Count > 0)
{
cameraComponent.EnterInteractionCamera(ref targets, ref gameCameraParams, cameraLerp);
}
break;
case Dialogue.DialogueData.DialoguePointCamera.CameraTargets.caller:
GameObject caller = GlobalUtils.FindCharacter(inputCaller);
if (null != caller)
{
if (inputCaller.isPlayer && gameCameraParams.gameCamera)
{
cameraComponent.EnterFixedOffsetGameCamera(cameraLerp);
}
else
{
List <GameObject> target = new List <GameObject>();
target.Add(caller);
cameraComponent.EnterInteractionCamera(ref target, ref gameCameraParams, cameraLerp);
}
}
break;
default: break;
}
}
}
else if (typeof(CinematicCameraParams) == cameraType)
{
if (null != conversation.cinematic)
{
if (conversation.IsCinematicAPrefabRequiringInstantiation())
{
GameObject cinematicObject = (GameObject)GameObject.Instantiate(conversation.cinematic);
if (null != cinematicObject && cinematicObject.activeInHierarchy)
{
Cinematic.Play(cinematicObject.GetComponent <Cinematic>(), PlayerManager.LocalPlayerGameObject());
}
}
else
{
Cinematic.Play(conversation.cinematic.GetComponent <Cinematic>(), PlayerManager.LocalPlayerGameObject());
}
}
}
}
public void Play()
{
_played = true;
//CameraMotionEventProperties info = _event._cameraMotionProperties;
//if(info._motionTarget == CameraMotionTarget.OriginView)
//{
//m_target_pos = CameraMotionPreviewManager.Instance.OriginPos;
//m_target_angle = CameraMotionPreviewManager.Instance.OriginAngle;
//}
//else
{
//Vector3 pos_offset = info._posOffset;
//if(info._useLocalOffset)
//{
//m_target_pos = _focusObject.transform.TransformPoint(pos_offset);
//}
//else
//{
//m_target_pos = _focusObject.transform.position + pos_offset;
//}
//m_target_angle = info._targetAngle;
}
//CombatCamera combat_camera = CameraMotionPreviewManager.Instance._previewCamera;
//if(combat_camera != null)
//{
// //combat_camera.OnCameraMotion(m_target_pos, m_target_angle, info._lerpCurve, info._lerpDuration);
//}
MoveEditor.CameraMotionEventInfo info = _event;
MoveEditor.CameraMotionEventProperties motionProps = info._cameraMotionProperties;
//if (motionProps._motionTrigger == MoveEditor.CameraMotionTrigger.LocalPlayerOnly)
//{
// if (Index.TeamIndex != CombatLogic.Instance.LocalPlayerTeamIndex)
// {
// return;
// }
//}
//else if (motionProps._motionTrigger == MoveEditor.CameraMotionTrigger.EnemyOnly)
//{
// if (CombatLogic.Instance.IsPlayerOrChallengerSide(Data.TeamId))
// {
// return;
// }
// //if (!Data.IsEnemy)
// //{
// // return;
// //}
//}
if (Camera.main != null)
{
CombatCamera combat_camera = Camera.main.GetComponent <CombatCamera>();
//if (!combat_camera.m_enablePlayerOrChallengerMotion && CombatLogic.Instance.IsPlayerOrChallengerSide(Index.TeamIndex))
//{
// return;
//}
//if (!combat_camera.m_enableOpponentMotion && CombatLogic.Instance.IsOpponentSide(Index.TeamIndex))
//{
// return;
//}
string camera_motion_json = motionProps._motionOptions;
List <MoveEditor.CameraMotionOption> options = GM.JSON.ToObject <List <MoveEditor.CameraMotionOption> >(camera_motion_json);
List <GameObject> targets = new List <GameObject>();
if (motionProps._motionTarget == MoveEditor.CameraMotionTarget.Attacker)
{
targets.Add(_previewGameObject);
}
else if (motionProps._motionTarget == MoveEditor.CameraMotionTarget.Defenders)
{
targets.Add(_previewHitGameObject);
}
else if (motionProps._motionTarget == MoveEditor.CameraMotionTarget.All)
{
targets.Add(_previewGameObject);
targets.Add(_previewHitGameObject);
}
else if (motionProps._motionTarget == MoveEditor.CameraMotionTarget.DefendersCameraAnchor)
{
//Debug.LogError("现在不支持DefendersCameraAnchor这种类型");
//GameObject anchor = CombatEventReceiver.Instance.defenderSide.Find(CombatEventReceiver.Instance.defenderFormation + "/f2").gameObject;
//if (anchor != null)
//{
// targets.Add(anchor);
//}
//else
//{
// EB.Debug.LogError("Combatant.OnCameraMotion Can not find DefendersCameraAnchor GameObject");
// return;
//}
}
if (combat_camera != null)
{
if (motionProps._blendCurrentCamera)
{
if (motionProps._onlyLookAtTarget)
{
combat_camera.CurrentCameraLookAt(ref targets, motionProps._hangonDuration);
}
else
{
CameraLerp lerp = CameraLerp.Create();
lerp.lerpStyle = CameraLerp.LerpStyle.determineAtRunTime;
lerp.dialogueCameraLerpSmoothing = motionProps._blendLerpSmoothing;
lerp.animationCurve = motionProps._blendLerpCurve;
lerp.dialogueCameraLerpTime = motionProps._lerpDuration;
lerp.pitchLerpSmoothing = motionProps._blendPitchLerpSmoothing;
lerp.curvePitchLerp = motionProps._blendPitchLerpCurve;
lerp.yawLerpSmoothing = motionProps._blendYawLerpSmoothing;
lerp.curveYawLerp = motionProps._blendYawLerpCurve;
lerp.hangonTime = motionProps._hangonDuration;
combat_camera.BlendCurrentCamera(ref targets, motionProps._blendDistanceOffset, motionProps._blendPitchOffset,
motionProps._blendYawOffset, motionProps._blendHeightOffset, lerp);
}
}
else
{
//int count = options.Count;
MoveEditor.CameraMotionOption option = MoveEditor.MoveUtils.GetCamermotionLottery(ref options, false);
if (option != null)
{
//Debug.LogError("OnCameraMotion != null cbt=" + Data.ToString());
CameraMotion motion = GlobalCameraMotionData.Instance.GetCameraMotion(option._motionName);
if (motion != null)
{
combat_camera.State = CombatCamera.MotionState.Lerping;
//MyFollowCamera.Instance.isActive = false;
GameCameraParams gameCameraParams = (GameCameraParams)motion.camera;
CameraLerp motion_lerp = motion.cameraLerpOverride;
motion_lerp.dialogueCameraLerpTime = motionProps._lerpDuration;
motion_lerp.hangonTime = motionProps._hangonDuration;
combat_camera.EnterInteractionCamera(ref targets, ref gameCameraParams, motion_lerp);
}
}
}
}
}
}
