/** * Runs at load time */ void Start () { movementController = MovementController.S; resourceTileController = ResourceTileController.S; tilesController = TilesController.S; }
// Use this for initialization void Start() { text = ui.GetComponent<Text> (); mControl = GetComponent<MovementController> (); charClass = GetComponent<CharacterClass> (); netview = mControl.netView; }
public void PickUp(Transform player) { if (!isHeld) { playerHolding = player; acCont = playerHolding.GetComponent<ActionController> (); moveCont = playerHolding.GetComponent<MovementController> (); if (acCont.canHoldWeapon) { isHeld = true; acCont.canHoldWeapon = false; acCont.holdingWeapon = true; transform.parent = playerHolding.transform; transform.position = acCont.weaponHoldPosition.position; if (inSpawner) { spawner.GetComponent<WeaponSpawner> ().WeaponTaken (); inSpawner = false; } if (facingRight && !moveCont.facingRight || !facingRight && moveCont.facingRight) { Flip (); } if (GetComponent<PolygonCollider2D> () != null) { GetComponent<PolygonCollider2D> ().enabled = false; } else { GetComponent<BoxCollider2D> ().enabled = false; } } } }
// Use this for initialization void Start () { body = gameObject.GetComponent<Rigidbody>(); boxcollider = gameObject.GetComponent<BoxCollider>(); defaultBoxColliderSize = boxcollider.size; defaultPlayerSize = body.transform.localScale; defaultFPVCameraAngle = CameraController.S.cameras[(int)CameraType.fpv].transform.localRotation; player = this; }
/// <summary> /// Initializes a new instance of the <see cref="RovioAPI" /> class. /// </summary> /// <param name="settings">The settings.</param> public RovioAPI(string host, int port, NetworkCredential credentials) { this.rwc = new RovioWebClient(host, port, credentials); this.movement = new MovementController(this); this.manualDriver = this.movement.ManualDriver; this.camera = new CameraController(this); }
// Use this for initialization void Start () { player = GameObject.FindGameObjectWithTag("Player").GetComponent<Transform>(); moveScript = player.gameObject.GetComponent<MovementController>(); splineScript = splineScript.GetComponent<SplineController>(); if(WaypointList.Count > 2) //just to prevent the thing from giving null ref error if the list is too small { lastWayPoint = WaypointList.Count - 1; } }
// Use this for initialization void Start() { GameObject p = GameObject.FindGameObjectWithTag("Player"); mCtrl = p.GetComponent<MovementController>(); aCtrl = p.GetComponent<AttackController>(); eCtrl = p.GetComponent<EquipmentController>(); game = GameObject.FindGameObjectWithTag("GameController").GetComponent<GameController>(); }
public virtual void Start() { textbox.enabled = false; dialogs.enabled = false; characterpic.enabled = false; showname.enabled = false; _mScript = GameObject.FindGameObjectWithTag("Player").GetComponent<MovementController>(); charanim = GameObject.Find("Character").GetComponent<Animator>(); serikAnim = GameObject.FindGameObjectWithTag("SerikGhost").GetComponent<Animator>(); }
// Use this for initialization void Start() { curmctrl = GameObject.FindGameObjectWithTag ("Player").GetComponent<MovementController> (); curslider = GetComponent<Slider> (); // Retrieve speed from MovementController speed = curmctrl.speed; StartCoroutine (Ongoing ()); }
void Start() { netView = GetComponent<NetworkView>(); mControl = player.GetComponent<MovementController> (); if (netView.isMine) { mControl.cam.enabled = true; } if (!netView.isMine) { mControl.cam.enabled = false; } }
// Use this for initialization protected virtual void Start () { player = GameObject.FindGameObjectWithTag("Player").GetComponent<Transform>(); _rbAI = GetComponent<Rigidbody>(); _waypoint = areaCenter + (OnUnitRect(rectSize.x,rectSize.z)) * rectMagnitude; playerMana = GameObject.FindGameObjectWithTag("Player").GetComponent<MovementController>(); spawnPoint = transform.position; possessExplode = GameObject.Find("SpiritBomb"); gamecontroller = GameObject.Find("GameControlCenter").GetComponent<GameControl>(); possanim = possessExplode.GetComponent<Animator>(); }
// protected abstract void AggroAbility(); // Use this for initialization protected virtual void Start() { player = GameObject.FindGameObjectWithTag("Player").GetComponent<Transform>(); playerMana = GameObject.FindGameObjectWithTag("Player").GetComponent<MovementController>(); agent = gameObject.GetComponent<NavMeshAgent>(); origin = gameObject.transform.position; waitTimer = 0.0f; circleCenter = transform.position + new Vector3(0, 0, offset); currentTargetPosition = transform.position; possessedexplode = GameObject.Find("SpiritBomb"); possanim = possessedexplode.GetComponent<Animator>(); }
/** * Runs at load time */ void Start () { disabledTileController = DisabledTileController.S; gameController = GameController.S; highlightsController = HighlightsController.S; mapsController = MapsController.S; movementController = MovementController.S; playerController = PlayerController.S; resourceTileController = ResourceTileController.S; remoteCamera = RemoteCamera.S; tilesController = TilesController.S; unitsController = UnitsController.S; }
// Use this for initialization void Start() { //_charCam.SetActive(false); CamPanScript = GameObject.FindGameObjectWithTag("Camera").GetComponent<CameraPanning>(); _dScript = GameObject.FindGameObjectWithTag("GulnazBody").GetComponent<DialogueScript>(); _camChar.GetComponent<Camera>(); _movieCam.GetComponent<Camera>(); _camChar.enabled = false; deshControl = GameObject.FindGameObjectWithTag("desh").GetComponent<Animator>(); _desh = GameObject.FindGameObjectWithTag("desh").GetComponent<NavMeshAgent>(); _moveScript = GameObject.FindGameObjectWithTag("Player").GetComponent<MovementController>(); _dTutScript = GameObject.FindGameObjectWithTag("desh").GetComponent<DeshTutorial>(); _Gulnaz = GameObject.FindGameObjectWithTag("Player"); }
/** * Runs at load time */ void Start () { gameController = GameController.S; mapsController = MapsController.S; movementController = MovementController.S; playerController = PlayerController.S; remoteCamera = RemoteCamera.S; unitTypesCollection = UnitTypes.S; playerUnitCounts = new Dictionary<string, int>[4]; // Copy the settings from the parent unit types to the faction units propagateOptions (); }
public void Init() { if (!isLocalPlayer) { Object.Destroy(mainCamera.gameObject); } else { terrainCollider = GetComponentInParent<TerrainCollider>(); bulletsEmiter = GetComponentInChildren<BulletsEmiter>(); towerController = GetComponentInChildren<TowerController>(); movementController = GetComponentInChildren<MovementController>(); } }
/** * Runs at load time */ void Start () { battleController = BattleController.S; disabledTileController = DisabledTileController.S; gameController = GameController.S; highlightsController = HighlightsController.S; mapsController = MapsController.S; movementController = MovementController.S; navController = NavController.S; playerController = PlayerController.S; resourceTileController = ResourceTileController.S; tilesController = TilesController.S; turnsController = TurnsController.S; unitsController = UnitsController.S; }
void Awake() { if (instance) { Destroy(gameObject); } else { instance = this; DontDestroyOnLoad(gameObject); } Debug.Log("MovementController: Resetting MovementSpeed..."); // Reset the movement speed ChangeSpeed(); }
private void Start() { _inventory = GetComponent<Inventory>(); _scrollingText = GetComponent<ScrollingText>(); _animator = GetComponent<Animator>(); _movementController = GetComponent<MovementController>(); _compass = transform.Find("Compass"); _characterController = GetComponent<CharacterController>(); switch (Job) { case Job.None: return; // Do nothing case Job.WoodCutter: _jobTask = WorkTask.ChopWood; break; case Job.Miner: _jobTask = WorkTask.Mine; break; } _currentTask = _jobTask; }
public void Drop() { if (isHeld) { if(GetComponent<PolygonCollider2D> () != null){ GetComponent<PolygonCollider2D> ().enabled = true; } else { GetComponent<BoxCollider2D> ().enabled = true; } transform.rotation = Quaternion.identity; facingRight = moveCont.facingRight; acCont.holdingWeapon = false; playerHolding = null; acCont = null; moveCont = null; isHeld = false; transform.parent = null; } }
// Use this for initialization void Awake() { movementFSM = gameObject.AddComponent<MovementController>(); if (!(jetpack3DMovement = GetComponent<Jetpack3DMovement>())) jetpack3DMovement = gameObject.AddComponent<Jetpack3DMovement>(); if (!(sphericalMovement = GetComponent<SphericalMovement>())) sphericalMovement = gameObject.AddComponent<SphericalMovement>(); switch(movementScheme) { case Movement.JETPACK3D: movementFSM.Configure(this, jetpack3DMovement); break; case Movement.SPHERICAL: movementFSM.Configure(this, sphericalMovement); break; } }
private void Start() { rb = GetComponent <Rigidbody>(); mv = GetComponent <MovementController>(); Energy = maxEnergy; Hydration = maxHydration; Alive = true; TimeAlive = 0; AccumEnergy = 0; AccumHydration = 0; overlappedWaterTiles = new List <Water>(); // Create attribute bars attributeBars = null; if (showAttributeBars) { attributeBars = Instantiate(attributeBarsPrefab, Vector3.zero, Quaternion.identity, GameObject.FindGameObjectWithTag("Canvas").transform); attributeBars.followTransform = transform; attributeBars.SetMaxEnergy(maxEnergy); attributeBars.SetMaxHydration(maxHydration); } }
void Start() { chargingParticleSystem.SetActive(false); chakupiState = ChakupiState.Moving; character = GetComponent <Character>(); character.CharacterInjuredEvent.AddListener(GetHit); detector.GetComponent <PlayerDetector>().playerDetectedEvent.AddListener(DetectPlayer); characterAnimator = GetComponent <ChakupiCharacterAnimator>(); movementController = GetComponent <MovementController>(); if (facingDirection) { characterAnimator.faceRight(); } else { characterAnimator.faceLeft(); } }
// Start is called before the first frame update void Awake() { gridLayout = GameObject.Find("Grid").GetComponent <GridLayout>(); //Access and store the GridLayout component enemyCellPosition = gridLayout.WorldToCell(transform.position); //Get this enemy's cell position and convert it to the nearest hex coordinates. This is the first half of an operation to center this object in it's position in the hex grid transform.position = gridLayout.CellToWorld(enemyCellPosition); //Take the hex grid position from the last operation, convert it back to world coordinates and set this object's position to those coordinates player = GameObject.FindGameObjectWithTag("Player"); //Access and store the player game object movementController = player.GetComponent <MovementController>(); gameController = GameObject.Find("GameController"); abilityController = player.GetComponent <AbilityController>(); //Access and store the ability controller highlightEnabled = false; mapManager = gameController.GetComponent <ManageMap>(); //Access and store a reference to the map manager script clickManager = gameController.GetComponent <ClickManager>(); //Access and store a reference to the click manager script resourceAndUpgradeManager = gameController.GetComponent <ResourceAndUpgradeManager>(); tutorialManager = gameController.GetComponent <TutorialManager>(); playerHealthControl = player.GetComponent <PlayerHealthControl>(); shotIncoming = false; //Set the initial state of the laser animation string clone = "(Clone)"; thisEnemyName = gameObject.name; thisEnemyName = thisEnemyName.Replace(clone, ""); inFlats = false; //thisEnemyObject = new EnemyObject(enemyCellPosition.x, enemyCellPosition.y, thisEnemyName); }
private void Awake() { if (!mController) { mController = GetComponent <MovementController>(); } if (!sController) { sController = GetComponent <SlideScript>(); } if (!cController) { cController = GetComponent <CrouchScript>(); } if (!gController) { gController = GetComponent <GlideScript>(); } if (!fController) { fController = GetComponent <FlyScript>(); } }
void Awake() { ragdollController = GetComponent <RagdollController>(); characterMovement = GetComponent <CharacterMovement>(); movementController = GetComponent <MovementController>(); humanoidAim = GetComponent <Game.Combat.HumanoidAim>(); if (cameraScript != null) { originalCamScriptTarget = cameraScript.m_Target; originalUpdateMode = cameraScript.updateMode; } SubscribeToEvents(); ragdollRightHand = ragdollController.ragdoll.GetBone(HumanBodyBones.RightLowerArm).transform.GetChild(0); }
private void Start() { movementController = GetComponentInParent <MovementController>(); parentAnimator = GetComponentInParent <Animator>(); parentAnimatorController = GetComponentInParent <AnimatorController>(); player = GetComponentInParent <Controller2D>(); cooldown = GetComponent <Cooldown>(); playerColliderExtentX = player.collider.bounds.extents.x; animationClips = parentAnimator.runtimeAnimatorController.animationClips; for (int i = 0; i < animationClips.Length; i++) { if (animationClips[i].name == "Player_Teleport_Out") { teleportOutClipLength = animationClips[i].length; } if (animationClips[i].name == "Player_Teleport_In") { teleportInClipLength = animationClips[i].length; } } }
/// <inheritdoc /> protected override Behavior.Status UpdateInternal() { //Lost target. if (!Targeter.HasTarget) { return(BehaviorTree.Behavior.Status.Failure); } //Check if close enough. float distance = Targeter.DistanceToTarget(); if (distance < _targetReachedDistance) { return(BehaviorTree.Behavior.Status.Success); } //Move towards target. Vector3 direction = Targeter.DirectionToTarget(); MovementController.ApplyMovement(direction); return(BehaviorTree.Behavior.Status.Running); }
protected override void LoadContent() { _viewportAdapter = new ScalingViewportAdapter(_graphics.GraphicsDevice, 1600, 900); _camera = new OrthographicCamera(_viewportAdapter); _spriteBatch = new SpriteBatch(_graphics.GraphicsDevice); if (File.Exists(@"Content\allSprites_default.xml")) { _atlas = TextureAtlasData.CreateFromFile(Content, @"Content\allSprites_default.xml"); _projectileFactory = new ProjectileFactory(_entityManager, _atlas); } var map = Content.Load <TiledMap>("map01"); _mapRenderer = new TiledMapRenderer(_graphics.GraphicsDevice); LoadMap(map); _player = _entityManager.AddEntity( new Player(_atlas.GetRegion("tankBody_red"), _atlas.GetRegion("tankRed_barrel1"), _projectileFactory) ); _movementController = new MovementController(_player, _camera); }
private void Start() { movementController = GetComponent <MovementController>(); playerTransform = GetComponent <Transform>(); forceApplier = GetComponent <ForceApplier>(); playerInput = GetComponent <PlayerInput>(); healthBar = FindObjectOfType <HealthBarController>(); enemyHPBar = FindObjectOfType <EnemyHealthBar>(); enemyWPBar = FindObjectOfType <EnemyWillPowerBar>(); concentrationBar = FindObjectOfType <ConcentrationBarController>(); concentrationBar.setMaxConcentation(maxConcentration); willpowerBar = FindObjectOfType <WillpowerBar>(); willpowerBar.setMaxWillpower(maxWillPower); //willpower = maxWillPower; noOfTaps = 0; concentration = maxConcentration; canAttack = true; isVulnerable = true; isBlocking = false; health = maxHealth; healthBar.setMaxHealth(maxHealth); }
/* --------------------------------------------------------------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ /* ------------------------------------ SCORERS FUNCTIONS -------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ public bool PlayerIsInRangeOfView(MovementController ctr) { Vector2 head, direction; float radius, distance; RaycastHit2D hit; int viewCount, castLayerMask; head = ctr.transform.position + Vector3.up * (1.5f); viewCount = Physics2D.OverlapCircleNonAlloc(head, ctr.entity.rangeOfView, this.overlapResults, this.playerLayerMask); if (viewCount == 0) { return(false); } direction = ((Vector2)(player.position + player.up * 0.5f)) - head; radius = 0.25f; distance = ctr.entity.rangeOfView; castLayerMask = (1 << LayerMask.NameToLayer("Ground")) | this.playerLayerMask; hit = Physics2D.CircleCast(head, radius, direction, distance, castLayerMask); return(hit.transform == player); }
void Start() // Verify setup { Setup(); // Retry setup if references were cleared post-add if (target == null) { Debug.LogError("No target assigned. Please correct and restart.", this); enabled = false; return; } if (rigidbody == null) { Debug.LogError("No rigidbody assigned. Please correct and restart.", this); enabled = false; return; } if (jumpBoostVisuals == null) { Debug.LogError("No jump boost visuals assigned. Please correct and restart.", this); enabled = false; return; } movementController = GetComponent <MovementController> (); movementController.onJump += OnJump; target[kRunForwardState].layer = target[kRunBackwardsState].layer = target[kStrafeLeftState].layer = target[kStrafeRightState].layer = 1; target.SyncLayer(1); target[kIdleState].layer = 1; }
// Start is called before the first frame update void Start() { weaponState = true; gameController = GameObject.Find("GameController"); gridLayout = GameObject.Find("Grid").GetComponent <GridLayout>(); //store a reference to the grid layout component mapManager = gameController.GetComponent <ManageMap>(); //store a reference to the map manager clickManager = gameController.GetComponent <ClickManager>(); uiController = gameController.GetComponent <UIControl>(); turnManager = gameController.GetComponent <TurnManager>(); resourceAndUpgradeManager = gameController.GetComponent <ResourceAndUpgradeManager>(); tutorialManager = gameController.GetComponent <TutorialManager>(); player = GameObject.FindGameObjectWithTag("Player"); //store a reference to the player game object playerHealthControl = player.GetComponent <PlayerHealthControl>(); movementController = player.GetComponent <MovementController>(); maxLaserRange = resourceAndUpgradeManager.CurrentMaxLaserRange; //set the initial state of the maximum laser range parameter maxJumpRange = resourceAndUpgradeManager.CurrentMaxJumpRange; instX = player.transform.position.x; //set the initial x position for instantiated objects instY = player.transform.position.y; //set the initial y position for instantiated objects Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); //get the current position of the mouse pointer //target = gridLayout.WorldToCell(ray.origin); //set the initial position of the target (i.e. where is the mouse pointing in grid coordinates) target = gridLayout.WorldToCell(clickManager.TouchPosition); //set the initial position of the target (i.e. where is the mouse pointing in grid coordinates) //target = gridLayout.WorldToCell(clickManager.ClickPosition); //set the initial position of the target (i.e. where is the mouse pointing in grid coordinates) laserState = false; //set the initial state of the laser ability activation jumpState = false; jumpCells = new List <Vector3Int>(); rocketRange = resourceAndUpgradeManager.CurrentMaxRocketRange; rocketReloadTime = resourceAndUpgradeManager.CurrentMaxRocketReload; playerFlats = new List <Vector3Int>(); timer = 0.0f; turnOffAb = false; abilityActive = false; uiController.SetLaserCharge(laserRange, maxLaserRange); uiController.SetJumpCharge(jumpRange, maxJumpRange); uiController.SetShieldBoostRechargeState(currentShieldBoostCharge, shieldBoostRechargeTime); uiController.SetRocketReloadState(currentRocketReloadAmount, rocketReloadTime); }
private void OnSceneGUI() //Monobehaviour editor function { MovementController mc = target as MovementController; Handles.ArrowHandleCap(0, mc.transform.position, mc.transform.rotation, mc.speed * .3f, EventType.Repaint); //Draws an arrow, at pos in direction of a given size. EventType.Repaint means it happens every frame if (mc.waypoints.Length > 1) { Color originalHandleColor = Handles.color; //Like Enabled, we must perserve the original handle color! Handles.color = Color.green; //Set the color of all for (int i = 0; i < mc.waypoints.Length - 1; i++) //Length minus one, because the last one doesnt have a "next" { if (mc.waypoints[i] && mc.waypoints[i + 1]) { Handles.DrawLine(mc.waypoints[i].position, mc.waypoints[i + 1].position); //Draw a line from i to i+1 } } if (mc.waypoints[0] && mc.waypoints[mc.waypoints.Length - 1]) { Handles.DrawLine(mc.waypoints[mc.waypoints.Length - 1].position, mc.waypoints[0].position); //Draw line from last element back to first element } Handles.color = originalHandleColor; //Reset the handle back to the original! } Handles.BeginGUI(); //Begin 2D gui handle, specifies that this is on the scene for (int i = 0; i < mc.waypoints.Length; i++) { if (!mc.waypoints[i]) { continue; } Vector2 guiPoint = HandleUtility.WorldToGUIPoint(mc.waypoints[i].position); //Convert a space in the world to the 2D GUI space Rect rect = new Rect(guiPoint.x - 50f, guiPoint.y - 40, 100, 20); //Create a scalable rect (In this case, hardcoded size) GUI.Box(rect, "Waypoint: " + i); //Create a GUI text box with the rect size } Handles.EndGUI(); //Call end to GUI 2D Handle }
public void Paused() { var npc = Controller.Npc; if (npc.Spacemap.Entities.Any(x => x.Value is Player)) { // move around if (npc.Range.Entities.Any(x => x.Value is Player)) { // make a search Player selectedPlayer = null; foreach (var entity in npc.Range.Entities.Where(x => x.Value is Player)) { var playerEntity = entity.Value as Player; if (selectedPlayer == null) { selectedPlayer = playerEntity; } else { if (selectedPlayer.Position.DistanceTo(entity.Value.Position) > playerEntity.Position.DistanceTo(npc.Position)) { selectedPlayer = playerEntity; } } } npc.Selected = selectedPlayer; MovementController.Move(npc, selectedPlayer.Position); } else if (!npc.Moving) { MovementController.Move(npc, Vector.Random(npc.Spacemap)); } } }
void Start() { button = GetComponentInChildren <ButtonMovement>(); door = GetComponentInChildren <DoorMovement>(); tp = this.transform.GetChild(0).GetChild(5); cam_target = this.transform.GetChild(1); reset_target = this.transform.GetChild(4); player = GameObject.Find("Playable_Character"); mc = player.GetComponent <MovementController>(); main_camera = GameObject.Find("MainCamera").GetComponent <Camera>(); cutscene_camera = GetComponentInChildren <Camera>(); can = GameObject.Find("FadeManager"); cam_fade = can.GetComponent <FadeManager>(); if (timed_door) { shape_mat.GetComponent <MeshRenderer>().material = mat[1]; door_mat.GetComponent <MeshRenderer>().material = mat[1]; } }
private void Start() { globalVolume.profile.TryGet(out vignette); globalVolume.profile.TryGet(out motionBlur); globalVolume.profile.TryGet(out filmGrain); globalVolume.profile.TryGet(out colorAdjustments); globalVolume.profile.TryGet(out chromaticAberration); startExposure = colorAdjustments.postExposure.value; startContrast = colorAdjustments.contrast.value; UIManager.Instance.staminaBar.OnChange += UpdateVignette; //UIManager.Instance.staminaBar.OnChange += UpdateMotionBlur; UIManager.Instance.staminaBar.OnChange += UpdateFilmGrain; UIManager.Instance.staminaBar.OnChange += UpdateChromaticAberration; UIManager.Instance.staminaBar.OnChange += UpdateColorGrading; UIManager.Instance.staminaBar.OnChange += UpdateCameraDistance; UIManager.Instance.staminaBar.OnChange += UpdatePlayerAnimation; UIManager.Instance.staminaBar.OnChange += UpdateMovementBuffs; UIManager.Instance.staminaBar.OnChange += UpdateOcclusionColor; UIManager.Instance.staminaBar.OnChange += UpdateAwakenessBarFillColor; movementController = GameManager.Instance.GetMovementController(); }
// Use this for initialization void Awake() { Debug.Log("Initialising " + versionNumber.text); assets = GetComponent <ChartEditorAssets>(); selectedObjectsManager = new SelectedObjectsManager(this); sfxAudioStreams = new LoadedStreamStore(soundMapConfig); _minPos = 0; _maxPos = 0; RegisterSystems(); movement = GameObject.FindGameObjectWithTag("Movement").GetComponent <MovementController>(); isDirty = false; gameObject.AddComponent <UITabbing>(); windowHandleManager = new WindowHandleManager(versionNumber.text, GetComponent <Settings>().productName); errorManager = gameObject.AddComponent <ErrorManager>(); toolManager.Init(); events.chartReloadedEvent.Register(OnChartReloaded); }
new void Start() { base.Start(); movement = GetComponent <MovementController>(); anim = GetComponent <Animator>(); movement.moveSpeed += Random.Range(-(movement.moveSpeed * 0.2f), movement.moveSpeed * 0.2f); chasing = false; Transform weaponSpot = GetComponentInChildren <WeaponSpot>().transform; GearDatabase gearDatabase = GameObject.FindObjectOfType <GearDatabase>(); GameObject weap = Instantiate(gearDatabase.weapons.Find(x => x.gamePref.name == startWeapon).gamePref, weaponSpot) as GameObject; weap.transform.localPosition = Vector3.zero; weap.transform.localRotation = Quaternion.identity; weap.transform.localScale = Vector3.one; if (Random.Range(0, 10) > 5) { direction = 1; } else { direction = -1; } changeDirectionCooldown = Random.Range(2, 10); }
void Start() { player = GameObject.Find("Playable_Character"); mc = player.GetComponent <MovementController>(); button = GetComponentInParent <Button>(); }
// Start is called before the first frame update void Start() { _movementController = GetComponent <MovementController>(); _attachToPlane = GetComponent <AttachToPlane>(); }
public void JumpButton_Clicked() { MovementController.Jump(JumpPower); }
public AnimatedPlayer() : base() { CanWalk = false; movement = new MovementController(); Score = 0; }
void Awake() { EventManager.AddListener(this,"GameOverEvent"); EventManager.AddListener(this,"GameStartEvent"); this.movementController = this.GetComponent<MovementController>(); }
// Use this for initialization void Start() { animator = GetComponent <Animator>(); movement = player.GetComponent <MovementController>(); }
public override void Awake() { base.Awake(); _inputReader = GameManager.Instance.playerInputReader; _movementControl = GetComponent <MovementController>(); }
private UnitsController unitsController = null; //!< The local reference to the unit's controller #endregion #region Unity methods /// @name Unity methods /** * Called when the script is loaded, before the game starts */ void Awake () { S = this; }
void Awake() { m_Controller = GetComponent<MovementController> (); }
/* --------------------------------------------------------------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ /* ------------------------------------ ACTION FUNCTIONS --------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ public IEnumerator Wander(MovementController ctr) { TurretController ltr = ctr as TurretController; yield return(ltr.Wander()); }
public override void OnStateEnter(Animator animator, AnimatorStateInfo animatorStateInfo, int layerIndex) { _rigidbody = animator.GetComponent <Rigidbody2D>(); _movementController = animator.GetComponent <MovementController>(); }
/* --------------------------------------------------------------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ /* ------------------------------------ SCORERS FUNCTIONS -------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ /* --------------------------------------------------------------------------------------------*/ public bool IsThereTargetAround(MovementController ctr) { // Declaration TurretController ltr; float dist, min; int count; Vector3 pos, dir, up; Collider c; Transform tr; LayerMask mask; Collider[] colliderResults; // Initialization ltr = ctr as TurretController; min = float.MaxValue; up = ltr.turret.transform.up; pos = ctr.position; tr = null; mask = 1 << LayerMask.NameToLayer("Ground"); colliderResults = Shared.colliderArray; count = Physics.OverlapSphereNonAlloc(pos, this.turretData.rangeOfView, colliderResults, this.turretData.targetLayerMask); // Check for (int i = 0; i < colliderResults.Length && count > 0; ++i) { c = colliderResults[i]; if (c == null) { continue; } // clean cache colliderResults[i] = null; // check if well-axed if (Mathf.Abs(ltr.turret.muzzle.InverseTransformPointUnscaled(c.transform.position).y) > 1f) { count--; continue; } // check if visible -> search wall/ground dir = c.transform.position - ltr.turret.muzzle.position; dir = Vector3.ProjectOnPlane(dir, up); if (Physics.Raycast(ltr.turret.muzzle.position, dir, dir.magnitude, mask)) { count--; continue; } // check nearest target dist = Vector3.Distance(pos, c.transform.position); if (dist < min) { min = dist; tr = c.transform; } count--; } ltr.target = tr; return(min <= this.turretData.rangeOfView); }
public void SetUp(Animator animator, int animationLayer, MovementController movementController) { anim = animator; layer = animationLayer; movement = movementController; }
private void Start() { camera = GameObject.FindGameObjectWithTag("MainCamera"); //Find the camera CamControl = camera.GetComponent<CameraController>(); hud = GameObject.FindGameObjectWithTag("HUD"); player = GameObject.FindGameObjectWithTag("Player"); GameObject notificationLog = GameObject.FindWithTag("Log"); Log = notificationLog.GetComponent<LogScript>(); movement_controller = GetComponent<MovementController>(); weapon_backpack_controller = GetComponent<WeaponBackpackController>(); healthController = GetComponent<HealthController>(); RB = GetComponent<Rigidbody>(); Flashlight = GetComponentInChildren<FlashlightController>(); //Attach the flashlight Particles = GetComponentsInChildren<ParticleSystem>(); //Attach the powerfists SetPowerfists(false); Drop = false; TrackFace = true; this.toggle_movement = false; ScreenSize = new Vector3(Screen.width, Screen.height); doubleTapCountdown = 0; //doubleTapCounts = new int[4]; doubleTapCount = 0; //resetDoubleTapCount(); dashDirection = new Vector2(0, 0); //dashCooldownCountdown = 0; this.isDashing = false; dashForceCurrent = 1; dashStartTime = 0; isStunned = false; stunCountdown = 0; SetStunElectricity(false); //currentFloor = 0; dialogueLevel = 0; deepestLevelVisited = 0; currLevel = 0; level = 0; defense = 1f; }
// Use this for initialization void Start () { _dScript = _dScript.GetComponent<DialogueScript>(); _deshScript = _deshScript.GetComponent<DeshTutorial>(); _pigScript = _pigScript.GetComponent<NewPigScript>(); _movementScript = _movementScript.GetComponent<MovementController>(); _waterWheel = _waterWheel.GetComponent<Animator>(); _sawBlade = _sawBlade.GetComponent<Animator>(); ArchuraAnim = ArchuraHimself.GetComponent<Animator>(); jumpSequence.SetActive(false); _camera = _camera.GetComponent<Transform>(); _dScript.hasDialogueEnd = true; _orignalRot = _camera.transform.rotation; }
public IEnumerator Shoot(MovementController ctr) { TurretController ltr = ctr as TurretController; yield return(ltr.Shoot()); }
// Use this for initialization void Start() { controller = GetComponent<MovementController>(); lastTarget = target; //self = transform; server.clients.Add(this); grid = server.grid; recentlyPerformance = GetComponent<PerformanceCalculator>(); recentlyPerformance.AddPositions(transform.position); controller.setMovementSpeed(recentlyPerformance.getSpeed()); }
override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) { this.animator = animator; movementController = animator.GetComponent <MovementController>(); movementController.OnJumpEnded += ResetAnimationState; }
// Verify setup void Start() { Setup (); // Retry setup if references were cleared post-add if (target == null) { Debug.LogError ("No target assigned. Please correct and restart.", this); enabled = false; return; } if (rigidbody == null) { Debug.LogError ("No rigidbody assigned. Please correct and restart.", this); enabled = false; return; } if (jumpBoostVisuals == null) { Debug.LogError ("No jump boost visuals assigned. Please correct and restart.", this); enabled = false; return; } movementController = GetComponent<MovementController> (); movementController.onJump += OnJump; target[kRunForwardState].layer = target[kRunBackwardsState].layer = target[kStrafeLeftState].layer = target[kStrafeRightState].layer = 1; target.SyncLayer (1); target[kIdleState].layer = 1; }
public PlayerSprite() : base() { DirectionControl = DirectionControl.Rotational; movement = new MovementController(); }
// // Use this for initialization void Start() { charClass = GetComponent<CharacterClass>(); mControl = GetComponent<MovementController> (); iControl = GetComponent<InterfaceController> (); netview = mControl.netView; // hitbox = hitboxObj.GetComponent<Collider> (); }