public void TryToTeleport(Movable _movable) { if (isXWarp) { // Teleport if exit map if (Mathf.Sign(transform.position.x - _movable.transform.position.x) == Mathf.Sign(transform.position.x - teleportTransform.position.x)) { return; } _movable.transform.position = new Vector3(teleportTransform.position.x, isXAndYChanged ? teleportTransform.position.y : _movable.transform.position.y, _movable.transform.position.z); _movable.Flip(); } else { // Teleport if exit map if (Mathf.Sign(transform.position.y - _movable.transform.position.y) == Mathf.Sign(transform.position.y - teleportTransform.position.y)) { return; } _movable.transform.position = new Vector3(_movable.transform.position.x, teleportTransform.transform.position.y, _movable.transform.position.z); } GameManager.PlayClipAtPoint(GameManager.I?.WarpSound, _movable.transform.position); }
/// <summary> /// Attempts to set movement of an entity. /// </summary> /// <param name="entity">Entity to set movement on.</param> /// <param name="relativePosition">Vector of direction and distance.</param> /// <param name="locomotion">Method of movement by terrain type</param> /// <returns>Returns true if movement set successfully.</returns> internal bool SetMovement(Entity entity, Vector2 destinationVector) { float distance = destinationVector.magnitude; Vector2 direction = destinationVector.normalized; Coordinates endCoordinates = entity.Coordinates.AtVector(destinationVector); // If obstacles in the way, ignore move if (physicsManager) { if (physicsManager.GetTargetRay(entity, direction, distance)) { return(false); } } // If we can place the entity at new coordinates set movements if (Place((EntityMember)entity, endCoordinates)) { Attributes attributes = entity.GetComponent <Attributes>(); Movable movable = entity.GetComponent <Movable>(); if (movable & attributes & worldManager) { float speed = worldManager.GetSpeed(endCoordinates, attributes, TerrainTileEntity.TerrainType.Land); // Default to using land locomotion movementManager.Set(movable, destinationVector, speed); return(true); } } return(false); }
// Method, which will move Movable implementing class by dx and dy public void moveBy(Movable serviced, int dx, int dy) { // this is the place to offer the functionality dx += serviced.getPosition().xPosition; dy += serviced.getPosition().yPosition; serviced.setPosition(new Position(dx, dy)); }
private void Awake() { _playerState = GetComponent <PlayerState>(); _movable = GetComponent <Movable>(); _attackLogic = GetComponent <AttackLogic>(); _probability = new Probability(); }
public void UpdateShields(Movable movable) { if (movable.Cell.Index != Index) { return; } if (typeof(Enemy).IsCompatibleWith(movable.GetType())) { ShieldsCount--; // Destroy Monster Inventory.RemoveToken(movable); Destroy(movable.gameObject); EventManager.TriggerEnemyDestroyed((Enemy)movable); } else if (typeof(Farmer).IsCompatibleWith(movable.GetType())) { ShieldsCount++; // Destroy Farmer Inventory.RemoveToken(movable); Destroy(movable.gameObject); EventManager.TriggerFarmerDestroyed((Farmer)movable); } if (ShieldsCount < 1) { EventManager.TriggerGameOver(); } EventManager.TriggerShieldsUpdate(ShieldsCount); }
public void TryToChange(FruitWithDir data) { if (gameState == GameState.Wait) { return; } Movable mainFruit = data.Fruit.GetComponent <Movable>(); Movable otherFruit = mainFruit.GetNeighborMovable(data.Dir, _allObjects); if (CanChange(mainFruit, data.Dir)) { gameState = GameState.Wait; ChangeFruits(mainFruit, otherFruit); EventHolder.startAnimation.Invoke(moveSpeed); List <Combine> matchesList = finder.GetCombinedObjects(_allObjects); AudioManager.Instance.SwipeSound(); if (matchesList.Count == 0) { StartCoroutine(RevertGems(mainFruit, otherFruit)); } else { taskManager.MadeMove(); shredder.MakeDamage(matchesList); StartCoroutine(shredder.FruitsDestroy(_allObjects, moveSpeed + 0.1f)); } } }
bool IsInSkillRange(Movable target) { if (Mathf.Abs(this.transform.position.x - target.transform.position.x) < skillRange * BattleManager.tileSize) return true; else return false; }
void setAIContext(UserMoveController player) { for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { GameObject obj = tileCreator.getObj(x, y); if (obj != null) { Movable movable = obj.GetComponentInChildren <Movable>(); if (movable != null) { movable.graphBuilder = this; } AIMoveController ai = obj.GetComponentInChildren <AIMoveController>(); if (ai != null) { ai.player = player; ai.graphMap = graphMap; } } } } }
void Start() { // Start with turn 0 _history.Clear(); _history.Push(new Turn(0)); // All entities MUST BE INITIALIZED AT SOME TURN // Turn0 by default var foundEntities = GameObject.FindObjectsOfType <Entity>(); _playerEntity = GameObject.FindGameObjectWithTag("Player").GetComponent <Entity>(); _playerMovable = _playerEntity.GetComponent <Movable>(); foreach (var entity in foundEntities) { var newId = GetNewEntityId(); entity.Initialize(this, newId); _entities.Add(newId, entity); } SwitchState(GameState.WaitingForPlayerCommand); _sceneName = SceneManager.GetActiveScene().name; Common.SetActiveLevel(this); //fixed rollback for test PlayerStats.Instance.SetFixedRollBack(); }
public void MoveToward(Vector2 position, float velocity) { Movable locomotion = Locomotion; Vector2 directionVector = new Vector2(); if (position.y < locomotion.GlobalPosition.y) { directionVector.y = -1f; } else if (position.y > locomotion.GlobalPosition.y) { directionVector.y = 1f; } if (position.x < locomotion.GlobalPosition.x) { directionVector.x = -1f; } else if (position.x > locomotion.GlobalPosition.x) { directionVector.x = 1f; } locomotion.velocity = directionVector.Normalized() * velocity; }
public void PaintDebug(DebugDrawer drawer) { if (Settings.Data.debugMode) { Movable locomotion = Locomotion; drawer.DrawCircle(drawer.Position, Controller.searchRadius, new Color(1.0f, 0.0f, 0.0f, 0.2f)); //drawer.DrawLine(drawer.Position, debugHitLocation.RelativeTo(locomotion.GlobalPosition), new Color(0.0f, 1.0f, 0.0f), 2f, true); if (target != null) { const float size = 24f; drawer.DrawRect(new Rect2(target.Location.RelativeTo(locomotion.GlobalPosition) - new Vector2(size / 2f, size / 2f), size, size), new Color(0.0f, 1.0f, 0.0f), false); } if (state == ChaseAIState.Wandering) { drawer.DrawLine(drawer.Position, target.Location.RelativeTo(locomotion.GlobalPosition), new Color(0.0f, 0.0f, 1.0f), 2f, true); drawer.DrawCircle(target.Location.RelativeTo(locomotion.GlobalPosition), 8f, new Color(0.0f, 0.0f, 1.0f)); } else if (state == ChaseAIState.Chasing) { drawer.DrawLine(drawer.Position, target.Location.RelativeTo(locomotion.GlobalPosition), new Color(1.0f, 0.0f, 0.0f), 2f, true); drawer.DrawCircle(target.Location.RelativeTo(locomotion.GlobalPosition), 8f, new Color(1.0f, 0.0f, 0.0f)); } } }
// Either the character controller moved into something, or something moved into the supercollider spheres. private void HandleCollision(GameObject obj, Vector3 hitNormal, Vector3 hitPos) { if (ignoreCollisions) { //Debug.Log ("Ignoring collsion because we're ignorin."+Time.time); return; } if (ignoreFootCollisions && (transform.position.y - distToGround + stepSize) >= hitPos.y + 0.01f) { //Debug.Log ("Ignoring collsion because its feet."+hitPos.y + " " + (transform.position.y - distToGround + stepSize)); return; } if ((layerMask & (1 << obj.layer)) == 0) { //Debug.Log ("Ignoring collsion of object with " + obj.layer); return; } if (Vector3.Angle(hitNormal, Vector3.up) < controller.slopeLimit) { //Debug.Log ("Ignoring collsion because it's valid ground."+Time.time); return; } float mag = velocity.magnitude; velocity = ClipVelocity(velocity, hitNormal); Movable check = obj.GetComponent <Movable> (); if (check != null) { Vector3 vel = check.velocity; float d = Vector3.Dot(vel, hitNormal); // How similar is our velocity to our hitnormal (perp = 0, backwards = -1, same = 1) if (d > 0.01f) // If the velocity should be applied { velocity += hitNormal * d * overbounce; // We apply it with some overbounce, to keep us from getting stuck. } } float change = Mathf.Abs(mag - velocity.magnitude); Rigidbody rigidcheck = obj.GetComponent <Rigidbody> (); if (rigidcheck != null) { Vector3 vel = rigidcheck.GetPointVelocity(hitPos); float d = Vector3.Dot(vel, hitNormal); if (d > 0.01f) { velocity += hitNormal * d * overbounce; } rigidcheck.AddForceAtPosition(-hitNormal * change * mass, hitPos); } if (change > fallSoundThreshold) { float fvol = Mathf.Min(change / (maxSafeFallSpeed - fallSoundThreshold), 1f); PlayerRoughLandingEffects(fvol, hitPos, hitNormal); } if (change > fallPunchThreshold) { float shakeIntensity = Mathf.Min((change - fallPunchThreshold) / (maxSafeFallSpeed - fallPunchThreshold), 1f); gameObject.SendMessage("ShakeImpact", -hitNormal * shakeIntensity); } }
public Tile(Vector2 pos, Texture2D texture, Movable movable, Rectangle rect) { this.pos = pos; this.texture = texture; this.movable = movable; this.rect = rect; }
private bool TryAnimateHint(Movable curMovable, Movable otherMovable, Vector2Int dir, GameObject[,] allObjects, bool findBigMatch, bool onlyCheck) { int maxMatch; if (findBigMatch) { maxMatch = 3; } else { maxMatch = 0; } List <Combine> combineList = GetPotentialMatchs(curMovable, otherMovable, allObjects, maxMatch); if (combineList != null) { if (onlyCheck) { return(true); } if (combineList.Contains(curMovable.GetComponent <Combine>())) { if (dir == Vector2Int.up) { curMovable.GetComponent <Animeted>().HintUp(); } else { curMovable.GetComponent <Animeted>().HintRight(); } } else { if (dir == Vector2Int.up) { otherMovable.GetComponent <Animeted>().HintDown(); } else { otherMovable.GetComponent <Animeted>().HintLeft(); } } foreach (Combine combine in combineList) { if (combine.gameObject == curMovable.gameObject) { continue; } combine.GetComponent <Animeted>().HintScale(); } return(true); } return(false); }
public virtual void Init() { _movable = GetComponent <Movable>(); if (_movable == null) { _movable = gameObject.AddComponent <Movable>(); } }
private void Awake() { battleMgr = GameObject.FindObjectOfType<BattleManager>(); parent = transform.parent.GetComponent<Movable>(); damage = parent.GetAttackDamage(); isMoveRight = parent.isOurForce ? true : false; }
// Use this for initialization void Start() { movable = GetComponent <Movable>(); if (movable == null) { Debug.LogError("Movable Controller not found"); } }
public Movable SpawnOurForce(Movable obj, int line, Vector2 pos) { Movable newObj = Instantiate(obj, ourForceLinePos[line - 1], new Quaternion()) as Movable; orderMgr.UpdateOrder(line); newObj.transform.position = pos; return newObj; }
public void TrySpawnOurForce(Movable obj, int line) { if (goldMgr.playerGold - obj.GetUnitCost() >= 0) { goldMgr.playerGold -= obj.GetUnitCost(); SpawnOurForce(obj, line); } }
public override char Print() { if (Movable != null) { return(Movable.Print()); } return('~'); }
public override int GetHashCode() { int hash = 1; if (Id != 0) { hash ^= Id.GetHashCode(); } if (relativePosition_ != null) { hash ^= RelativePosition.GetHashCode(); } if (relativeVelocity_ != null) { hash ^= RelativeVelocity.GetHashCode(); } if (Rcs != 0D) { hash ^= Rcs.GetHashCode(); } if (Movable != false) { hash ^= Movable.GetHashCode(); } if (Width != 0D) { hash ^= Width.GetHashCode(); } if (Length != 0D) { hash ^= Length.GetHashCode(); } if (Height != 0D) { hash ^= Height.GetHashCode(); } if (Theta != 0D) { hash ^= Theta.GetHashCode(); } if (absolutePosition_ != null) { hash ^= AbsolutePosition.GetHashCode(); } if (absoluteVelocity_ != null) { hash ^= AbsoluteVelocity.GetHashCode(); } if (Count != 0) { hash ^= Count.GetHashCode(); } if (MovingFramesCount != 0) { hash ^= MovingFramesCount.GetHashCode(); } return(hash); }
public bool TryPlaceObject(Movable obj) { if (currentObject != null) { return(false); } SetObject(obj); return(true); }
private void UnsetObject(ARInteractable oldInteractable, ARInteractable newInteractable) { print(newInteractable); print(oldInteractable); if (newInteractable != null && newInteractable != oldInteractable) { this.currentObject = null; } }
private void Awake() { // init components _movable = GetComponent <Movable>(); // try get this, null if player _enemyController = GetComponent <EnemyController>(); // Set animation speed for attacks based on attack time animator.SetFloat(AttackSpeed, 1 / (float)attackTime); }
public bool TryTake() { if (currentObject == null) { return(false); } currentObject = null; return(true); }
private void Awake() { if (!spriteRenderer) { spriteRenderer = GetComponent <SpriteRenderer>(); } animator = GetComponent <Animator>(); movable = GetComponent <Movable>(); }
private void HandleTick(int tick, int partialTick, float tickDuration, bool everyone) { if (everyone && Level.Instance.HasAgent(AgentID)) { Movable m = Level.Instance.GetMovableById(AgentID); HandleWalkStatus(m); Emit(heading); } }
private void OnTriggerEnter(Collider other) { Movable movable = other.GetComponent <Movable>(); if (movable != null) { movable.PullInComptoir(transform, comptoir); } }
public override bool AcceptMove(Movable movable) { if (movable.GetType() == typeof(Movables.Baricade)) { return(false); } return(base.AcceptMove(movable)); }
public void ChangeMotion <TBoard>(Movable <TBoard> movable) where TBoard : Board <TBoard> { Velocity velocity = movable.Velocity; IsActive = false; // can't do this because we don't have something called friction to resist fixed velocity motion // movable.Velocity = new Velocity(velocity.FinenessX + MoveFinenessX, velocity.FinenessY); movable.Velocity = new Velocity(MoveFinenessX, velocity.FinenessY); }
void MoveComplete(Movable movable) { if (movable != this.movable) { return; } if (stops.Count == 0) { Dispose(); } else { Cell stop = stops[0]; stops.RemoveAt(0); Cell start = movable.Cell; int startIndex = path.Cells.IndexOf(start); if (startIndex != -1) { foreach (Farmer f in start.Inventory.Farmers) { foreach (Pair <Farmer, Cell> farmer in farmers) { if (farmer.First == f) { int stopInd = -1; if (farmer.Second != null) { stopInd = path.Cells.IndexOf(farmer.Second); } if (stopInd == -1) { stopInd = path.Cells.Count - 1; } List <Cell> subpathFarmer = path.Cells.GetRange(startIndex, stopInd - startIndex + 1); f.Move(subpathFarmer); break; } } } int stopIndex = path.Cells.IndexOf(stop, startIndex + 1); if (stopIndex != -1) { List <Cell> subpathHero = path.Cells.GetRange(startIndex, stopIndex - startIndex + 1); movable.Move(subpathHero, totalFreeMoves); } else { Dispose(); } } } }
public static bool CanReach(this Movable seeker, TargetInfo targetInfo) { if (seeker.Navigator is Navigation2D navigator) { object simplePath = navigator.GetSimplePath(seeker.GlobalPosition, targetInfo) != null; return(simplePath != null); } return(false); }
void Start() { movable = GetComponentInParent <Movable>(); my_body = GetComponent <ColoredBody>(); if (my_body == null) { Debug.LogError("Bullet objects must have a ColoredBody component!"); } }
private void OnTriggerEnter2D(Collider2D other) { Movable movable = other.gameObject.GetComponent <Movable>(); if (movable) { GetInto(movable); } }
public override void OnInspectorGUI() { base.OnInspectorGUI(); GUILayout.Space(8f); if (!EditorApplication.isPlaying && GUILayout.Button("Apply to changed", GUILayout.Height(25f))) { MovableText movableText = target as MovableText; int messageLength = movableText.Message.Length; Transform movTransform = movableText.transform; #region Summary /*================================================================================= * If amount of unstableChar is more than messageLength, removal unstableChar at the last. * 만약 불안정문자의 수가 메시지의 길이보다 많다면, 제일 뒤에있는 불안정문자를 제거한다. *=================================================================================*/ #endregion while (messageLength < movTransform.childCount) { Undo.DestroyObjectImmediate(movTransform.GetChild(movTransform.childCount - 1).gameObject); } #region Summary /*================================================================================= * Rearrange unstableChar based on length of changed message and change the each unstableChar by changed message. * 변경된 메시지에따라 불안정문자를 재배치하고, 각 불안정문자들이 나타내는 글자를 변경한다. *=================================================================================*/ #endregion for (int i = 0; i < messageLength; i++) { if (i >= movTransform.childCount) { Movable.CreateMovableChar(i, movableText.Message[i], movableText.GetTextInfo) .transform.parent = movTransform; } Undo.RecordObject(movTransform.GetChild(i), movableText.Message); if (movableText.transform.GetChild(i).TryGetComponent(out MovableObject movable)) { movable.Setting(movableText.GetTextInfo); } movTransform.GetChild(i).SetLetterSpace(messageLength, movableText.LetterSpace, i); if (movTransform.GetChild(i).TryGetComponent(out Text text)) { Undo.RecordObject(text, "Apply to changed text"); text.text = movableText.Message[i].ToString(); } } } }
public void Init() { target = transform.parent.GetComponent<Movable>(); if (target.forDecoration) { Destroy(this.gameObject); return; } hpRed = transform.FindChild("Red").gameObject; hpBack = transform.FindChild("Hp Back").gameObject; hpBack.GetComponent<SpriteRenderer>().color = target.isOurForce ? ourForceBackColor : enemyBackColor; SetHpBar(); }
public void OnTouch() { spawnObj = selectTab.GetUnit(); if (spawnObj != null) { switch (gameObject.name) { case "Spawn Line1": spawnMgr.TrySpawnOurForce(spawnObj, 1); break; case "Spawn Line2": spawnMgr.TrySpawnOurForce(spawnObj, 2); break; case "Spawn Line3": spawnMgr.TrySpawnOurForce(spawnObj, 3); break; } } selectTab.ResetButton(); }
IEnumerator WaitAndRevival(Movable target, int line, Vector3 pos) { yield return new WaitForSeconds(1f); spawnMgr.SpawnOurForce(target, line, pos); }
public TerrainQuadTreeNode( Terrain terrain, TerrainQuadTreeNode parent, ushort xOff, ushort yOff, ushort size, ushort lod, ushort depth, ushort quadrant ) : base() { this.mTerrain = terrain; this.mParent = parent; this.mOffsetX = xOff; this.mOffsetY = yOff; this.mBoundaryX = (ushort)( xOff + size ); this.mBoundaryY = (ushort)( yOff + size ); this.mSize = size; this.mBaseLod = lod; this.mDepth = depth; this.mQuadrant = quadrant; this.mBoundingRadius = 0; this.mCurrentLod = -1; this.mMaterialLodIndex = 0; this.mLodTransition = 0; this.mChildWithMaxHeightDelta = null; this.mSelfOrChildRendered = false; this.mNodeWithVertexData = null; this.mAABB = new AxisAlignedBox(); if ( this.mTerrain.MaxBatchSize < size ) { var childSize = (ushort)( ( ( size - 1 )*0.5f ) + 1 ); var childOff = (ushort)( childSize - 1 ); var childLod = (ushort)( lod - 1 ); // LOD levels decrease down the tree (higher detail) var childDepth = (ushort)( depth + 1 ); // create children this.mChildren[ 0 ] = new TerrainQuadTreeNode( this.mTerrain, this, xOff, yOff, childSize, childLod, childDepth, 0 ); this.mChildren[ 1 ] = new TerrainQuadTreeNode( this.mTerrain, this, (ushort)( xOff + childOff ), yOff, childSize, childLod, childDepth, 1 ); this.mChildren[ 2 ] = new TerrainQuadTreeNode( this.mTerrain, this, xOff, (ushort)( yOff + childOff ), childSize, childLod, childDepth, 2 ); this.mChildren[ 3 ] = new TerrainQuadTreeNode( this.mTerrain, this, (ushort)( xOff + childOff ), (ushort)( yOff + childOff ), childSize, childLod, childDepth, 3 ); var ll = new LodLevel(); // non-leaf nodes always render with minBatchSize vertices ll.BatchSize = this.mTerrain.MinBatchSize; ll.MaxHeightDelta = 0; ll.CalcMaxHeightDelta = 0; this.mLodLevels.Add( ll ); } else { //no children Array.Clear( this.mChildren, 0, this.mChildren.Length ); // this is a leaf node and may have internal LODs of its own var ownLod = this.mTerrain.NumLodLevelsPerLeaf; Debug.Assert( lod == ( ownLod - 1 ), "The lod passed in should reflect the number of lods in a leaf" ); // leaf nodes always have a base LOD of 0, because they're always handling // the highest level of detail this.mBaseLod = 0; var sz = this.mTerrain.MaxBatchSize; while ( ownLod-- != 0 ) { var ll = new LodLevel(); ll.BatchSize = sz; ll.MaxHeightDelta = 0; ll.CalcMaxHeightDelta = 0; this.mLodLevels.Add( ll ); if ( ownLod != 0 ) { sz = (ushort)( ( ( sz - 1 )*0.5 ) + 1 ); } } Debug.Assert( sz == this.mTerrain.MinBatchSize ); } // local centre calculation // because of pow2 +1 there is always a middle point var midoffset = (ushort)( ( size - 1 )/2 ); var midpointX = (ushort)( this.mOffsetX + midoffset ); var midpointY = (ushort)( this.mOffsetY + midoffset ); //derive the local centry, but give it a height if 0 //TODO: - what if we actually centred this at the terrain height at this point? //would this be better? this.mTerrain.GetPoint( midpointX, midpointY, 0, ref this.mLocalCentre ); this.mMovable = new Movable( this ); this.mRend = new Rend( this ); }
void Start() { movable = GetComponent<Movable>(); health = GetComponent<Damageable>(); }
public void AddMovable(Movable m) { updateList.Add(m); }
public void Remove(Movable m) { if(updateList.Contains(m)) updateList.Remove(m); }
protected override void dispose( bool disposeManagedResources ) { if ( !IsDisposed ) { if ( disposeManagedResources ) { if ( this.mMovable != null ) { if ( !this.mMovable.IsDisposed ) { this.mMovable.Dispose(); } this.mMovable = null; } if ( this.mRend != null ) { this.mRend = null; } if ( this.mLocalNode != null ) { this.mTerrain.RootSceneNode.RemoveAndDestroyChild( this.mLocalNode.Name ); this.mLocalNode = null; } for ( int i = 0; i < this.mChildren.Length; i++ ) { if ( this.mChildren[ i ] != null ) { this.mChildren[ i ].Dispose(); } } DestroyCpuVertexData(); DestroyGpuVertexData(); DestroyGpuIndexData(); if ( this.mLodLevels != null ) { this.mLodLevels.Clear(); this.mLodLevels = null; } this.mVertexDataRecord = null; } } base.dispose( disposeManagedResources ); }
public void SpawnOurForce(Movable obj, int line) { Instantiate(obj, ourForceLinePos[line - 1], new Quaternion()); orderMgr.UpdateOrder(line); }
void Start() { movable = GetComponent<Movable>(); animator = GetComponent<Animator>(); }
public int[] ShortestDepotPath(int[] startInd, Movable mover) { int[] shortestInd = null; float shortestLen = Mathf.Infinity; foreach (int[] stopInd in depots) { float len = mover.TravelDistance (stopInd); if (len < shortestLen && mover.CanReach (stopInd)) { shortestInd = stopInd; shortestLen = len; } } return shortestInd; }
// Use this for initialization void Start() { player = GetComponent<Movable>(); TurnRight(); }