private void Awake()
{
if (Instance == null)
Instance = this;
charStateScript = GameObject.FindObjectOfType<CharState> ();
camScript = GameObject.FindObjectOfType<ThirdPersonCamera> ();
}
// Use this for initialization
void Start()
{
cam = GameObject.FindGameObjectWithTag("MainCamera").GetComponent<ThirdPersonCamera>();
gazeData = GetComponent<GazePointDataComponent>();
if (!gazeData)
{
gazeData = new GazePointDataComponent();
}
}
private void Start()
{
CamTransform = transform;
cam = Camera.main;
if (!instance)
{
instance = this;
}
LookAt = GameManager.gm.mainPlayer.transform;
}
/// <summary>
/// 初始
/// </summary>
public void Init()
{
Messenger.AddListener(MessengerConst.OnCutsceneMovieBegin, OnCutsceneMovieBegin);
LinkCamera();
// m_bDirty = true;
m_ThirdPersonCamera = new ThirdPersonCamera();
m_ThirdPersonCamera.Init();
m_CurrentCamera = m_ThirdPersonCamera;
// m_EffectRenderTexture = new SynRenderTexture();
// m_EffectRenderTexture.Init();
}
private Vector3 GetTargetOriginPosition()
{
ThirdPersonCamera thirdPersonCamera = m_viewerCamera as ThirdPersonCamera;
if (thirdPersonCamera != null)
{
return((thirdPersonCamera.GetThirdPersonTarget() as Component).ComponentTranslation);
}
else
{
return(m_viewerCamera.GetEyeVector());
}
}
//This built-in function will be called after the script first time loaded into the scene
void Start()
{
isMove = false;
isRun = false;
Cursor.visible = false;
controller = GetComponent <CharacterController>();
anim = GetComponent <Animator>();
cam = transform.GetChild(2).GetComponentInChildren <ThirdPersonCamera>();
ispeed = speed;
}
public Vector3 GetPlayerRotation()
{
foreach (Transform child in player.transform)
{
ThirdPersonCamera camera = child.gameObject.GetComponent <ThirdPersonCamera>();
if (camera != null)
{
return(camera.transform.eulerAngles);
}
}
return(Vector3.forward); // default
}
protected override void Update(GameTime gameTime)
{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
{
Exit();
}
bool colisão1 = false;
bool colisão2 = false;
float raiotank1 = 2f, raiotank2 = 2f;
SurfaceFollowCamera.Update(GraphicsDevice, gameTime, field, tank, CameraType.SurfaceFollow);
ThirdPersonCamera.Update(GraphicsDevice, gameTime, field, tank, CameraType.ThirdPerson);
tank.Update(field, ChooseTank.tank, bullet, gameTime);
enemyTank.EnemyUpdate(tank.position, tank.direction, field, gameTime);
if (bullet.isShooting == true)
{
bullet.Update(gameTime);
}
colisão1 = tank.Colisão(tank.position, enemyTank.position, raiotank1, raiotank2);
colisão2 = tank.Colisão(enemyTank.position, tank.position, raiotank1, raiotank2);
if (colisão1 == false)
{
positionBack1 = tank.position;
}
else if (colisão1 == true)
{
tank.position = positionBack1;
}
if (colisão2 == false)
{
positionBack2 = enemyTank.position;
}
else if (colisão2 == true)
{
enemyTank.position = positionBack2;
}
if (Window != null)
{
Mouse.SetPosition(Window.ClientBounds.Width / 2, Window.ClientBounds.Height / 2);
}
base.Update(gameTime);
}
private void Awake()
{
m_Unit = Instantiate(m_PlayerPrefab);
m_Unit.canMoveWithInput = true;
m_PlayerCamera = Instantiate(m_CameraPrefab);
m_PlayerCamera.following = m_Unit.gameObject;
m_Controller = new GameObject().AddComponent <UserController>();
m_Controller.Register(this);
UIAnnouncer.self.DelayedAnnouncement(m_Unit.unitNickname + ", Pick a skill below!", 1.0f);
UIAnnouncer.self.DelayedAnnouncement(m_Unit.unitNickname + " has entered the arena!", 1.5f);
}
public override void OnInspectorGUI()
{
ThirdPersonCamera script = (ThirdPersonCamera)target;
script.target = EditorGUILayout.ObjectField("Target", script.target, typeof(Transform), true) as Transform;
script.moveSmoothTime = EditorGUILayout.Slider("Move Smoothing", script.moveSmoothTime, 0.001f, 0.1f);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Zoom", EditorStyles.boldLabel);
script.zoomSpeed = EditorGUILayout.Slider("Zoom Speed", script.zoomSpeed, 2, 25);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Camera Dist", GUILayout.MaxWidth(100.0f), GUILayout.MinWidth(12.0f));
GUILayout.FlexibleSpace();
EditorGUIUtility.labelWidth = 32;
script.minDistance = EditorGUILayout.FloatField("Min:", script.minDistance, GUILayout.MinWidth(62));
GUILayout.FlexibleSpace();
script.maxDistance = EditorGUILayout.FloatField("Max:", script.maxDistance, GUILayout.MinWidth(62));
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUIUtility.labelWidth = 1;
EditorGUILayout.LabelField(script.minDistanceLimit.ToString(), GUILayout.MaxWidth(30));
EditorGUILayout.MinMaxSlider(ref script.minDistance, ref script.maxDistance, script.minDistanceLimit, script.maxDistanceLimit);
EditorGUIUtility.labelWidth = 1;
EditorGUILayout.LabelField(script.maxDistanceLimit.ToString(), GUILayout.MaxWidth(30));
EditorGUIUtility.labelWidth = 0;
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.LabelField("Rotation", EditorStyles.boldLabel);
script.rotationSpeed = EditorGUILayout.Vector2Field("Rotation Speed", script.rotationSpeed);
script.rotateSmoothTime = EditorGUILayout.Slider("Rotation Smoothing", script.rotateSmoothTime, 0, 0.8f);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Camera Angle", GUILayout.MaxWidth(100.0f), GUILayout.MinWidth(12.0f));
GUILayout.FlexibleSpace();
EditorGUIUtility.labelWidth = 32;
script.minPitch = EditorGUILayout.FloatField("Min:", script.minPitch, GUILayout.MinWidth(62));
GUILayout.FlexibleSpace();
script.maxPitch = EditorGUILayout.FloatField("Max:", script.maxPitch, GUILayout.MinWidth(62));
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUIUtility.labelWidth = 1;
EditorGUILayout.LabelField(script.minPitchLimit.ToString(), GUILayout.MaxWidth(30));
EditorGUILayout.MinMaxSlider(ref script.minPitch, ref script.maxPitch, script.minPitchLimit, script.maxPitchLimit);
EditorGUIUtility.labelWidth = 1;
EditorGUILayout.LabelField(script.maxPitchLimit.ToString(), GUILayout.MaxWidth(30));
EditorGUIUtility.labelWidth = 0;
EditorGUILayout.EndHorizontal();
}
private void OnPlayerSetup(SocketIOEvent evt)
{
Debug.Log("creating character/controller");
CharacterType PlayType = (CharacterType)JsonToInt(evt.data.GetField("type").ToString(), "\"");
bool isSimulated = false;
Debug.Log("Creating players controller and character:" + PlayType);
if (PlayType == CharacterType.Blender) // case blender
{
GameObject prefab = Instantiate(BlenderControllerPrefab);
PlayerBlenderController = prefab.GetComponent <BlenderController> ();
PlayerBlenderController.CharacterObject = CreateCharacter(evt, isSimulated, BlenderPrefab) as Blender;
Debug.Log("Created Blender:" + PlayerBlenderController.CharacterObject);
Blenders.Add(PlayerBlenderController.CharacterObject);
// for blender 3rd person cam
GameObject cam = Instantiate(ThirdCam, PlayerBlenderController.CharacterObject.transform.position + ThirdCam.transform.position, ThirdCam.transform.rotation);
ThirdCamComp = cam.GetComponent <ThirdPersonCamera> ();
ThirdCamComp.gameObject.SetActive(true);
ThirdCamComp.GetComponent <ThirdPersonCamera>().Setup(PlayerBlenderController.CharacterObject.gameObject);
ThirdCamComp.BlenderCamStick = PlayerBlenderController.JoystickCam;
}
else if (PlayType == CharacterType.Killer)
{
GameObject prefab = Instantiate(KillerControllerPrefab);
PlayerKillerController = prefab.GetComponent <KillerController> ();
PlayerKillerController.CharacterObject = CreateCharacter(evt, isSimulated, KillerPrefab) as Killer;
Debug.Log("Created Killer:" + PlayerKillerController.CharacterObject);
Killers.Add(PlayerKillerController.CharacterObject);
// for killer 1st person cam
GameObject cam = Instantiate(FirstCam);
FirstCamComp = cam.GetComponent <FirstPersonCamera> ();
FirstCamComp.gameObject.SetActive(true);
FirstCamComp.gameObject.transform.position = PlayerKillerController.CharacterObject.HeadTransform.position;
FirstCamComp.gameObject.transform.parent = PlayerKillerController.CharacterObject.HeadTransform;
}
SocketIOComp.Emit("SERVER:CREATE_FOR_OTHERPLAYER");
// create NPC blenders
if (GlobalGameState.IsNPCBlenderMaster)
{
GlobalMapManager.CreateNPCBlenders(NPCCount);
}
}
// Use this for initialization
void Start()
{
tpCamera = Camera.main.GetComponent <ThirdPersonCamera>();
gameObject.AddComponent <HandleMovement_Player>();
states = GetComponent <StateManager>();
hMove = GetComponent <HandleMovement_Player>();
states.isPlayer = true;
states.Init();
hMove.Init(states, this);
FixPlayerMeshes();
}
public void SetUp()
{
// create player and camera mock
GameObject prefab = Resources.Load <GameObject>("Prefabs/Player_Mock");
mock = GameObject.Instantiate(prefab).transform;
cameraTransform = mock.Find("TPV");
// Third-Person-Controller
controller = new ThirdPersonCamera(mock, 0f);
//Set SPEED const
System.Reflection.FieldInfo info = controller.GetType().GetField("SPEED", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
info.SetValue(controller, SPEED);
}
// Use this for initialization
void Start()
{
_ui = GameObject.Find("SpectatorUI").GetComponent <SpectatorUI>();
_ui.gameObject.SetActive(false);
_thirdPersonCamera = GetComponent <ThirdPersonCamera>();
_freeCameraTarget = new GameObject()
{
name = "Spectator Camera [Free Mode]"
};
_freeCameraTarget.AddComponent <CharacterController>();
this.enabled = false;
}
void Destruir()
{
if (Input.GetKeyDown(KeyCode.H) && estaemcena == true)
{
Debug.Log("Destruir");
DestroyImmediate(amigo.gameObject);
ThirdPersonCamera cam = cameraPlayer.gameObject.GetComponent <ThirdPersonCamera>();
cam.target = suportPlayer.transform;
GameObject.Find("Player").GetComponent <PlayerController>().enabled = true;
estaemcena = false;
}
}
protected override void Tick()
{
base.Tick();
if (Input.ActiveChild != null)
{
ActiveChild = Input.ActiveChild;
}
if (LifeState != LifeState.Alive)
{
return;
}
TickPlayerUse();
if (Input.Pressed(InputButton.View))
{
if (Camera is ThirdPersonCamera)
{
Camera = new FirstPersonCamera();
}
else
{
Camera = new ThirdPersonCamera();
}
}
if (Input.Pressed(InputButton.Drop))
{
var dropped = Inventory.DropActive();
if (dropped != null)
{
if (dropped.PhysicsGroup != null)
{
dropped.PhysicsGroup.Velocity = Velocity + (EyeRot.Forward + EyeRot.Up) * 300;
}
timeSinceDropped = 0;
SwitchToBestWeapon();
}
}
if (ActiveChild is Weapon weapon && !weapon.IsUsable() && weapon.TimeSincePrimaryAttack > 0.5f && weapon.TimeSinceSecondaryAttack > 0.5f)
{
SwitchToBestWeapon();
}
}
protected override void CreateScene()
{
var player = CreatePlayer();
ThirdPersonCamera thirdPersonCamera = new ThirdPersonCamera("thirdPerson", player);
thirdPersonCamera.BackgroundColor = Color.CornflowerBlue;
EntityManager.Add(thirdPersonCamera);
CreateCube("Cube2", new Vector3(5f, 0f, 0f));
CreateCube("Cube3", new Vector3(-5f, 0f, 0f));
CreateCube("Cube4", new Vector3(5f, 0f, 5f));
CreateCube("Cube5", new Vector3(-5f, 0f, 5f));
CreateCube("Cube6", new Vector3(5f, 0f, -5f));
CreateCube("Cube7", new Vector3(-5f, 0f, -5f));
}
void Awake()
{
player = GameManager.player;
Instance = this;
if (!cameraRotator)
{
cameraRotator = new GameObject("CameraRotator").transform;
cameraRotator.rotation = player.transform.rotation;
DontDestroyOnLoad(cameraRotator);
cameraRotator.position = pivotPoint.position;
transform.parent = cameraRotator;
mainOffset = transform.position - cameraRotator.position;
}
}
/// <summary>
/// Set the TPC Camara
/// </summary>
protected virtual void InitializeTpCamera()
{
if (tpCamera == null)
{
tpCamera = FindObjectOfType <ThirdPersonCamera>();
if (tpCamera == null)
{
return;
}
if (tpCamera)
{
tpCamera.SetMainTarget(this.transform);
tpCamera.Init();
}
}
}
public Vehicle()
{
CameraDefinition defaultCameraDefinition = new CameraDefinition()
{
Distance = 10,
FPV = true,
Offset = Vector3.Zero,
ViewAngle = Vector2.One,
Style = DrawingStyle.Normal
};
FirstPersonCamera = new FirstPersonCamera(defaultCameraDefinition);
ThirdPersonCamera = new ThirdPersonCamera(defaultCameraDefinition);
CameraList = new Camera[0];
CurrentCamera = 1;
VehicleMesh = new MeshReference();
}
protected override void Tick()
{
base.Tick();
//
// Input requested a weapon switch
//
if (Input.ActiveChild != null)
{
ActiveChild = Input.ActiveChild;
}
if (LifeState != LifeState.Alive)
{
return;
}
if (Input.Pressed(InputButton.View))
{
if (Camera is ThirdPersonCamera)
{
Camera = new FirstPersonCamera();
}
else
{
Camera = new ThirdPersonCamera();
}
}
if (Input.Pressed(InputButton.Drop))
{
var dropped = Inventory.DropActive();
if (dropped != null)
{
dropped.PhysicsGroup.Velocity = Velocity + (EyeRot.Forward + EyeRot.Up) * 300;
timeSinceDropped = 0;
}
}
if (Input.Pressed(InputButton.Use))
{
using (Prediction.Off())
{
TookDamage(this, WorldPos + Vector3.Random * 100);
}
}
}
private void Awake()
{
this.cameraScript = base.GetComponent <ThirdPersonCamera>();
this.controllerScript = base.GetComponent <ThirdPersonController>();
if (base.photonView.isMine)
{
this.cameraScript.enabled = true;
this.controllerScript.enabled = true;
}
else
{
this.cameraScript.enabled = false;
this.controllerScript.enabled = true;
this.controllerScript.isControllable = false;
}
base.gameObject.name = base.gameObject.name + base.photonView.viewID;
}
private void OnDrawGizmos()
{
ThirdPersonCamera TPC = GetComponent <ThirdPersonCamera>();
if (TPC != null && TPC.enabled == true)
{
UnityEditor.Handles.color = minCircleColor;
UnityEditor.Handles.DrawWireDisc(TPC.target.transform.position, transform.parent.up, TPC.minDistanceFromTarget);
UnityEditor.Handles.color = maxCircleColor;
UnityEditor.Handles.DrawWireDisc(TPC.target.transform.position, transform.parent.up, TPC.maxDistanceFromTarget);
UnityEditor.Handles.color = lookDirectionColor;
Vector3 playerLocal = TPC.target.InverseTransformPoint(transform.position);
playerLocal = new Vector3(playerLocal.x, 0, playerLocal.z);
Vector3 updatedForward = (TPC.target.position - TPC.target.TransformPoint(playerLocal)).normalized;
UnityEditor.Handles.DrawDottedLine(TPC.target.position, TPC.target.position + (updatedForward * TPC.distanceFromTarget), 5f);
}
}
IEnumerator LoadUI()
{
AsyncOperation loadUI = SceneManager.LoadSceneAsync("UI", LoadSceneMode.Additive);
while (!loadUI.isDone)
{
yield return(null);
}
GameObject[] players = GameObject.FindGameObjectsWithTag("Player");
foreach (GameObject player in players)
{
if (!Equals(player.name, "Warrior"))
{
player.tag = "Untagged";
player.SetActive(false);
}
}
GameObject[] icons = GameObject.FindGameObjectsWithTag("PlayerIcon");
foreach (GameObject icon in icons)
{
if (!Equals(icon.name, "Warrior"))
{
icon.tag = "Untagged";
icon.SetActive(false);
}
}
GameManager.SetPlayer();
GameObject mainCamera = GameObject.FindGameObjectWithTag("MainCamera");
ThirdPersonCamera thirdPersonCamera = mainCamera.GetComponent <ThirdPersonCamera>();
thirdPersonCamera.SetCamPos();
Minimap miniMapCamera = GameObject.Find("MiniMapCamera").GetComponent <Minimap>();
miniMapCamera.Init();
SceneManager.GetSceneByName("UI").GetRootGameObjects()[0].transform.Find("Skill").GetComponent <UIController>().InitSkillUI();
SaveLoadManager slm = GameObject.FindWithTag("Setting").GetComponent <SaveLoadManager>();
slm.Init();
slm.LoadBtnOnClick();
//slm.gameObject.SetActive(false);
//StaticVarAndFunction.UnloadNewCharacter();
GameManager.isLoading = false;
Destroy(this.transform.parent.parent.gameObject);
}
void Awake()
{
playerInput = GetComponent <InputController>();
playerShooter = GetComponent <PlayerShooter>();
camScript = mainCam.GetComponent <ThirdPersonCamera>();
legRB = GetComponent <Rigidbody>();
eggMode = false;
eggForm.SetActive(false);
legForm.SetActive(true);
legRB.detectCollisions = true;
legRB.isKinematic = false;
eggRB = eggForm.GetComponent <Rigidbody>();
eggRB.velocity = Vector3.zero;
eggRB.angularVelocity = Vector3.zero;
legRB.velocity = Vector3.zero;
legRB.angularVelocity = Vector3.zero;
}
private static void CreateData(MenuCommand menuCommand)
{
ThirdPersonCamera target = null;
if (menuCommand.context is ThirdPersonCamera == false)
{
return;
}
target = menuCommand.context as ThirdPersonCamera;
CameraScriptableObject dataObject = ScriptableObject.CreateInstance <CameraScriptableObject>();
dataObject.Distance = target.distance;
dataObject.TargetHeight = target.targetHeight;
dataObject.YawValue = target.yaw;
dataObject.PitchValue = target.pitch;
AssetDatabase.CreateAsset(dataObject, "Assets/Resources/Camera/Data.asset");
}
void SetControlsEnabled(GameObject playerObject, bool enabled)
{
BaseMovement movementScript = playerObject.GetComponent <BaseMovement>();
BattleScript combatScript = playerObject.GetComponent <BattleScript>();
ThirdPersonCamera cameraScript = Camera.main.GetComponent <ThirdPersonCamera>();
if (cameraScript != null)
{
cameraScript.enabled = enabled;
}
if (movementScript != null)
{
movementScript.enabled = enabled;
}
if (combatScript != null)
{
combatScript.enabled = enabled;
}
}
private void Start()
{
Base = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerStat>().ProjectileAbility;
ThirdPersonCamera camera = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <ThirdPersonCamera>();
if (camera == null)
{
Destroy(gameObject);
}
Name = Base.Name;
Description = Base.Description;
Damage = Base.Damage;
TimeActive = Base.TimeActive;
Speed = Base.Speed;
RechargeTimer = Base.RechargeTimer;
Model = Base.model; //remove this when model is available
_PrimitiveShape = GameObject.CreatePrimitive(Model); //remove this when model is available
transform.LookAt(camera.LookingAtPoint);
}
// Use this for initialization
void Start()
{
myRigidbody = GetComponentInChildren <Rigidbody> ();
myTransform = GetComponent <Transform> ();
myAnimator = GetComponentInChildren <Animator> ();
distToGround = 0; // GetComponent<CapsuleCollider> ().height / 8;
ignoreMask = 1 << 9;
cameraT = Camera.main.transform;
myCam = Camera.main.GetComponent <ThirdPersonCamera> ();
walkSpeedCounter = walkSpeedTime;
myForward = myTransform.forward;
myUp = myTransform.up;
myRight = myTransform.right;
CalculateGravity();
CalaculateWallRunForce();
}
private void SimulatePlayer()
{
if (Input.Pressed(InputButton.View))
{
if (!(Camera is FirstPersonCamera))
{
Camera = new FirstPersonCamera();
}
else
{
Camera = new ThirdPersonCamera();
}
}
if (LifeState == LifeState.Alive)
{
TickPlayerUse();
}
}
void Awake()
{
playerRigidBody = GetComponent <Rigidbody>();
playerRigidBody.AddForce(Physics.gravity * gravity);
anim = GetComponent <Animator>();
playerCollider = GetComponent <Collider>();
agent = GetComponent <NavMeshAgent>();
cam = GetComponentInChildren <ThirdPersonCamera>();
distanceToGround = playerCollider.bounds.extents.y;
playerSword = GetComponentInChildren <PlayerSwordAttack>();
//Character look fields
Vector3 angles = transform.eulerAngles;
HorizontalDirection = angles.y;
//Audio
playerSound = GetComponent <AudioSource>();
}
public override void Simulate(Client cl)
{
base.Simulate(cl);
//
// Input requested a weapon switch
//
if (Input.ActiveChild != null)
{
ActiveChild = Input.ActiveChild;
}
if (LifeState != LifeState.Alive)
{
return;
}
TickPlayerUse();
if (Input.Pressed(InputButton.View))
{
if (Camera is ThirdPersonCamera)
{
Camera = new FirstPersonCamera();
}
else
{
Camera = new ThirdPersonCamera();
}
}
SimulateActiveChild(cl, ActiveChild);
//
// If the current weapon is out of ammo and we last fired it over half a second ago
// lets try to switch to a better wepaon
//
if (ActiveChild is BaseDmWeapon weapon && !weapon.IsUsable() && weapon.TimeSincePrimaryAttack > 0.5f && weapon.TimeSinceSecondaryAttack > 0.5f)
{
SwitchToBestWeapon();
}
}
void Start()
{
if (canvasPause == null)
{
canvasPause = GameObject.Find("CanvasPause");
}
if (thirdPersonCamera == null)
{
thirdPersonCamera = GameObject.Find("MainCamera").GetComponent <ThirdPersonCamera>();
}
if (player == null)
{
player = GameObject.Find("Player").GetComponent <Player>();
}
playSecondDialogue = false;
Cursor.visible = true;
dialogueUI.SetActive(false);
}
void Awake()
{
cameraScript = GetComponent<ThirdPersonCamera>();
controllerScript = GetComponent<ThirdPersonController>();
if (photonView.isMine)
{
//MINE: local player, simply enable the local scripts
cameraScript.enabled = true;
controllerScript.enabled = true;
}
else
{
cameraScript.enabled = false;
controllerScript.enabled = true;
controllerScript.isControllable = false;
}
gameObject.name = gameObject.name + photonView.viewID;
}
void Awake()
{
this.cameraScript = this.GetComponent<ThirdPersonCamera>();
this.controllerScript = this.GetComponent<ThirdPersonController>();
if (this.photonView.isMine)
{
//MINE: local player, simply enable the local scripts
this.cameraScript.enabled = true;
this.controllerScript.enabled = true;
}
else
{
this.cameraScript.enabled = false;
this.controllerScript.enabled = true;
this.controllerScript.isControllable = false;
}
this.gameObject.name = this.gameObject.name + this.photonView.viewID;
}
void Start()
{
anim = GetComponent<Animator>();
anim.SetLayerWeight(1, 1.0f);
anim.SetLayerWeight(2, 1.0f);
timeScript = GetComponent<TimeActions>();
camScript = GetComponent<ThirdPersonCamera>();
activationHandler = GetComponent<ActivationHandler>();
weapHandler = GetComponent<WeaponHandler>();
ammoScript = GetComponent<Ammo>();
playerActivationHandler = GetComponent<PlayerActivationHandler>();
cloneActivationHandler = GetComponent<CloneActivationHandler>();
flash = GameObject.Find("Flash").GetComponent<Screenflash>();
if(anim.layerCount == 2)
anim.SetLayerWeight(1, 1);
mMoving = false;
anim.SetBool("GetUp", getUpAtStart);
}
/// <summary>
/// Initializes the custom components.
/// </summary>
private void InitializeCustomComponents()
{
_thirdPersonController = personController.GetComponent<ThirdPersonController>();
_thirdPersonCameraController = personController.GetComponent<ThirdPersonCamera>();
_flyScan = personController.GetComponent<FlyScan>();
_characterMotor = personController.GetComponent<CharacterMotor>();
_fpsInputController = personController.GetComponent<FPSInputController>();
_rotationConstraint = eyesCamera.GetComponent<RotationConstraint>();
_myMouseLook = personController.GetComponent<MyMouseLook>();
}
// Use this for initialization
protected void Start()
{
if (emitter != null) {
emitter.Emit ();//запускаем эмиттер
isSpawn = true;//отключаем движения и повреждения
}
if (!photonView.isMine) {
Destroy (GetComponent<ThirdPersonController> ());
Destroy (GetComponent<ThirdPersonCamera> ());
Destroy (GetComponent<MouseLook> ());
GetComponent<Rigidbody> ().isKinematic = true;
} else {
cameraController=GetComponent<ThirdPersonCamera> ();
isAi = cameraController==null;
}
mainAi = GetComponent<AIBase> ();
isAi = mainAi!=null;
correctPlayerPos = transform.position;
myCollider = collider;
centerOffset = capsule.bounds.center - myTransform.position;
headOffset = centerOffset;
headOffset.y = capsule.bounds.max.y - myTransform.position.y;
distToGround = capsule.height/2-capsule.center.y;
charMan = GetComponent<CharacteristicManager> ();
charMan.Init ();
health= charMan.GetIntChar(CharacteristicList.MAXHEALTH);
//Debug.Log (distToGround);
}
void Start()
{
Gamestatemanager.ChangeInGameMenuHandler +=Gamestatemanager_ChangeInGameMenuHandler;
camScript = gameObject.GetComponent<ThirdPersonCamera>();
calculateAOI();
}
// Use this for initialization
protected void Start()
{
aSource = GetComponent<AudioSource> ();
sControl = new soundControl (aSource);//создаем обьект контроллера звука
_canWallRun = canWallRun;
//проигрываем звук респавна
sControl.playClip (spawnSound);
if (emitter != null) {
emitter.Emit ();//запускаем эмиттер
isSpawn = true;//отключаем движения и повреждения
}
if (!photonView.isMine) {
Destroy (GetComponent<ThirdPersonController> ());
Destroy (GetComponent<ThirdPersonCamera> ());
Destroy (GetComponent<MouseLook> ());
GetComponent<Rigidbody> ().isKinematic = true;
//ivnMan.Init ();
} else {
cameraController=GetComponent<ThirdPersonCamera> ();
isAi = cameraController==null;
}
mainAi = GetComponent<AIBase> ();
isAi = mainAi!=null;
correctPlayerPos = transform.position;
myCollider = collider;
ivnMan.Init ();
centerOffset = capsule.bounds.center - myTransform.position;
headOffset = centerOffset;
headOffset.y = capsule.bounds.max.y - myTransform.position.y;
distToGround = capsule.height/2-capsule.center.y;
charMan = GetComponent<CharacteristicManager> ();
charMan.Init ();
health= charMan.GetIntChar(CharacteristicList.MAXHEALTH);
if (canJump) {
jetPackCharge = charMan.GetIntChar(CharacteristicList.JETPACKCHARGE);
}
ivnMan.Init ();
AfterSpawnAction ();
//Debug.Log (distToGround);
}
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// Overlay component, used to draw the pause menu and game over menu
overlayComponent = new OverlayComponent(Game, spriteBatch);
Game.Components.Add(overlayComponent);
projectionMatrix = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4,
GraphicsDevice.Viewport.AspectRatio, 0.1f, 50000);
directionalLight = new DirectionalLight(
new Vector3(-1.25f, -2f, 5.0f), // Direction
new Vector3(.1f, .1f, .1f),//new Vector3(.15f, .14f, .29f), // Ambient
new Vector3(.46f, .33f, .75f)); // Diffuse
Game.AddService(typeof(DirectionalLight), directionalLight);
#region Level terrain generation
int heightMapSize = terrainSegmentsCount * terrainSegmentSize + 1;
float halfHeightMapSize = heightMapSize / 2f;
HeightMap heightmapGenerator = new HeightMap(heightMapSize);
var heightMap = heightmapGenerator.Generate();
var roadMap = new float[heightMapSize, heightMapSize];
raceTrack = new RaceTrack(heightMapSize, terrainScale);
navMesh = new NavMesh(GraphicsDevice, raceTrack.Curve, //1500, roadWidth, terrainScale);
750, roadWidth, terrainScale);
Vector3 lastPosition = raceTrack.Curve.GetPoint(.01f) / terrainScale;
for (float t = 0; t < 1; t += .0002f)
{
var e = raceTrack.Curve.GetPoint(t) / terrainScale;
for (float j = -roadFalloff; j <= roadFalloff; j++)
{
var pos = e + j * Vector3.Normalize(Vector3.Cross(lastPosition - e, Vector3.Up));
// Indices
int x = (int)(pos.X + halfHeightMapSize),
z = (int)(pos.Z + halfHeightMapSize);
float height = e.Y;
if (Math.Abs(j) <= roadWidth)
{
heightMap[x, z] = height;
roadMap[x, z] = 1;
}
else
{
float amount = (Math.Abs(j) - roadWidth) / (roadFalloff - roadWidth);
heightMap[x, z] = MathHelper.Lerp(height,
heightMap[x, z], amount);
roadMap[x, z] = amount / 10f;
}
}
lastPosition = e;
}
heightmapGenerator.Smoothen();
heightmapGenerator.Perturb(30f);
for (int i = 0; i < 5; i++)
{
heightmapGenerator.Smoothen();
}
terrainEffect = content.Load<Effect>(@"Effects\TerrainShading");
//terrainEffect.Parameters["TextureMap0"].SetValue(content.Load<Texture2D>(@"Terrain\sand"));
#region TEXTURE RENDERING
//var unprocessedGrassTexture = content.Load<Texture2D>(@"Terrain\grass");
//var grassTexture = new RenderTarget2D(GraphicsDevice, unprocessedGrassTexture.Width, unprocessedGrassTexture.Height);
//GraphicsDevice.SetRenderTarget(grassTexture);
//spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
//spriteBatch.Draw(unprocessedGrassTexture, new Rectangle(0, 0, unprocessedGrassTexture.Width, unprocessedGrassTexture.Height), Color.White);
//spriteBatch.Draw(content.Load<Texture2D>(@"Particles\fire"), new Rectangle(0, 0, unprocessedGrassTexture.Width, unprocessedGrassTexture.Height), Color.White);
//spriteBatch.End();
//GraphicsDevice.SetRenderTarget(null);
//terrainEffect.Parameters["TextureMap1"].SetValue(grassTexture);
#endregion
terrainEffect.Parameters["TextureMap0"].SetValue(content.Load<Texture2D>(@"Terrain\road"));
terrainEffect.Parameters["TextureMap1"].SetValue(content.Load<Texture2D>(@"Terrain\grass"));
terrainEffect.Parameters["TextureMap2"].SetValue(content.Load<Texture2D>(@"Terrain\rock"));
terrainEffect.Parameters["TextureMap3"].SetValue(content.Load<Texture2D>(@"Terrain\snow"));
terrainEffect.Parameters["RoadNormalMap"].SetValue(content.Load<Texture2D>(@"Terrain\road_n"));
terrainEffect.Parameters["Projection"].SetValue(projectionMatrix);
// Creates a terrainmodel around Vector3.Zero
terrainSegments = new TerrainModel[terrainSegmentsCount, terrainSegmentsCount];
float terrainStart = -.5f * heightMapSize;
for (int z = 0; z < terrainSegmentsCount; z++)
{
for (int x = 0; x < terrainSegmentsCount; x++)
{
terrainSegments[x, z] = new TerrainModel(GraphicsDevice,
terrainSegmentSize, terrainSegmentsCount, terrainStart,
x * terrainSegmentSize, z * terrainSegmentSize,
terrainScale, heightMap, roadMap, terrainEffect, directionalLight);
}
}
#endregion
#region Car
Car = MakeCar();
gameInstance.AddService(typeof(Car), Car);
Player localPlayer = gameInstance.GetService<ServerClient>().LocalPlayer;
gameInstance.GetService<CarControlComponent>().Cars[localPlayer] = Car;
gameInstance.AddService(typeof(Player), localPlayer);
#endregion
#region Lights
// Load model to represent our lightsources
var pointLightModel = content.Load<Model>(@"Models\light");
//spotLightModel = content.Load<Model>(@"Models\Cone");
Vector3 pointLightOffset = new Vector3(0, 250, 0);
var cr = new CurveRasterization(raceTrack.Curve, 50);
float colorOffset = 0f;
foreach (var point in cr.Points)
{
Random r = UniversalRandom.GetInstance();
Vector3 color = new Vector3(0f,0f,0f);
PointLight pl = new PointLight(point.Position + pointLightOffset +
Vector3.Transform(50 * Vector3.Up, Matrix.CreateRotationZ(MathHelper.TwoPi * (float)UniversalRandom.GetInstance().NextDouble())),
color, 450)
{
Model = pointLightModel,
ColorTimeOffset = colorOffset
};
pointLights.Add(pl);
GraphicalObjects.Add(pl);
colorOffset += 100 / cr.Points.Count;
}
#endregion
dustEmitter = new ParticleEmitter(dustSystem, 150, Car.Position);
#region SkySphere
skyBoxModel = content.Load<Model>(@"Models/skybox");
skyBoxEffect = content.Load<Effect>(@"Effects/SkyBox");
skyMap = new TextureCube(GraphicsDevice, 2048, false, SurfaceFormat.Color);
string[] cubemapfaces = { @"SkyBoxes/PurpleSky/skybox_right1",
@"SkyBoxes/PurpleSky/skybox_left2",
@"SkyBoxes/PurpleSky/skybox_top3",
@"SkyBoxes/PurpleSky/skybox_bottom4",
@"SkyBoxes/PurpleSky/skybox_front5",
@"SkyBoxes/PurpleSky/skybox_back6_2"
};
//cubeMap = new TextureCube(GraphicsDevice, 1024, false, SurfaceFormat.Color);
//string[] cubemapfaces = {
// @"SkyBoxes/StormyDays/stormydays_ft",
// @"SkyBoxes/StormyDays/stormydays_bk",
// @"SkyBoxes/StormyDays/stormydays_up",
// @"SkyBoxes/StormyDays/stormydays_dn",
// @"SkyBoxes/StormyDays/stormydays_rt",
// @"SkyBoxes/StormyDays/stormydays_lf"
//};
//cubeMap = new TextureCube(GraphicsDevice, 1024, false, SurfaceFormat.Color);
//string[] cubemapfaces = {
// @"SkyBoxes/Miramar/miramar_ft",
// @"SkyBoxes/Miramar/miramar_bk",
// @"SkyBoxes/Miramar/miramar_up",
// @"SkyBoxes/Miramar/miramar_dn",
// @"SkyBoxes/Miramar/miramar_rt",
// @"SkyBoxes/Miramar/miramar_lf"
//};
for (int i = 0; i < cubemapfaces.Length; i++)
LoadCubemapFace(skyMap, cubemapfaces[i], (CubeMapFace)i);
skyBoxEffect.Parameters["SkyboxTexture"].SetValue(skyMap);
foreach (var mesh in skyBoxModel.Meshes)
foreach (var part in mesh.MeshParts)
part.Effect = skyBoxEffect;
#endregion
#region Weather
thunderBoltGenerator = new ThunderBoltGenerator(gameInstance, thunderParticleSystem);
gameInstance.Components.Add(thunderBoltGenerator);
#endregion
#region GameObjects
OakTree.LoadMaterial(content);
BirchTree.LoadMaterial(content);
Stone.LoadMaterial(content);
int numObjects = 75;
for (int i = 0; i < numObjects; i++)
{
var t = navMesh.triangles[UniversalRandom.GetInstance().Next(navMesh.triangles.Length)];
float v = (float)UniversalRandom.GetInstance().NextDouble();
//float u = (float) (UniversalRandom.GetInstance().NextDouble() - 1/2f);
//if (u < 0)
// u -= .5f;
//else
// u += 1.5f;
float u = 0;
if (UniversalRandom.GetInstance().NextDouble() <= .5)
u = -.5f - .3f * (float)(-UniversalRandom.GetInstance().NextDouble());
else
u = (float)(1.5f + .3f * UniversalRandom.GetInstance().NextDouble());
var pos = (t.vertices[0] + u * t.ab + v * t.ac) / terrainScale;
//var treePos = new Vector3(-halfHeightMapSize + (float)UniversalRandom.GetInstance().NextDouble() * (heightMapSize-50), 0,
// -halfHeightMapSize + (float)UniversalRandom.GetInstance().NextDouble() * (heightMapSize-50));
float X = pos.X + heightMapSize / 2f,
Z = pos.Z +heightMapSize / 2f;
float Xlerp = X % 1f,
Zlerp = Z % 1f;
int x0 = (int)X,
z0 = (int)Z,
x1 = x0 + 1,
z1 = z0 + 1;
float height;
float k;
if (Xlerp + Zlerp > 1)
{
float h1 = MathHelper.Lerp(heightMap[x0, z1], heightMap[x1, z1], Xlerp);
float h2 = MathHelper.Lerp(heightMap[x1, z0], heightMap[x1, z1], Zlerp);
k = h2 / h1;
height = MathHelper.Lerp(h1, h2, .5f);
}
else
{
float h1 = MathHelper.Lerp(heightMap[x0, z0], heightMap[x1, z0], Xlerp),
h2 = MathHelper.Lerp(heightMap[x0, z0], heightMap[x0, z1], Zlerp);
k = h2 / h1;
height = MathHelper.Lerp(h1, h2, .5f);
}
pos.Y = height - 0.002f;
if (k > 1.02 ) continue;
GameObject obj;
switch(UniversalRandom.GetInstance().Next(0, 3))
{
case 0:
obj = new OakTree(gameInstance);
obj.Scale = 3 + 3 * (float)UniversalRandom.GetInstance().NextDouble();
FireflyCandidates.Add(obj);
break;
case 1:
obj = new BirchTree(gameInstance);
obj.Scale = 3 + 3 * (float)UniversalRandom.GetInstance().NextDouble();
FireflyCandidates.Add(obj);
break;
default:
obj = new Stone(gameInstance);
obj.Scale = 0.5f + (float)(.25 * UniversalRandom.GetInstance().NextDouble());
break;
}
obj.Position = terrainScale * pos;
obj.Rotation = new Vector3(0, MathHelper.Lerp(0, MathHelper.Pi * 2, (float)UniversalRandom.GetInstance().NextDouble()), 0);
GraphicalObjects.Add(obj);
ShadowCasterObjects.Add(obj);
}
for (int i = 0; i < FireflyCandidates.Count; i+=5)
{
ParticleEmitter emitter = new ParticleEmitter(fireflySystem, 80, FireflyCandidates[i].Position);
emitter.Origin = FireflyCandidates[i].Position + Vector3.Up * 500;
fireflyEmitter.Add(emitter);
}
#endregion
//foreach (GameObject obj in GraphicalObjects)
//{
// pointLights.Add(new PointLight(obj.Position + Vector3.Up * 500, new Vector3(0.7f, 0.7f, 0.7f), 450)
// {
// Model = pointLightModel
// });
//}
//GraphicalObjects.AddRange(pointLights);
//List<FireObject> list = new List<FireObject>();
//foreach (PointLight p in pointLights)
//{
// FireObject obj = new FireObject(gameInstance, content, p.Position, p.Position + Vector3.Up * 10);
// list.Add(obj);
//}
//pointLights.AddRange(list);
//GraphicalObjects.AddRange(list);
#region Cameras
var input = gameInstance.GetService<InputComponent>();
gameInstance.GetService<CameraComponent>().AddCamera(new DebugCamera(new Vector3(-11800, 3000, -8200), input));
Camera c;
gameInstance.GetService<CameraComponent>().AddCamera(c = new ThirdPersonCamera(Car, input));
gameInstance.GetService<CameraComponent>().CurrentCamera = c;
#endregion
#region DynamicEnvironment
// TODO: CARMOVE
environmentCubeMap = new RenderTargetCube(this.GraphicsDevice, 256, true, SurfaceFormat.Color, DepthFormat.Depth16);
Car.EnvironmentMap = skyMap;
#endregion
#region PostProcess
postProcessingComponent = new PostProcessingComponent(Game);
Game.Components.Add(postProcessingComponent);
postProcessTexture = new RenderTarget2D(GraphicsDevice,
GraphicsDevice.Viewport.Width,
GraphicsDevice.Viewport.Height,
true, SurfaceFormat.Color, DepthFormat.Depth24);
#endregion
// Adding a prelighingrenderer as a service
prelightingRenderer = new PrelightingRenderer(GraphicsDevice, content);
Game.AddService(typeof(PrelightingRenderer), prelightingRenderer);
#region ShadowMapEffect
shadowMapEffect = content.Load<Effect>(@"Effects\ShadowMap");
#endregion
#region Gameplay Trigger Manager (with sample)
/// <summary>
/// Gets the triggermanager
/// Add new PositionTrigger
/// Hook up to listener => when hit, use the thunderBoltGenerator and spawn a flash
/// Adds it to triggers.
/// </summary>
//var triggerManager = gameInstance.GetService<TriggerManager>();
//int noOfCheckpoints = 10;
//for (int i = 0; i < noOfCheckpoints; i++)
//{
// var trigger = new PositionTrigger(raceTrack.CurveRasterization, (int)(((float)i / noOfCheckpoints) * raceTrack.CurveRasterization.Points.Count), true, true);
// string cp = "Checkpoint " + i;
// trigger.Triggered += (sender, e) =>
// {
// Console.WriteLine(cp);
// };
// triggerManager.Triggers.Add("checkpoint"+i, trigger);
//}
#endregion
#region Game Mode
if (gameInstance.GetService<ServerClient>().connected)
{
foreach (var player in gameInstance.GetService<ServerClient>().Players.Values)
{
gameInstance.GetService<CarControlComponent>().AddCar(player, null, this);
}
var carList = gameInstance.GetService<CarControlComponent>().Cars.OrderBy(pc => pc.Key.ID).Select(pc => pc.Value).ToList();
SetCarsAtStart(carList);
}
int cp = 6;
if (gameModeChoice == GameModeChoice.SimpleRace)
this.mode = new SimpleRaceMode(gameInstance, 3, cp, raceTrack, Car);
else if (gameModeChoice == GameModeChoice.Multiplayer)
this.mode = new MultiplayerRaceMode(gameInstance, 3, cp, raceTrack, Car);
else
throw new Exception("Stop choosing weird game modes");
gameInstance.AddService(typeof(GameplayMode), mode);
#endregion
#region Checkpoint lights
for (int i=0; i<cp; i++) {
var point = raceTrack.GetCurveRasterization(cp).Points[i];
var pl = new CheckpointLight(point.Position + 500 * Vector3.Up)
{
Model = pointLightModel
};
pointLights.Add(pl);
GraphicalObjects.Add(pl);
#region Fire
int halfnumberoffire = 5;
for (int o = -halfnumberoffire + 1; o < halfnumberoffire; o++)
{
Vector3 side = Vector3.Cross(Vector3.Normalize(raceTrack.Curve.GetPoint((i) / (float)cp + .001f) - point.Position), Vector3.Up);
var fire = new FireObject(content, fireSystem, fireSmokeSystem, point.Position + side * 100 * o -
Vector3.Up * 400 +
Vector3.Up * 650 * (float)Math.Cos(o/(float)halfnumberoffire), Vector3.Up * 10);
pointLights.Add(fire);
GraphicalObjects.Add(fire);
}
#endregion
}
#endregion
#region BackgroundSound
loopSoundManager.AddNewSound("forestambient");
#endregion
prelightingRenderer.GameObjects = GraphicalObjects;
init = true;
}
// Use this for initialization
void Start()
{
cam = GameObject.FindGameObjectWithTag("MainCamera").GetComponent<ThirdPersonCamera>();
cuttableLayer = 1 << LayerMask.NameToLayer("Cuttable");
gazeData = GetComponent<GazePointDataComponent> ();
if(!gazeData)
{
gazeData = new GazePointDataComponent();
}
lineTex = new Texture2D(2, 2);
lineTex.SetPixel(0, 0, Color.white);
lineTex.wrapMode = TextureWrapMode.Repeat;
lineTex.Apply();
}
// Use this for initialization
void Start()
{
targets = new Dictionary<int, Transform>();
cameraScript = cameraTransform.GetComponent<ThirdPersonCamera>();
}
void Awake()
{
cameraScript = GetComponent<ThirdPersonCamera>();
controllerScript = GetComponent<ThirdPersonController>();
}
void Start()
{
players = new Dictionary<string, ChickenPlayer>();
if (Player) {
player_controller = Player.GetComponent<ThirdPersonController>();
camera_controller = Player.GetComponent<ThirdPersonCamera>();
player_last_position = Player.transform.position;
player_last_rotation = Player.transform.eulerAngles.y;
player_last_state = player_controller.GetState();
}
}
void Awake()
{
Instance = this;
}
/*Use the existing camera or make a new one*/
public static void UseExistingOrCreateNewMainCamera()
{
GameObject tempCamera;
GameObject targetLookAt;
ThirdPersonCamera myCamera;
/*there is a camera, set it to temp*/
if (Camera.mainCamera != null) {
tempCamera = Camera.mainCamera.gameObject;
} else { /*no camera, create one*/
tempCamera = new GameObject ("Main Camera");
/*Adding a Camera Compnent or temp cam won't be a Camera*/
tempCamera.AddComponent ("Camera");
/*this will set the temp camera to MainCamera*/
tempCamera.tag = "MainCamera";
}
/*Adding the script ThirdPersonCamera to tempCamera*/
tempCamera.AddComponent ("ThirdPersonCamera");
/*Finding the camera and setting the Component*/
myCamera = tempCamera.GetComponent ("ThirdPersonCamera") as ThirdPersonCamera;
/*Assign Camera a target to look at*/
targetLookAt = GameObject.Find ("CameraTarget") as GameObject;
/*if no targetLookAt create one*/
if (targetLookAt == null) {
/*no look at object*/
targetLookAt = new GameObject ("targetLookAt");
/*position look at to world origin*/
targetLookAt.transform.position = Vector3.zero;
}
/*Assign myCamera's target look at to the targetLookAt*/
myCamera.TargetLookAt = targetLookAt.transform;
}
void CameraCheck()
{
/*there is a camera, set it to temp*/
if (Camera.mainCamera != null)
{
tempCamera2 = Camera.mainCamera.gameObject;
} else
{ /*no camera, create one*/
tempCamera2 = new GameObject ("Main Camera");
/*Adding a Camera Compnent or temp cam won't be a Camera*/
tempCamera2.AddComponent ("Camera");
/*this will set the temp camera to MainCamera*/
tempCamera2.tag = "MainCamera";
}
/*Adding the script ThirdPersonCamera to tempCamera*/
tempCamera2.AddComponent ("ThirdPersonCamera");
/*Finding the camera and setting the Component*/
myCamera = tempCamera2.GetComponent ("ThirdPersonCamera") as ThirdPersonCamera;
if(PenanceMotion.Instance.held)
{
/*Assign Camera a target to look at*/
targetLookAt2 = GameObject.Find ("CameraTarget") as GameObject;
//Debug.Log("Targeting CameraTarget");
if(PenanceMotion.Instance.gripped)
{
targetLookAt2 = GameObject.Find("SlashTarget") as GameObject;
//Debug.Log("Targeting SlashTarget");
}
}
else
{
targetLookAt2 = GameObject.Find ("PenanceTarget") as GameObject;
//Debug.Log("Targeting PenanceTarget");
}
/*Assign myCamera's target look at to the targetLookAt*/
myCamera.TargetLookAt = targetLookAt2.transform;
}
// Use this for initialization
void Start()
{
player = GetComponent<Player>();
tpcamera = GetComponentInChildren<ThirdPersonCamera>();
}
