public void InitPlayer()
{
List <User> users = NetManager.GetInstance().sfs.UserManager.GetUserList();
foreach (User item in users)
{
int role = item.GetVariable("role").GetIntValue();
GameObject tmpPlayer = ResManager.GetInstance().GetRes <GameObject>("Player/tank" + role, true);
tmpPlayer.name = item.Name;
mUsers.Add(item.Name, tmpPlayer);
if (item.IsItMe)
{
tmpPlayer.AddComponent <TankController>();
Vector3 v = tmpPlayer.transform.position;
tmpPlayer.transform.position = this.transform.Find("b" + UnityEngine.Random.Range(0, 2)).position;
CameraCtrl cc = GameObject.Find("CameraCtrl").GetComponent <CameraCtrl>();
cc.target = tmpPlayer.transform;
cc.transform.position = tmpPlayer.transform.position - tmpPlayer.transform.forward.normalized * 2;
}
else
{
tmpPlayer.AddComponent <AsyncPlayer>();
tmpPlayer.transform.position = this.transform.Find("b" + UnityEngine.Random.Range(0, 2)).position;
}
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void CrossFade( CameraCtrl _cameraCtrl, float _duration = 0.3f )
{
if ( _cameraCtrl.layer >= MAX_LAYER ) {
Debug.LogError ( string.Format( "Failed to CrossFade CameraCtrl: {0}, camera layer ({1}) out of range. MAX_LAYER is {2}.",
_cameraCtrl.name,
_cameraCtrl.layer,
MAX_LAYER ) );
return;
}
// DISABLE {
// if ( layerToCameraCtrls[_cameraCtrl.layer].IndexOf(_cameraCtrl) != -1 )
// {
// layerToCameraCtrls[_cameraCtrl.layer].Remove(_cameraCtrl);
// }
// layerToCameraCtrls[_cameraCtrl.layer].Add(_cameraCtrl);
// } DISABLE end
PushRequest( _cameraCtrl, 1.0f, _duration );
foreach ( CameraCtrl cameraCtrl in layerToCameraCtrls[_cameraCtrl.layer] ) {
if ( cameraCtrl == _cameraCtrl )
continue;
PushRequest( cameraCtrl, 0.0f, _duration );
}
layerToBlendStates[_cameraCtrl.layer].Clear();
}
void Start()
{
_tank = new TankCtrl();
_tank.start(this);
_camera = new CameraCtrl();
_camera.start(this);
}
public override void Enter(CameraCtrl fsm)
{
// init base component
base.Enter(fsm);
// apply rotation speed settings to all characters
// vertical rotation -----------------------------
IsPlayer[] playerChars = GameObject.FindObjectsOfType<IsPlayer>();
foreach (IsPlayer character in playerChars)
{
ControlledMove moveCtrl = character.gameObject.GetComponent<ControlledMove>();
moveCtrl.rotateSpeed = rotationSpeed;
}
// -----------------------------------------------
// set Lerp values -> offset from zoomPoint
offsetFromTarget = (chaseState.chasePoint.position - zoomPoint.position).magnitude;
offsetFromTarget_Start = offsetFromTarget;
offsetFromTarget_End = 0f;
// reset lerp timer
currentLerpTime = 0f;
// copy vertical offset from previous camera state
offsetFromTargetVert = fsmCtrl.prevState.offsetFromTargetVert;
// get direction to target
Vector3 disp = chaseState.chasePoint.position - zoomPoint.position;
desiredPos = zoomPoint.position + disp.normalized * offsetFromTarget;
// enable current player rotation
ControlledMove curMoveCtrl = fsmCtrl.chaseTarget.GetComponent<ControlledMove>();
curMoveCtrl.lockRotation = false;
}
private void CameraCtrl_ImageReceived(object sender, AxNeptuneLib._INeptuneEvents_ImageReceivedEvent e)
{
try
{
if (_bIsStart == true)
{
string strGPS = _pGPSCtrl.RMCData.UTCDate + " " + _pGPSCtrl.RMCData.LocalTime;
strGPS += " ";
strGPS += _pGPSCtrl.RMCData.Longitude;
strGPS += " ";
strGPS += _pGPSCtrl.RMCData.Latitude;
strGPS += " ";
strGPS += (_pGPSCtrl.RMCData.Speed * 1.8).ToString();
CameraCtrl.ClearOverlay();
CameraCtrl.DrawOverlayText(20, 20, 80, 255, 0, 0, strGPS);
if (_bIsSave == true)
{
string strFileName = String.Format("image_{0}_{1}.jpg", (_nSaveCount++), strGPS);
CameraCtrl.SaveImage(strFileName, 100);
}
}
}
catch
{
MessageBox.Show("Unavailable Capture Path.");
}
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
CameraCtrl _target = (CameraCtrl)target;
_target.gameObject.name = _target.cameraType.ToString();
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void CrossFade(CameraCtrl _cameraCtrl, float _duration = 0.3f)
{
if (_cameraCtrl.layer >= MAX_LAYER)
{
Debug.LogError(string.Format("Failed to CrossFade CameraCtrl: {0}, camera layer ({1}) out of range. MAX_LAYER is {2}.",
_cameraCtrl.name,
_cameraCtrl.layer,
MAX_LAYER));
return;
}
// DISABLE {
// if ( layerToCameraCtrls[_cameraCtrl.layer].IndexOf(_cameraCtrl) != -1 )
// {
// layerToCameraCtrls[_cameraCtrl.layer].Remove(_cameraCtrl);
// }
// layerToCameraCtrls[_cameraCtrl.layer].Add(_cameraCtrl);
// } DISABLE end
PushRequest(_cameraCtrl, 1.0f, _duration);
foreach (CameraCtrl cameraCtrl in layerToCameraCtrls[_cameraCtrl.layer])
{
if (cameraCtrl == _cameraCtrl)
{
continue;
}
PushRequest(cameraCtrl, 0.0f, _duration);
}
layerToBlendStates[_cameraCtrl.layer].Clear();
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void PushRequest(CameraCtrl _cameraCtrl, float _weight, float _duration)
{
BlendState blendState = null;
for (int i = 0; i < blendRequestList.Count; ++i)
{
BlendState curBlendState = blendRequestList[i];
if (curBlendState.target == _cameraCtrl)
{
blendState = curBlendState;
break;
}
}
if (blendState == null)
{
blendState = new BlendState(_cameraCtrl, _weight, _duration);
blendRequestList.Add(blendState);
}
else
{
blendState.destWeight = _weight;
blendState.duration = _duration;
}
}
public bool InView()
{
CameraCtrl cmr = CameraCtrl.instance;
if (!cmr)
{
return(false);
}
int withinBounds = 0;
// Checks if the Blueprint is in view.
if (transform.position.x + 128f < cmr.transform.position.x + 104)
{
withinBounds++;
}
if (transform.position.x + 128f > cmr.transform.position.x - 104)
{
withinBounds++;
}
if (transform.position.y + 128f < cmr.transform.position.y + 104)
{
withinBounds++;
}
if (transform.position.y + 128f > cmr.transform.position.y - 104)
{
withinBounds++;
}
return(withinBounds == 4);
}
void Start()
{
instance = this;
m_mainCamera = Camera.main;
m_cameraCtrl = m_mainCamera.GetComponent <CameraCtrl>();
screenDragTrigger.onDrag += OnScreenDrag;
}
public override void Enter(CameraCtrl fsm)
{
// init base component
base.Enter(fsm);
// apply rotation speed settings to all characters
// horizontal rotation ---------------------------
IsPlayer[] playerChars = GameObject.FindObjectsOfType<IsPlayer>();
foreach (IsPlayer character in playerChars)
{
ControlledMove moveCtrl = character.gameObject.GetComponent<ControlledMove>();
moveCtrl.rotateSpeed = rotationSpeed;
}
// -----------------------------------------------
// enter init position with default parameters on first enter
if (currentPos == Vector3.zero)
{
// calculate distance offset from target
offsetFromTarget = (targetFocusPoint.position - chasePoint.position).magnitude;
// offset is set to max at init, no LERP between states is needed
offsetFromTarget_End = offsetFromTarget;
// offset value starts from the chasePoint
offsetFromTargetVert = 0f;
// get direction from chasePoint helper to target
Vector3 disp = chasePoint.position - targetFocusPoint.position;
desiredPos = targetFocusPoint.position + disp.normalized * offsetFromTarget;
}
else
{
// transition to ChaseState from ZoomState
if (fsmCtrl.prevState is ZoomState)
{
// set Lerp values -> offset from zoomPoint
offsetFromTarget_Start = (targetFocusPoint.position - zoomState.zoomPoint.position).magnitude;
offsetFromTarget_End = (targetFocusPoint.position - chasePoint.position).magnitude;
offsetFromTarget = offsetFromTarget_Start;
// reset lerp timer
currentLerpTime = 0f;
}
else
{
offsetFromTarget = (targetFocusPoint.position - chasePoint.position).magnitude;
}
// copy vertical offset from previous camera state
offsetFromTargetVert = fsmCtrl.prevState.offsetFromTargetVert;
// get direction to target
Vector3 disp = chasePoint.position - targetFocusPoint.position;
desiredPos = targetFocusPoint.position + disp.normalized * offsetFromTarget;
// camera position on vertical plane
desiredPos.y = chasePoint.position.y + offsetFromTargetVert;
}
// enable current player rotation
//ControlledMove curMoveCtrl = fsmCtrl.chaseTarget.GetComponent<ControlledMove>();
//curMoveCtrl.lockRotation = false;
}
// Use this for initialization
void Start()
{
roundController = FindObjectOfType <RoundController>();
roomContraller = FindObjectOfType <RoomContraller>();
diceRoll = FindObjectOfType <DiceRollCtrl>();
confirmUI = FindObjectOfType <ConfirmManageUI>();
camCtrl = FindObjectOfType <CameraCtrl>();
}
public Slider mSpeedSlider; //速度滑动条
void Start()
{
gCtrl = GetComponent <GameCtrl> ();
camCtrl = Camera.main.GetComponent <CameraCtrl> ();
mSpeedText.text = "Mouse Move Speed: " + camCtrl.moveSpeed.ToString();
mSpeedSlider.value = camCtrl.moveSpeed;
}
void Start()
{
PM = GameObject.Find("Player").GetComponent <PlayerMove>();
cam_mainCamera = GameObject.Find("Main Camera").GetComponent <CameraCtrl>();
cam_subCamera = GameObject.Find("Sub camera").GetComponent <CameraCtrl>();
changeCameraSight();
}
public void RunOvercharge()
{
ghostCharacter.RunShock();
explodeParticleSystem.Play();
burstParticleSystem.Play();
SoundManager.PlaySound(SoundManager.SoundType.SoundFX, overchargeSound, 1.0f, Random.Range(0.75f, 1.25f));
CameraCtrl.Shake(0.15f, 50.0f);
}
// TODO: curve
public BlendState(CameraCtrl _target, float _weight, float _duration)
{
target = _target;
duration = _duration;
timer = 0.0f;
srcWeight = _target.weight;
destWeight = _weight;
}
// 应用启动方法
private void Start()
{
m_pCamera = Camera.main.gameObject;
m_pCameraCtrl = new CameraCtrl(m_pCamera);
m_pPicker = null;
InitProject();
}
void Start()
{
this.bloodBar = ScriptEF.CreateBloodBar(gameObject);
gameObject.animation.wrapMode = WrapMode.Once;
cameraCtrl = Camera.main.GetComponent <CameraCtrl>();
myController = GetComponent <CharacterController>();
initObj();
}
// Use this for initialization
void Start()
{
roundController = FindObjectOfType <RoundController>();
roomContraller = FindObjectOfType <RoomContraller>();
HiddenRoom01 = FindObjectOfType <H_hiddenRoom>();
camCtrl = FindObjectOfType <CameraCtrl>();
this.setThingCode(ThingConstant.HIDDEN_DOOR_01_CODE);
}
void Start()
{
cam = Camera.main;
cameraCtrl = cam.GetComponent <CameraCtrl>();
lineVisual.positionCount = lineSegment;
Hide();
}
// Use this for initialization
void Start()
{
roundController = FindObjectOfType <RoundController>();
roomContraller = FindObjectOfType <RoomContraller>();
camCtrl = FindObjectOfType <CameraCtrl>();
this.setThingCode(ThingConstant.UPSTAIR_ENTER_CODE);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void PushCameraCtrlIfNotExist(CameraCtrl _cameraCtrl)
{
// find if the camera ctrl is already in layerToCameraCtrls list, if not, add it
if (layerToCameraCtrls[_cameraCtrl.layer].IndexOf(_cameraCtrl) == -1)
{
_cameraCtrl.weight = 0.0f;
layerToCameraCtrls[_cameraCtrl.layer].Add(_cameraCtrl);
}
}
protected override void Start()
{
m_unitTag = "Player";
gameObject.tag = m_unitTag;
CDataManager dataMgr = CDataManager.Inst;
if (dataMgr == null)
{
return;
}
Data.PlayerInfo playerInfo = dataMgr.PlayerRecord.PlayerInfo;
GameObject genderPrefab = null;
if (playerInfo.gender == Gender.Female)
{
genderPrefab = Resources.Load <GameObject>("Prefabs/Character/Player/Female");
Gender = Gender.Female;
}
else
{
genderPrefab = Resources.Load <GameObject>("Prefabs/Character/Player/Male");
Gender = Gender.Male;
}
if (genderPrefab == null)
{
return;
}
GameObject genderGO = Instantiate(genderPrefab, transform);
genderGO.name = genderPrefab.name;
base.Start();
m_inputCtrl = GetComponent <CInputCtrl>();
CameraCtrl.SetCamera(m_inputCtrl, this);
m_inventory = GetComponent <CInventory>();
m_inventory.Initialized(this);
if (m_unitUIPrefab)
{
GameObject uiObj = Instantiate <GameObject>(m_unitUIPrefab, CStageUIManager.Inst.transform);
uiObj.name = m_unitUIPrefab.name;
m_unitUI = uiObj.GetComponent <CUnitUI>();
if (m_unitUI != null)
{
m_unitUI.Init(this);
}
}
}
public void RunDashFX()
{
dashRenderer.emitting = true;
dashParticleSystem.Play();
var emission = dashParticleSystem.emission;
emission.enabled = true;
CameraCtrl.Shake(0.15f, 20.0f);
eyesBase.localScale = new Vector3(1.5f, 1.5f, 1.0f);
}
// Use this for initialization
void Start()
{
eventController = FindObjectOfType <EventController> ();
roundController = FindObjectOfType <RoundController> ();
roomContraller = FindObjectOfType <RoomContraller> ();
camCtrl = FindObjectOfType <CameraCtrl> ();
}
public void playerSpawn(GameObject newGameObject)
{
// attach camera
CameraCtrl cameraCtrl = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <CameraCtrl>();
cameraCtrl.Attach(newGameObject);
// wait before spawning the character
StartCoroutine(EndSpawn(newGameObject, endOfSpawnDelay));
}
public Vector3 View2WorldPos(float x, float y)
{
CameraCtrl uiCam = Instance.GetCamera(CameraCtrl.CameraType.UICamera);
if (uiCam == null || uiCam.Camera == null)
{
return(Vector3.zero);
}
return(uiCam.Camera.ViewportToWorldPoint(new Vector3(x, y, 0)));
}
//int time;
//public List<GameObject> instancesEnermies;
// Use this for initialization
protected override void OnStart()
{
cloneplayer = Instantiate(player , Vector3.zero , Quaternion.identity) as GameObject;
cam = GetComponent<CameraCtrl>();
cam.SetTarget(cloneplayer.transform);
//instancesEnermies.Add(pEnermy);
Messenger.RegisterListener(new Listener("Damage", cloneplayer, "HandleMessage"));
}
private void Awake()
{
if (instance == null)
{
instance = this;
}
cam = Camera.main;
originPosition = transform.position;
}
// Start is called before the first frame update
void Start()
{
Coli = GetComponent <PlayerCollision>();
Rigid = GetComponent <Rigidbody>();
Anim = GetComponentInChildren <Animator>();
Visual = GetComponent <PlayerVisual>();
Cam = GetComponentInChildren <CameraCtrl>();
Cam.GetComponent <CameraCtrl>().Setup(this.transform);
Cam.transform.parent = null;
}
private void PropertyBtn_Click(object sender, EventArgs e)
{
try
{
CameraCtrl.ShowPropertyPage();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
void Awake()
{
instance = this;
startPos = transform.position;
PostProcessVolume volume = GetComponentInChildren <PostProcessVolume>();
profile = volume.profile;
chromaticAberration = profile.GetSetting <ChromaticAberration>();
}
public FlyTask(CameraCtrl pCtrl, CTRL_MODE eMode, Vector3 mTarget, float nLng, float nLat, float nDistance, float nPitch, float nYaw)
{
m_pCameraCtrl = pCtrl;
m_eMode = eMode;
m_mTarget = mTarget;
m_nLng = nLng;
m_nLat = nLat;
m_nDistance = nDistance;
m_nPitch = nPitch;
m_nYaw = nYaw;
}
private void InitializeEnv()
{
CameraCBox.Items.Clear();
CameraCBox.SelectedIndex = -1;
System.Array arCameraList = (System.Array)CameraCtrl.GetCameraList();
for (int i = 0; i < arCameraList.Length; i++)
{
CameraCBox.Items.Add(arCameraList.GetValue(i));
CameraCBox.SelectedIndex = i;
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void Blend( CameraCtrl _cameraCtrl, float _weight, float _duration = 0.3f )
{
if ( _cameraCtrl.layer >= MAX_LAYER ) {
Debug.LogError ( string.Format( "Failed to CrossFade CameraCtrl: {0}, camera layer ({1}) out of range. MAX_LAYER is {2}.",
_cameraCtrl.name,
_cameraCtrl.layer,
MAX_LAYER ) );
return;
}
PushRequest( _cameraCtrl, _weight, _duration );
// layerToBlendStates[_cameraCtrl.layer].Clear();
}
void Start()
{
CameraMng cameraMng = Game.instance.GetComponent<CameraMng>();
if ( cameraMng ) {
GameObject ctrlGO = Instantiate( OrbitFollowCameraCtrlPrefab,
Vector3.zero,
Quaternion.identity ) as GameObject;
if ( ctrlGO ) {
OrbitFollowCameraCtrl orbitFollow = ctrlGO.GetComponent<OrbitFollowCameraCtrl>();
if ( orbitFollow ) {
orbitFollow.traceTarget = player.transform;
orbitFollow.MoveTo ( player.transform.position
- player.transform.forward * 10.0f
+ player.transform.up * 10.0f );
orbitFollow.Apply ();
camCtrl1 = orbitFollow;
cameraMng.CrossFade(camCtrl1);
}
}
}
}
// TODO: curve
public BlendState( CameraCtrl _target, float _weight, float _duration )
{
target = _target;
duration = _duration;
timer = 0.0f;
srcWeight = _target.weight;
destWeight = _weight;
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
public void FadeOut( CameraCtrl _cameraCtrl, float _duration = 0.3f )
{
// TODO:
}
public void Awake()
{
mState = transform.parent.gameObject.GetComponentInChildren<MapState>();
charLSManager = transform.parent.Find("charLSManager").GetComponent<LinkedSpriteManager>();
itemLSManager = transform.parent.Find("charLSManager").GetComponent<LinkedSpriteManager>();
enemyLSManager = transform.parent.Find("enemyLSManager").GetComponent<LinkedSpriteManager>();
camCtrl = Camera.mainCamera.GetComponent<CameraCtrl>();
settings = transform.parent.gameObject.GetComponentInChildren<Settings>();
DontDestroyOnLoad (transform.parent);
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void PushCameraCtrlIfNotExist( CameraCtrl _cameraCtrl )
{
// find if the camera ctrl is already in layerToCameraCtrls list, if not, add it
if ( layerToCameraCtrls[_cameraCtrl.layer].IndexOf(_cameraCtrl) == -1 ) {
_cameraCtrl.weight = 0.0f;
layerToCameraCtrls[_cameraCtrl.layer].Add(_cameraCtrl);
}
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void PushRequest( CameraCtrl _cameraCtrl, float _weight, float _duration )
{
BlendState blendState = null;
for ( int i = 0; i < blendRequestList.Count; ++i ) {
BlendState curBlendState = blendRequestList[i];
if ( curBlendState.target == _cameraCtrl ) {
blendState = curBlendState;
break;
}
}
if ( blendState == null ) {
blendState = new BlendState( _cameraCtrl, _weight, _duration );
blendRequestList.Add(blendState);
}
else {
blendState.destWeight = _weight;
blendState.duration = _duration;
}
}
public virtual void Enter(CameraCtrl fsm)
{
fsmCtrl = fsm;
}
