// Use this for initialization
public void Init(Vector3 start, Vector3 end, UnitAttack attack, float altitude = 0.0f)
{
transform.position = start;
this.attack = attack;
move = GetComponent <UnitMove> ();
move.Init(end, altitude);
}
void Awake()
{
audioSource = GetComponent<AudioSource>();
animator = GetComponent<Animator>();
_unitMoveScript = GetComponent<UnitMove>();
self = GetComponent<AttackingUnit>();
}
// Use this for initialization
void Awake()
{
_unitCtrl = GetComponent <UnitController>();
_unitMove = GetComponent<UnitMove>();
_unitAttack = GetComponent<UnitAttack>();
_unitSpine = GetComponentInChildren<UnitSpine>() ? GetComponentInChildren<UnitSpine>() : null;
}
// ===========================================
protected void Init()
{
unitCharacter = gameObject.GetComponent <UnitCharacter>();
unitMove = gameObject.GetComponent <UnitMove>();
_AllTiles = GameObject.FindGameObjectsWithTag("Terrain Tile");
turnManager = FindObjectOfType <TurnManager>();
}
private List <MapNode> GetPath(Board board, MapNode source, BoardMove boardMove, List <KeyValuePair <MapNode, double> > orderedDistances, Func <MapNode, bool> predicate)
{
var allMoves = board.GetUnitMoves();
foreach (MapNode currentTarget in orderedDistances.Select(kvp => kvp.Key)
.Where(predicate))
{
IEnumerable <UndirectedEdge <MapNode> > rawPath;
if (!_predecessorObserver.TryGetPath(currentTarget, out rawPath))
{
continue;
}
List <MapNode> path = MakePathList(source, currentTarget, rawPath);
MapNode adjacentTarget = path[1];
UnitMove unitMove = allMoves.FirstOrDefault(um => um.Edge.Target == adjacentTarget && um.Edge.Source == source);
if (boardMove == null || boardMove.CurrentlyAllowsFallSpring(unitMove))
{
return(path);
}
}
// couldn't find anything
return(null);
}
private void GetComponent()
{
gameManager = FindObjectOfType <GameManager>();
unitAnimator = GetComponent <UnitAnimator>();
unitMove = GetComponent <UnitMove>();
statusController = GetComponent <StatusController>();
}
void Start()
{
unitController = GetComponent <UnitController>();
unitAnimator = GetComponent <UnitAnimator>();
unitMove = GetComponent <UnitMove>();
statusController = GetComponent <StatusController>();
}
// Start is called before the first frame update
void Start()
{
count = 0;
time = 0;
hitfrag = false;
enemys = new Dictionary <int, GameObject>();
unitMove = gameObject.transform.parent.GetComponent <UnitMove>();
}
public override void GetReachableTiles(UnitMove move, HashSet <Tile> reachTiles, Unit team)
{
if (move.moveType != MoveType.flying)
{
return;
}
base.GetReachableTiles(move, reachTiles, team);
}
public override void GetReachableTiles(UnitMove move, HashSet <Tile> reachTiles, Unit team)
{
if (_open)
{
base.GetReachableTiles(move, reachTiles, team);
}
return;
}
public void Init()
{
unitMove = gameObject.GetComponent <UnitMove>();
unitAttack = gameObject.GetComponent <UnitAttack>();
turnManager = FindObjectOfType <TurnManager>();
_Ui = FindObjectOfType <CurrentCharacterInformation>();
TurnManager.AddUnitToGame(gameObject.tag, this);
}
// Update is called once per frame
void Update()
{
coolNow -= Time.deltaTime;
if (stat.GetAlive() && autoATKEnabled)
{
if (target != null)
{
Vector3 unitPos = new Vector3(transform.position.x, 0, transform.position.z);
Vector3 targetPos = new Vector3(target.transform.position.x, 0, target.transform.position.z);
RaycastHit hit;
bool isCol = false;
if (Physics.Raycast(transform.position + transform.up, transform.TransformDirection(Vector3.forward), out hit, atkRange))
{
GameObject hitObject = hit.transform.gameObject;
if (hitObject == target.gameObject)
{
isCol = true;
}
}
if (Vector3.Distance(unitPos, targetPos) <= atkRange || isCol)
{
UnitMove uni = GetComponent <UnitMove>();
uni.OrderMove(Vector3.one);
this.transform.LookAt(target.transform);
this.transform.rotation = Quaternion.Euler(0, this.transform.eulerAngles.y, 0);
CommandATK();
}
else
{
UnitMove mover = GetComponent <UnitMove>();
mover.OrderMove(target.transform.position);
}
if (target == null || !target.GetAlive())
{
target = null;
}
}
else
{
Collider[] hitColliders = Physics.OverlapSphere(transform.position, atkNotice);
int i = 0;
while (i < hitColliders.Length)
{
UnitStatSystem enemyStat = hitColliders[i].GetComponent <UnitStatSystem>();
if (enemyStat != null && stat.GetOwner() != enemyStat.GetOwner() && !AllianceSystem.CheckAlly(stat.GetOwner(), enemyStat.GetOwner()) && enemyStat.GetAlive())
{
target = enemyStat;
Debug.Log("Found Enemy");
}
i++;
}
}
}
else
{
target = null;
}
}
void ClearSelectedUnits()
{
foreach (GameObject g in selectedUnits)
{
UnitMove u = g.GetComponent <UnitMove>();
u.DeSelectUnit();
}
selectedUnits.Clear();
}
private void OnTriggerEnter(Collider other)
{
if (other.gameObject.CompareTag("Monster"))
{
UnitMove attackedTarget = other.GetComponent <UnitMove>();
attackedTarget.HP -= Constants.GetNumber.baseATK;
Destroy(gameObject);
}
}
public Unit()
{
mUp = MoveUp;
mDown = MoveDown;
mLeft = MoveLeft;
mRight = MoveRight;
ascii = 'U';
}
private void OnDrawGizmos()
{
Transform tr = transform;
UnitMove unitMove = GetComponent <UnitMove>();
Handles.color = col;
Handles.DrawSolidArc(tr.position + Vector3.up * 1.5f, Vector3.up, -transform.right + transform.forward, 90, unitMove.rayDistance);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
UnitMove unitMove = new UnitMove()
{
moveSpeed = m_MoveSpeed
};
dstManager.AddComponentData(entity, unitMove);
}
void MoveUnits(Vector3 pos)
{
moveToPos = pos;
foreach (GameObject g in selectedUnits)
{
g.GetComponent <Unit>().state = Unit.State.moving;
UnitMove u = g.GetComponent <UnitMove>();
u.MoveToSpot(pos);
}
}
public void UnitBuildConstruction()
{
MapNode munich = MapNodes.Get("mun");
Unit germanUnit = Army.Get(Powers.Germany);
var edge = Maps.BuildMap.AdjacentOutEdges(MapNodes.Get("build")).First(e => e.Target == munich);
UnitMove uBuild = new UnitMove(germanUnit, edge);
Assert.IsTrue(uBuild.IsBuild);
}
public override void OnIndexTriggered()
{
base.OnIndexTriggered();
if (!startSelected)
{
startSelected = true;
Debug.Log("Raycast Initated");
RaycastHit hit;
GameObject hitObject = null;
if (Physics.Raycast(pointer.transform.position, pointer.transform.TransformDirection(Vector3.forward), out hit, Mathf.Infinity))
{
hitObject = InitRayCast(hit);
}
if (selectedConstruct != null)
{
if (selectedConstruct.IsBuildable())
{
selectedConstruct.ConfirmBuild();
selectedConstruct = null;
}
}
else
{
CheckUnitOBJ(hitObject);
CheckUIOBJ(hitObject);
}
EtherDeposit eth = hitObject.GetComponent <EtherDeposit>();
if (selectedWorker != null && eth != null)
{
selectedWorker.GoHarvest(eth);
}
if (hitObject.tag == "Terrain" && (selectedUnit != null || selectedWorker != null))
{
UnitMove mover = null;
if (selectedUnit != null)
{
mover = selectedUnit.GetComponent <UnitMove>();
selectedUnit.SetAutoAttaack(false);
selectedUnit.SetTarget(null);
}
else if (selectedWorker != null)
{
mover = selectedWorker.GetComponent <UnitMove>();
selectedWorker.GoHarvest(null);
}
mover.OrderMove(hit.point);
StartCoroutine(MovePointIndicator(hit.point));
}
}
}
IEnumerator recover(UnitMonoBehaciour unit)
{
float Value_2 = Attribute.GetFloat(CannonBuffAttrType.Value_2);
UnitMove move = unit.gameObject.GetComponent <UnitMove>();
float speed = move.MoveSpeed;
move.MoveSpeed = 0;
yield return(new WaitForSeconds(Value_2));
move.MoveSpeed = speed;
}
public void NoTerritorySwappingAllowed()
{
Board board = Board.GetInitialBoard();
BoardMove moves = new BoardMove();
UnitMove move1 = board.GetMove("tri", "ven");
UnitMove move2 = board.GetMove("ven", "tri");
Assert.IsTrue(moves.CurrentlyAllowsFallSpring(move1));
moves.Add(move1);
Assert.IsFalse(moves.CurrentlyAllowsFallSpring(move2));
}
void Update()
{
if (Input.GetKeyDown("5"))
{
if (SelectedUnits[0] != null)
{
unitMove = SelectedUnits[0].GetComponent <UnitMove>();
unitMove.Selected = !unitMove.Selected;
Debug.Log("Unit Move = " + unitMove.Selected);
}
}
}
private void EvoToBossMonster()
{//필드의 몬스터 중 한마리를 보스 몬스터로 만든다.
GameObject EvoMonster = monsters[Random.Range(0, monsters.Length)];
if (EvoMonster.activeSelf)
{
EvoMonster.transform.localScale *= 3;
UnitMove statusOfBossMonster = EvoMonster.GetComponent <UnitMove>();
statusOfBossMonster.HP = 100000;
bossMonsterCreated = true;
}
}
public void Update(Unit unit)
{
unit.Animator.SetInteger("AnimationState", (int)Unit.ANIMATION_STATE.IDLE);
unit.WeaponAnimator.SetBool("IsAttack", false);
GameObject target = FindShortDistanceBuilding(unit);
if (target)
{
UnitMove unitMove = new UnitMove(target.transform.position, unit);
unit.ChangeStateMachine(unitMove);
}
}
public void UnitMoveConstruction()
{
MapNode munich = MapNodes.Get("mun");
Unit germanUnit = initialBoard.OccupiedMapNodes[munich];
var edge = Maps.Army.AdjacentOutEdges(munich).First();
UnitMove uMove = new UnitMove(germanUnit, edge);
Assert.IsFalse(uMove.IsHold);
UnitMove uMove2 = new UnitMove(germanUnit, munich);
Assert.IsTrue(uMove2.IsHold);
}
private IEnumerator aquireATK()
{
isATKing = true;
Animator ani = GetComponent <Animator>();
ani.SetBool("Attack", true);
yield return(new WaitForSeconds(atkStartSwing));
if (soundEffect)
{
Instantiate(soundEffect, transform.position, transform.localRotation);
}
if (!rangedATK)
{
if (target != null)
{
target.GetDamage(damage);
Instantiate(meleeEffect, target.transform.position + (transform.up * 2), transform.localRotation);
}
else
{
}
}
else
{
ProjectieDummy proj = Instantiate(missile, projPoint.transform.position, transform.localRotation) as ProjectieDummy;
if (target != null)
{
//proj.transform.LookAt(target.transform.position);
Debug.Log("Throw to Target");
proj.StartProj(target.transform.position, stat.GetOwner(), damage);
}
else
{
//proj.transform.LookAt(transform.position + (transform.forward * atkRange));
Debug.Log("Throw to Point");
proj.StartProj(transform.position + (transform.forward * atkRange), stat.GetOwner(), damage);
}
}
ani.SetBool("Attack", false);
yield return(new WaitForSeconds(atkStopSwing));
UnitMove uni = GetComponent <UnitMove>();
uni.OrderMove(Vector3.one);
isATKing = false;
yield return(null);
}
public virtual void GetReachableTiles(UnitMove move, HashSet <Tile> reachTiles, Unit team)
{
if (!isOccuppied)
{
this.moveLeft = move.moveSpeed;
reachTiles.Add(this);
}
else if (this.Unit.isHostile(team))
{
return;
}
if (move.moveType == MoveType.flying)
{
move.moveSpeed--;
}
else
{
move.moveSpeed -= Movecost;
}
if (move.moveSpeed >= 0)
{
if (Slow)
{
move.moveSpeed = 0;
}
if (north != null)
{
north.GetReachableTiles((north.Slow) ? new UnitMove(0) : move, reachTiles, team);
}
if (south != null)
{
south.GetReachableTiles((south.Slow) ? new UnitMove(0) : move, reachTiles, team);
}
if (west != null)
{
west.GetReachableTiles((west.Slow) ? new UnitMove(0) : move, reachTiles, team);
}
if (east != null)
{
east.GetReachableTiles((east.Slow) ? new UnitMove(0) : move, reachTiles, team);
}
}
else
{
return;
}
}
public override void DoBUFF(UnitMonoBehaciour unit, UnitMonoBehaciour target)
{
Color color = new Color(0, 192f / 255f, 1f);
foreach (var targetCol in BuffTools.GetOverlapSphereUnit(target.transform.position, Value_0))
{
UnitMove move = targetCol.gameObject.GetComponent <UnitMove>();
if (!list.Contains(move))
{
move.MoveSpeed *= (1f - Value_1);
targetCol._DefCol = color;
targetCol._Renderer.material.color = color;
list.Add(move);
}
}
}
void SelectUnits()
{
ClearSelectedUnits();
RaycastHit[] hit = Physics.BoxCastAll(rectCenter, halfExtents, Vector3.up);
for (int i = 0; i < hit.Length; i++)
{
if (hit[i].collider.CompareTag("PlayerUnit"))
{
UnitMove u = hit[i].collider.GetComponent <UnitMove>();
u.SelectUnit();
u.CalculateOffSet(rectCenter);
selectedUnits.Add(u.gameObject);
}
}
}
static int get_speed(IntPtr L)
{
object o = null;
try
{
o = ToLua.ToObject(L, 1);
UnitMove obj = (UnitMove)o;
float ret = obj.speed;
LuaDLL.lua_pushnumber(L, ret);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index speed on a nil value" : e.Message));
}
}
static int set_stat(IntPtr L)
{
object o = null;
try
{
o = ToLua.ToObject(L, 1);
UnitMove obj = (UnitMove)o;
int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
obj.stat = arg0;
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index stat on a nil value" : e.Message));
}
}
protected virtual void Init()
{
unitMove = GetComponent<UnitMove>();
meshRenderer = gameObject.GetComponentInChildren<MeshRenderer>();
mat_ended = Resources.Load<Material>("Materials/Unit_Turn_Over");
stats = gameObject.GetComponent<UnitStats>();
m_statusEffects = gameObject.GetComponent<SEManager>();
LoadResources();
SetStats();
SetPowers();
}
public OnEventStartMovingCharacter(UnitMove unit, int x, int z)
{
_unit = unit;
_x = x;
_z = z;
}
