//float now;
float GetDistToTarget(AutoTile targetTile)
{
Vector3 target = RpgMapHelper.GetTileCenterPosition(targetTile.TileX, targetTile.TileY);
target.z = transform.position.z;
return((transform.position - target).magnitude);
}
void FixedUpdate()
{
Vector3 vTarget = m_pathFindingBehaviour.TargetPos;
//vTarget = RpgMapHelper.GetTileCenterPosition(vTarget);
vTarget.z = transform.position.z;
// stop when target position has been reached
Vector3 vDist = (vTarget - transform.position);
Debug.DrawLine(vTarget, transform.position); //TODO: the target is the touch position, not the target tile center. Fix this to go to target position once in the target tile
if (m_pathFindingBehaviour.IsComputingPath)
{
;// do nothing
}
else
{
bool isInTargetTile = RpgMapHelper.GetTileIdxByPosition(vTarget) == RpgMapHelper.GetTileIdxByPosition(transform.position);
if (isInTargetTile || m_pathFindingBehaviour.CurrentPathNode != null && m_pathFindingBehaviour.CurrentPathNode.Next == null)
{
m_pathFindingBehaviour.enabled = false;
if (vDist.magnitude > MinDistToReachTarget)
{
m_moving.Arrive(vTarget);
}
else
{
m_moving.Veloc = Vector3.zero;
}
}
}
UpdateAnimDir();
}
public void ActivateTrigger(eTrigger trigger)
{
if (m_CurTile == null) return;
Vector2 targetMapPos = new Vector2(m_CurTile.TileX, m_CurTile.TileY);
switch (trigger)
{
case eTrigger.MoveDown:
targetMapPos.y += 1;
break;
case eTrigger.MoveLeft:
targetMapPos.x -= 1;
break;
case eTrigger.MoveRight:
targetMapPos.x += 1;
break;
case eTrigger.MoveUp:
targetMapPos.y -= 1;
break;
}
if (PlayerState == eState.Idle && (targetMapPos.x != m_CurTile.TileX || targetMapPos.y != m_CurTile.TileY))
{
if (AutoTileMap.Instance.GetCellAutotileCollision((int)targetMapPos.x, (int)targetMapPos.y) == eTileCollisionType.PASSABLE)
{
Vector3 vTargetPos = RpgMapHelper.GetTileCenterPosition((int)targetMapPos.x, (int)targetMapPos.y);
TargetTile = RpgMapHelper.GetAutoTileByPosition(vTargetPos, 0);
m_fAxisX = TargetTile.TileX - m_CurTile.TileX; m_fAxisX = m_fAxisX != 0 ? Mathf.Sign(m_fAxisX) : 0;
m_fAxisY = TargetTile.TileY - m_CurTile.TileY; m_fAxisY = m_fAxisY != 0 ? Mathf.Sign(m_fAxisY) : 0;
SetState(eState.Moving);
}
}
}
void Start()
{
m_animCtrl = GetComponents <DirectionalAnimation>()[0];
m_phyChar = GetComponent <PhysicCharBehaviour>();
TargetTile = RpgMapHelper.GetAutoTileByPosition(transform.position, 0);
ableToMove = true;
}
void Update()
{
m_CurTile = RpgMapHelper.GetAutoTileByPosition(transform.position, 0);
if (TargetTile == null) TargetTile = m_CurTile;
_DoStateLogic();
}
protected override void Update()
{
eAnimDir savedAnimDir = m_animCtrl.AnimDirection;
base.Update();
/*
* if(m_keepAttackDirTimer > 0f)
* {
* m_keepAttackDirTimer -= Time.deltaTime;
* m_animCtrl.AnimDirection = savedAnimDir;
* }
*/
m_phyChar.enabled = (Vehicle == null);
if (Vehicle != null)
{
m_animCtrl.IsPlaying = false;
}
else
{
// character mouse direction
Vector3 dir = Input.mousePosition - Camera.main.WorldToScreenPoint(transform.position);
if (dir.x > 0)
{
m_animCtrl.AnimDirection = eAnimDir.Right;
}
else if (dir.x < 0)
{
m_animCtrl.AnimDirection = eAnimDir.Left;
}
if (Input.GetKeyDown("r")) // mousebuttondown(0)
{
weaponH.Shoot();
}
bool isMoving = (m_phyChar.Dir.sqrMagnitude >= 0.01);
if (isMoving)
{
//m_phyChar.Dir.Normalize();
m_camera2DFollowBehaviour.Target = transform;
}
else
{
m_phyChar.Dir = Vector3.zero;
}
}
int tileIdx = RpgMapHelper.GetTileIdxByPosition(transform.position);
if (tileIdx != m_lastTileIdx || m_lastFogSightLength != FogSightLength)
{
RpgMapHelper.RemoveFogOfWarWithFade(transform.position, FogSightLength);
}
m_lastFogSightLength = FogSightLength;
m_lastTileIdx = tileIdx;
}
float GetDistToTarget(AutoTile targetTile)
{
Vector3 target = m_curNode.Next != null?RpgMapHelper.GetTileCenterPosition(targetTile.TileX, targetTile.TileY) : (Vector3)TargetPos;
target.z = transform.position.z;
float dist = (transform.position - target).magnitude;
return(dist);
}
// public bool IsPassable()
// {
// AutoTileMap autoTileMap = AutoTileMap.Instance;
//
// if (autoTileMap.IsValidAutoTilePos(TileX, TileY))
// {
// for( int iLayer = autoTileMap.GetLayerCount() - 1; iLayer >= 0; --iLayer )
// {
// if( autoTileMap.MapLayers[iLayer].LayerType == eLayerType.Ground )
// {
// AutoTile autoTile = autoTileMap.GetAutoTile(TileX, TileY, iLayer);
// eTileCollisionType collType = autoTile.Id >= 0 ? autoTileMap.Tileset.AutotileCollType[autoTile.Id] : eTileCollisionType.EMPTY;
// if( collType == eTileCollisionType.PASSABLE || collType == eTileCollisionType.WALL )
// {
// return true;
// }
// else if( collType == eTileCollisionType.BLOCK || collType == eTileCollisionType.FENCE )
// {
// return false;
// }
// }
// }
// }
// return false;
// }
//A* Style pathfinding
public Vector3 findPath()
{
AutoTile m_CurTile;
AutoTile m_CurTile2;
AutoTile m_CurTile3;
Vector3 targetMapPos;
float[,] map = new float[3, 3]; //Represents the 8 surrounding the object
float idx = -(1f * .32f); //far left tile Column
float idy = (1f * .32f); //Top most Row of tiles
float lowest = 100f;
low = new Vector3(0f, 0f, 0f);
//Loops through each row
for (int i = 0; i < 3; i++)
{
//Loops through each tile in this row
for (int j = 0; j < 3; j++)
{
float temp = Vector3.Distance(this.transform.position + new Vector3(idx, idy, 0f), targetTile);
map [i, j] = temp;
m_CurTile = RpgMapHelper.GetAutoTileByPosition(this.transform.position + new Vector3(idx, idy, 0f), 0);
m_CurTile2 = RpgMapHelper.GetAutoTileByPosition(this.transform.position + new Vector3(idx, idy, 0f), 1);
m_CurTile3 = RpgMapHelper.GetAutoTileByPosition(this.transform.position + new Vector3(idx, idy, 0f), 2);
//targetMapPos = new Vector2(m_CurTile.TileX, m_CurTile.TileY);
targetMapPos = RpgMapHelper.GetTileCenterPosition(m_CurTile.TileX, m_CurTile.TileY);
eTileCollisionType collType = AutoTileMap.Instance.GetAutotileCollisionAtPosition(targetMapPos);
eTileCollisionType collType2 = AutoTileMap.Instance.GetAutotileCollisionAtPosition(targetMapPos);
eTileCollisionType collType3 = AutoTileMap.Instance.GetAutotileCollisionAtPosition(targetMapPos);
if ((i == 0 && j == 0) || (i == 2 && j == 0) || (i == 0 && j == 2) || (i == 2 && j == 2) || (i == 1 && j == 1) ||
collType != eTileCollisionType.PASSABLE
)
{
temp = 100f;
}
if (temp < lowest)
{
lowest = temp;
low = new Vector3(idx, idy, 0f);
}
idx += .32f;
}
idy -= .32f;
idx = -.32f;
}
Vector3 decision = low;
return(decision);
}
void Update()
{
// if (!ableToMove) {
// TargetTile = null;
// }
m_CurTile = RpgMapHelper.GetAutoTileByPosition(transform.position, 0);
if (TargetTile == null)
{
TargetTile = m_CurTile;
}
_DoStateLogic();
}
protected override void Update()
{
eAnimDir savedAnimDir = m_animCtrl.AnimDirection;
base.Update();
if (m_keepAttackDirTimer > 0f)
{
m_keepAttackDirTimer -= Time.deltaTime;
m_animCtrl.AnimDirection = savedAnimDir;
}
m_phyChar.enabled = (Vehicle == null);
if (Vehicle != null)
{
m_animCtrl.IsPlaying = false;
}
else
{
DoInputs();
bool isMoving = (m_phyChar.Dir.sqrMagnitude >= 0.01);
if (isMoving)
{
//m_phyChar.Dir.Normalize();
m_camera2DFollowBehaviour.Target = transform;
}
else
{
m_phyChar.Dir = Vector3.zero;
}
}
int tileIdx = RpgMapHelper.GetTileIdxByPosition(transform.position);
if (tileIdx != m_lastTileIdx || m_lastFogSightLength != FogSightLength)
{
RpgMapHelper.RemoveFogOfWarWithFade(transform.position, FogSightLength);
}
m_lastFogSightLength = FogSightLength;
m_lastTileIdx = tileIdx;
}
private void _DoStateLogic()
{
switch (PlayerState)
{
case eState.Idle:
UpdateMovement(0, 0);
transform.position = RpgMapHelper.GetTileCenterPosition(m_CurTile.TileX, m_CurTile.TileY) + new Vector3(0, 0, transform.position.z);
break;
case eState.Moving:
UpdateMovement(m_fAxisX, -m_fAxisY);
Vector3 vCheckPos = transform.position - new Vector3((AutoTileMap.Instance.CellSize.x / 2) * m_fAxisX, -(AutoTileMap.Instance.CellSize.y / 2) * m_fAxisY);
AutoTile checkTile = RpgMapHelper.GetAutoTileByPosition(vCheckPos, 0);
if (checkTile == TargetTile)
{
transform.position = RpgMapHelper.GetTileCenterPosition(TargetTile.TileX, TargetTile.TileY) + new Vector3(0, 0, transform.position.z);
SetState(eState.Idle);
}
break;
}
}
internal MapTileNode(int idx, MapPathFinding owner)
{
m_owner = owner;
TileIdx = idx;
TileX = idx % AutoTileMap.Instance.MapTileWidth;
TileY = idx / AutoTileMap.Instance.MapTileWidth;
Position = RpgMapHelper.GetTileCenterPosition(TileX, TileY);
// get all neighbors row by row, neighIdx will be the idx of left most tile per each row
int neighIdx = (idx-1)-AutoTileMap.Instance.MapTileWidth;
for (int i = 0; i < 3; ++i, neighIdx += AutoTileMap.Instance.MapTileWidth)
{
for (int j = 0; j < 3; ++j)
{
if (i != 1 || j != 1) // skip this node
{
m_neighborIdxList.Add(neighIdx + j);
}
}
}
}
protected void FixedUpdate()
{
if (m_curNode != null)
{
MapTileNode curTileNode = m_curNode.Value as MapTileNode;
AutoTile autoTile = RpgMapHelper.GetAutoTileByPosition(transform.position, 0);
if (
(autoTile.TileX != curTileNode.TileX || autoTile.TileY != curTileNode.TileY) ||
GetDistToTarget(autoTile) > MinDistToMoveNextTarget // wait until min dist is reached
)
{
Vector3 vSeek = curTileNode.Position; vSeek.z = transform.position.z; // put at this object level
if (m_movingBehavior)
{
if (m_curNode.Next != null)
{
m_movingBehavior.Seek(vSeek);
}
else
{
m_movingBehavior.Arrive(vSeek);
}
}
}
else
{
m_curNode = m_curNode.Next;
}
}
//if (TargetPos != null) //TODO: TargetPos can't be null
{
int prevTileidx = m_startTileIdx;
m_startTileIdx = RpgMapHelper.GetTileIdxByPosition(TargetPos);
m_isUpdatePath |= prevTileidx != m_startTileIdx;
if (m_isUpdatePath)//|| !m_isComputing) //Removed to keep actor moving until reach the center of the node
{
m_isUpdatePath = false;
m_endTileIdx = RpgMapHelper.GetTileIdxByPosition(transform.position);
//now = Time.realtimeSinceStartup;
StopCoroutine("ComputePath");
StartCoroutine("ComputePath");
}
}
//+++ Debug
for (LinkedListNode <IPathNode> it = Path.First; it != null; it = it.Next)
{
MapTileNode mapTileNode0 = it.Value as MapTileNode;
if (it.Next != null)
{
MapTileNode mapTileNode1 = it.Next.Value as MapTileNode;
Vector3 v0 = mapTileNode0.Position;
Vector3 v1 = mapTileNode1.Position;
v0.z = transform.position.z;
v1.z = transform.position.z;
Debug.DrawLine(v0, v1, Color.red);
}
}
//---
}
protected override void Update()
{
if (m_playerCtrl == null)
{
return;
}
Color textColor = HelpText.GetComponent <Renderer>().material.color;
textColor.a = Mathf.Clamp(0.2f + Mathf.Abs(Mathf.Sin(0.05f * Time.frameCount)), 0f, 1f);
HelpText.GetComponent <Renderer>().material.color = textColor;
if (m_isLanding)
{
if (VehicleType == eVehicleType.Aircraft)
{
m_altitude = Mathf.Lerp(MaxAltitude, 0f, LandingTime * (1 - m_altitude / MaxAltitude) + Time.deltaTime);
//m_altitude -= m_altitude / 20;
if (m_altitude <= 0.01)
{
m_altitude = 0;
m_playerCtrl.SetVisible(true);
}
}
}
else
{
// Empty vehicle logic
if (m_playerCtrl.Vehicle == null)
{
Vector3 vPos = transform.position;
bool isPlayerCloseEnough = false;
if (VehicleType == eVehicleType.Boat)
{
m_animCtrl.IsPlaying = true; //Force to always animate
Rect rVert = new Rect(vPos.x + phyChar.CollRect.x, vPos.y + phyChar.CollRect.y - phyChar.CollRect.height, phyChar.CollRect.width, 3 * phyChar.CollRect.height);
Rect rHor = new Rect(vPos.x + phyChar.CollRect.x - phyChar.CollRect.width, vPos.y + phyChar.CollRect.y, 3 * phyChar.CollRect.width, phyChar.CollRect.height);
RpgMapHelper.DebugDrawRect(Vector3.zero, rVert, Color.blue);
RpgMapHelper.DebugDrawRect(Vector3.zero, rHor, Color.green);
isPlayerCloseEnough = rVert.Contains(m_playerCtrl.transform.position) || rHor.Contains(m_playerCtrl.transform.position);
}
else //if (VehicleType == eVehicleType.Aircraft)
{
m_animCtrl.IsPlaying = false; //Force to don't animate
Rect rect = new Rect(vPos.x + phyChar.CollRect.x, vPos.y + phyChar.CollRect.y - phyChar.CollRect.height / 3, phyChar.CollRect.width, phyChar.CollRect.height);
RpgMapHelper.DebugDrawRect(Vector3.zero, rect, Color.blue);
isPlayerCloseEnough = rect.Contains(m_playerCtrl.transform.position);
}
HelpText.GetComponent <Renderer>().enabled = isPlayerCloseEnough;
if (isPlayerCloseEnough)
{
if (Input.GetKeyDown(KeyCode.Return))
{
m_playerCtrl.Vehicle = this;
HelpText.GetComponent <Renderer>().enabled = false;
m_playerCtrl.SetVisible(VehicleType == eVehicleType.Boat);
if (VehicleType == eVehicleType.Aircraft)
{
m_phyChar.IsCollEnabled = false;
}
}
}
}
// Occupied vehicle logic
else if (m_playerCtrl.Vehicle == this)
{
base.Update();
m_animCtrl.IsPlaying = true; //Force to always animate
if (VehicleType == eVehicleType.Aircraft)
{
m_altitude = Mathf.Lerp(0f, MaxAltitude, LandingTime * (m_altitude / MaxAltitude) + Time.deltaTime);
int sightLength = (int)(MaxAltitudeSightLength * (m_altitude / MaxAltitude));
int tileIdx = RpgMapHelper.GetTileIdxByPosition(transform.position);
if (tileIdx != m_lastTileIdx || m_lastFogSightLength != sightLength)
{
RpgMapHelper.RemoveFogOfWarWithFade(transform.position, sightLength);
}
m_lastFogSightLength = sightLength;
m_lastTileIdx = tileIdx;
}
if (Input.GetKeyDown(KeyCode.Return))
{
int dir = VehicleType == eVehicleType.Boat ? (int)m_playerCtrl.AnimCtrl.AnimDirection : (int)eAnimDir.Down;
Vector3 vDir = VehicleType == eVehicleType.Boat ? m_playerCtrl.AnimCtrl.GetAnimDirection() : new Vector2(0, -0.5f);
float fMult = _landingMult[dir >> 1]; // divide dir by two, because eAnimDir have 8 directions and this way it is translated to a 4 direction index
Vector3 vLandingPos = transform.position + fMult * vDir * AutoTileMap.Instance.CellSize.x;
vLandingPos.z = m_playerCtrl.transform.position.z;
bool isColliding = m_playerCtrl.PhyCtrl.IsColliding(vLandingPos);
RpgMapHelper.DebugDrawRect(vLandingPos, m_playerCtrl.PhyCtrl.CollRect, isColliding ? Color.red : Color.blue, 0.5f);
if (VehicleType == eVehicleType.Aircraft)
{
isColliding |= PhyCtrl.IsColliding(transform.position);
RpgMapHelper.DebugDrawRect(transform.position, PhyCtrl.CollRect, isColliding ? Color.red : Color.blue, 0.5f);
}
isColliding |= RpgMapHelper.GetAutoTileByPosition(vLandingPos, 0).IsWaterTile();
if (!isColliding)
{
m_vLandingPos = vLandingPos;
m_isLanding = true;
PhyCtrl.Dir = Vector3.zero;
}
}
}
}
Vector3 vAnimSprPos = AnimCtrl.TargetSpriteRenderer.transform.localPosition;
vAnimSprPos.y = m_altitude;
AnimCtrl.TargetSpriteRenderer.transform.localPosition = vAnimSprPos;
if (ShadowSprite != null)
{
float scale = (MaxAltitude - m_altitude / 3);
ShadowSprite.transform.localScale = new Vector3(scale, scale, scale);
}
//+++fix overlay layer problem while landing
if (VehicleType == eVehicleType.Aircraft)
{
Vector3 vCheckPos = m_animCtrl.TargetSpriteRenderer.transform.position;
//Debug.DrawRay( vCheckPos, Vector3.right, Color.red );
int bottomTile = RpgMapHelper.GetAutoTileByPosition(vCheckPos, 2).Id;
vCheckPos.y += AutoTileMap.Instance.CellSize.y;
//Debug.DrawRay(vCheckPos, Vector3.right, Color.green);
int topTile = RpgMapHelper.GetAutoTileByPosition(vCheckPos, 2).Id;
if (
(bottomTile < 0 && topTile >= 0 && m_altitude > 0.30f) || // bottom tile is not overlay and top tile is overlay
(m_altitude > 0.02f && bottomTile < 0) // taking off set Z over overlay layer only after bottom tile is not overlay
)
{
GetComponent <IsoSpriteController>().enabled = false;
Vector3 vSprPos = m_animCtrl.TargetSpriteRenderer.transform.position;
vSprPos.z = AutoTileMap.Instance.FindLastLayer(eLayerType.Overlay).Depth - 0.1f;
m_animCtrl.TargetSpriteRenderer.transform.position = vSprPos;
}
else if (m_altitude <= 0.8)
{ // found an overlay tile? enable IsoSpriteController to adjust Z under overlay layer
GetComponent <IsoSpriteController>().enabled = true;
}
}
//---
}
/// <summary>
/// Reveal an area using as center, the tile over worldPosition and a sight length in tiles (sightLength)
/// Uses a coroutine to make a fade transition
/// </summary>
/// <param name="worldPosition">The center tile</param>
/// <param name="sightLength">The sight length in tiles</param>
public static void RemoveFogOfWarWithFade(Vector3 worldPosition, int sightLength)
{
float sqrMaxDist = sightLength * sightLength * 4;
int iFogLayer = AutoTileMap.Instance.MapLayers.FindIndex(x => x.LayerType == AutoTileMap.eLayerType.FogOfWar);
if (iFogLayer >= 0)
{
AutoTileMap.AutoTile centerTile = RpgMapHelper.GetAutoTileByPosition(worldPosition, iFogLayer);
for (int yf = -sightLength; yf <= sightLength; ++yf)
{
for (int xf = -sightLength; xf <= sightLength; ++xf)
{
int tx = centerTile.TileX + xf;
int ty = centerTile.TileY + yf;
if (AutoTileMap.Instance.IsValidAutoTilePos(tx, ty)) // This extra check is needed with fog of war layer
{
byte[] aFogAlpha = new byte[4];
for (int i = 0; i < aFogAlpha.Length; ++i)
{
//NOTE: for the fog level, each tile is divided in 4 tileparts.
// The index i of each tile part is:
// 0|2
// 1|3
int xf2 = 0;
if (xf < 0)
{
xf2 = (i == 0 || i == 1) ? 2 * -xf : 2 * -xf - 1; //NOTE: 0, 1 are the left tile parts
}
else if (xf > 0)
{
xf2 = (i == 2 || i == 3) ? 2 * xf : 2 * xf - 1;
}
else //if( xf == 0 )
{
xf2 = 0;
}
int yf2 = 0;
if (yf < 0)
{
yf2 = (i == 0 || i == 2) ? 2 * -yf : 2 * -yf - 1;
}
else if (yf > 0)
{
yf2 = (i == 1 || i == 3) ? 2 * yf : 2 * yf - 1;
}
else //if( xf == 0 )
{
yf2 = 0;
}
float sqrDist = xf2 * xf2 + yf2 * yf2;
//NOTE: sqrDist = [0..(sightAreaSize*2)^2]
float fAlphaFactor = Mathf.Clamp01(sqrDist / sqrMaxDist);
fAlphaFactor *= fAlphaFactor;
byte fogAlpha = (byte)(0xff * fAlphaFactor);
aFogAlpha[i] = fogAlpha;
}
AutoTileMap.Instance.AddFogOfWarSetToQueue(tx + ty * AutoTileMap.Instance.MapTileWidth, aFogAlpha);
}
}
}
AutoTileMap.Instance.RefreshMinimapTexture(centerTile.TileX - sightLength, centerTile.TileY - sightLength, 2 * sightLength, 2 * sightLength);
}
}
protected override void Update()
{
int tileIdx = RpgMapHelper.GetTileIdxByPosition(transform.position);
if (tileIdx != m_lastTileIdx || m_lastFogSightLength != FogSightLength)
{
RpgMapHelper.RemoveFogOfWarWithFade(transform.position, FogSightLength);
}
m_lastFogSightLength = FogSightLength;
m_lastTileIdx = tileIdx;
if (teleporting == true && UnityEngine.SceneManagement.SceneManager.GetActiveScene().name == newScene)
{
teleporting = false;
teleport();
}
Vector3 savedDir = m_phyChar.Dir;
m_phyChar.Dir = savedDir;
m_tileMovementBehaviour.enabled = (Vehicle == null);
//DirectionalAnimation[] anims = GetComponentsInChildren<DirectionalAnimation> ();
if (m_tileMovementBehaviour.enabled)
{
if (Input.GetKey(KeyCode.Space) && canMove)
{
attack.enabled = true;
attack.SetAnimDirection(currDir);
attack.IsPlaying = true;
attacking();
attack.OnAnimationLoopOver += reset;
canMove = false;
}
else if (canMove)
{
if (Input.GetKey(KeyCode.RightArrow))
{
if (Input.GetAxis("Horizontal") < .2)
{
m_animCtrl.SetAnimDirection(Vector3.right);
currDir = Vector3.right;
// for (int i = 0; i < anims.Length; i++) {
//
// anims[i].SetAnimDirection(Vector3.right);
// }
}
else
{
m_animCtrl.SetAnimDirection(Vector3.right);
currDir = Vector3.right;
m_tileMovementBehaviour.ActivateTrigger(TileMovementBehaviour.eTrigger.MoveRight);
}
}
else if (Input.GetKey(KeyCode.LeftArrow))
{
if (Mathf.Abs(Input.GetAxis("Horizontal")) < .2)
{
m_animCtrl.SetAnimDirection(Vector3.left);
currDir = Vector3.left;
// for (int i = 0; i < anims.Length; i++) {
//
// anims[i].SetAnimDirection(Vector3.left);
// }
}
else
{
m_animCtrl.SetAnimDirection(Vector3.left);
currDir = Vector3.left;
m_tileMovementBehaviour.ActivateTrigger(TileMovementBehaviour.eTrigger.MoveLeft);
}
}
else if (Input.GetKey(KeyCode.UpArrow))
{
if (Input.GetAxis("Vertical") < .2)
{
m_animCtrl.SetAnimDirection(Vector3.up);
currDir = Vector3.up;
// for (int i = 0; i < anims.Length; i++) {
//
// anims[i].SetAnimDirection(Vector3.up);
// }
}
else
{
m_animCtrl.SetAnimDirection(Vector3.up);
currDir = Vector3.up;
m_tileMovementBehaviour.ActivateTrigger(TileMovementBehaviour.eTrigger.MoveUp);
}
}
else if (Input.GetKey(KeyCode.DownArrow))
{
if (Mathf.Abs(Input.GetAxis("Vertical")) < .2)
{
m_animCtrl.SetAnimDirection(Vector3.down);
currDir = Vector3.down;
// for (int i = 0; i < anims.Length; i++) {
//
// anims[i].SetAnimDirection(Vector3.down);
// }
}
else
{
m_animCtrl.SetAnimDirection(Vector3.down);
currDir = Vector3.down;
m_tileMovementBehaviour.ActivateTrigger(TileMovementBehaviour.eTrigger.MoveDown);
}
}
}
}
}
// Update is called once per frame
void Update()
{
Vector3 vPlayerPos = m_player.transform.position; vPlayerPos.z = transform.position.z;
Ray2D sightRay = new Ray2D(transform.position, vPlayerPos - transform.position);
float distToTarget = Vector2.Distance(vPlayerPos, transform.position);
float fSightBlockedDist = IsSightBlockedByBlockedTiles? RpgMapHelper.Raycast(sightRay, distToTarget) : -1f;
// NOTE: fSightBlockedDist will be -1f if sight line is not blocked by blocked collision tile
bool isPlayerSeen = distToTarget < SightDistance && fSightBlockedDist == -1f;
if (isPlayerSeen)
{
m_pathFindingBehaviour.TargetPos = vPlayerPos;
}
bool isTargetReached = Vector2.Distance(m_pathFindingBehaviour.TargetPos, transform.position) <= MinDistToReachTarget;
if (!isPlayerSeen && isTargetReached)
{
// Move around
m_pathFindingBehaviour.enabled = false;
vPlayerPos = transform.position;
m_fAngOff += Random.Range(-AngRandOff, AngRandOff);
Vector3 vOffset = Quaternion.AngleAxis(m_fAngOff, Vector3.forward) * (AngRandRadious * Vector3.right);
vPlayerPos += vOffset;
m_moving.Arrive(vPlayerPos);
}
else // Follow the player
{
// stop following the path when closed enough to target
m_pathFindingBehaviour.enabled = !isTargetReached;
if (!m_pathFindingBehaviour.enabled)
{
m_fAngOff += Random.Range(-AngRandOff, AngRandOff);
Vector3 vOffset = Quaternion.AngleAxis(m_fAngOff, Vector3.forward) * (AngRandRadious * Vector3.right);
vPlayerPos += vOffset;
Debug.DrawLine(transform.position, m_player.transform.position, Color.blue);
Debug.DrawRay(m_player.transform.position, vOffset, Color.blue);
m_moving.Arrive(vPlayerPos);
}
}
//+++avoid obstacles
Vector3 vTurnVel = Vector3.zero;
if (0 != (m_phyChar.CollFlags & PhysicCharBehaviour.eCollFlags.RIGHT))
{
vTurnVel.x = -m_moving.MaxSpeed;
}
else if (0 != (m_phyChar.CollFlags & PhysicCharBehaviour.eCollFlags.LEFT))
{
vTurnVel.x = m_moving.MaxSpeed;
}
if (0 != (m_phyChar.CollFlags & PhysicCharBehaviour.eCollFlags.DOWN))
{
vTurnVel.y = m_moving.MaxSpeed;
}
else if (0 != (m_phyChar.CollFlags & PhysicCharBehaviour.eCollFlags.UP))
{
vTurnVel.y = -m_moving.MaxSpeed;
}
if (vTurnVel != Vector3.zero)
{
m_moving.ApplyForce(vTurnVel - m_moving.Veloc);
}
//---
//fix to avoid flickering of the creature when collides with wall
if (Time.frameCount % 16 == 0)
//---
{
if (!LockAnimDir)
{
UpdateAnimDir();
}
}
}
protected override void Update()
{
eAnimDir savedAnimDir = m_animCtrl.AnimDirection;
if (!PhotonView.isMine)
{
return;
}
base.Update();
/*
* if(m_keepAttackDirTimer > 0f)
* {
* m_keepAttackDirTimer -= Time.deltaTime;
* m_animCtrl.AnimDirection = savedAnimDir;
* }
*/
m_phyChar.enabled = (Vehicle == null);
if (Vehicle != null)
{
m_animCtrl.IsPlaying = false;
}
else
{
if (Input.GetAxis("Mouse ScrollWheel") != 0f)
{
weaponH.Change();
}
// character mouse direction
Vector3 dir = Input.mousePosition - Camera.main.WorldToScreenPoint(transform.position);
if (!isForce)
{
if (dir.x > 0)
{
m_animCtrl.AnimDirection = eAnimDir.Right;
if (currentDir == 0)
{
// right
weaponH.reverseDirection(1);
currentDir = 1;
}
}
else if (dir.x < 0)
{
m_animCtrl.AnimDirection = eAnimDir.Left;
if (currentDir == 1)
{
// left
weaponH.reverseDirection(0);
currentDir = 0;
}
}
}
// 재장전
if (Input.GetKey("r"))
{
weaponH.Reload();
}
// 무기 버리기
if (Input.GetKey("g"))
{
weaponH.DropGun();
}
if (Input.GetMouseButtonDown(0)) // mousebuttondown(0)
{
weaponH.Shoot();
}
bool isMoving = (m_phyChar.Dir.sqrMagnitude >= 0.01);
if (isMoving)
{
//m_phyChar.Dir.Normalize();
m_camera2DFollowBehaviour.Target = transform;
}
else
{
m_phyChar.Dir = Vector3.zero;
}
}
int tileIdx = RpgMapHelper.GetTileIdxByPosition(transform.position);
if (tileIdx != m_lastTileIdx || m_lastFogSightLength != FogSightLength)
{
RpgMapHelper.RemoveFogOfWarWithFade(transform.position, FogSightLength);
}
m_lastFogSightLength = FogSightLength;
m_lastTileIdx = tileIdx;
}
