void FireBullet()
{
Ray ray = new Ray(Muzzle.position, Muzzle.forward);
RaycastHit hit;
Physics.Raycast(ray, out hit);
flashLine.positionCount = 2;
flashLine.SetPosition(0, Muzzle.position);
flashLine.SetPosition(1, hit.point);
flashStay = FlashStayTime;
flashLine.enabled = true;
if (hit.collider)
{
UnitHealth hitBody = hit.collider.gameObject.GetComponent <UnitHealth>();
HitCollider hitCollider = hit.collider.gameObject.GetComponent <HitCollider>();
if (!hitBody && hitCollider && hitCollider.ColliderType == HitCollider.Type.Receive)
{
hitBody = hitCollider.GetOwner();
}
if (hitBody)
{
hitBody.Damage(DamagePerBullet);
}
}
}
void OnTriggerEnter(Collider other)
{
if (mAttackActionInfo == null)
{
return;
}
if (other.gameObject == mOwner.gameObject)
{
return;
}
HitCollider hitObj = other.gameObject.GetComponent <HitCollider>();
if (hitObj == null)
{
return;
}
CharacterProperty character = hitObj.mOwner;
if (character)
{
float hitTime = Time.time - t;
character.Hit(mOwner, mAttackActionInfo.value);
//character.HitRate
GameObject hitEffect = Instantiate(Resources.Load("Effects/Hits/SimpleHitFlash"), CheckCollider.ClosestPointOnBounds(other.transform.position), Quaternion.identity) as GameObject;
Destroy(hitEffect, 3.0f);
mAttackActionInfo = null;
CheckCollider.enabled = false;
}
}
void OnTriggerEnter2D(Collider2D other)
{
var nearProps = Physics2D.OverlapCircleAll(transform.position, HitRadius, HitLayerMask);
HitCollider?.Invoke(nearProps, other.transform, transform.position);
gameObject.SetActive(false);
Instantiate(OnDestroyedVFX, transform.position - new Vector3(0, 0, .3f), OnDestroyedVFX.transform.rotation);
AudioManager.Instance.PlaySFX(OnHitClips[Random.Range(0, OnHitClips.Length)], 0.5f, Random.Range(1, 1.1f));
}
public void OnHitColliderContact(HitCollider self, HitCollider other)
{
if (self.ColliderType != other.ColliderType)
{
if (self.ColliderType == global::HitCollider.Type.Inflict)
{
OnInflictHit?.Invoke(self, other);
}
else if (self.ColliderType == global::HitCollider.Type.Receive)
{
OnReceiveHit?.Invoke(self, other);
}
}
}
private List <InteractTile> GetTiles(InteractTile center)
{
List <InteractTile> ret = new List <InteractTile>();
Collider[] HitColliders = Physics.OverlapCapsule(center.transform.position, center.transform.position + InteractComponent.singleton.GetDirection() * World.singleton.Size.magnitude, Radius, 1 << 8);
foreach (Collider HitCollider in HitColliders)
{
InteractTile TileComponent = HitCollider.GetComponent <InteractTile>();
if (TileComponent)
{
ret.Add(TileComponent);
}
}
return(ret);
}
private List <InteractTile> GetTiles(InteractTile center)
{
List <InteractTile> ret = new List <InteractTile>();
Collider[] HitColliders = Physics.OverlapSphere(center.transform.position, Radius, 1 << 8);
foreach (Collider HitCollider in HitColliders)
{
InteractTile TileComponent = HitCollider.GetComponent <InteractTile>();
if (TileComponent)
{
ret.Add(TileComponent);
}
}
return(ret);
}
void Start()
{
m_networkManager = NetworkManager.singleton;
m_controller = GetComponent <CharacterController>();
Camera.main.GetComponent <CameraController>().m_target = transform;
if (gameObject.tag == "Player")
{
gameObject.layer = 8;
}
else if (gameObject.tag == "Enemy")
{
gameObject.layer = 9;
}
m_animController = GetComponent <Animator>();
m_hitColliderScript = GetComponent <HitCollider>();
}
protected void OnTriggerEnter2D(Collider2D other)
{
if (attackableMask == (attackableMask | (1 << other.gameObject.layer)))
{
HitCollider target = other.GetComponent <HitCollider>();
if (target != null)
{
target.character.DoDamage(owner.gameObject, this.damage);
}
}
Debug.Log(other.gameObject.name);
if (destructionMask == (destructionMask | (1 << other.gameObject.layer)))
{
Destroy(gameObject);
}
}
void Update()
{
if (Random.Range(0.0f, 1.0f) < RandomFireStartChance)
{
for (int i = 0; i < Random.Range(0, RandomFireStartMaxCount); i++)
{
Collider[] HitColliders = Physics.OverlapSphere(GetRandomTile().transform.position, Random.Range(0.0f, RandomFireStartRadius), 1 << 8);
foreach (Collider HitCollider in HitColliders)
{
InteractTile TileComponent = HitCollider.GetComponent <InteractTile>();
if (TileComponent)
{
TileComponent.SetFireState(true);
}
}
}
}
}
private List <InteractTile> GetTiles(InteractTile center)
{
List <InteractTile> ret = new List <InteractTile>();
bool HasWater = false;
Collider[] HitColliders = Physics.OverlapCapsule(center.transform.position, center.transform.position + InteractComponent.singleton.GetDirection() * Range, Radius, 1 << 8);
foreach (Collider HitCollider in HitColliders)
{
InteractTile TileComponent = HitCollider.GetComponent <InteractTile>();
if (TileComponent)
{
if (TileComponent.type == TileType.Water)
{
HasWater = true;
}
ret.Add(TileComponent);
}
}
return(HasWater ? ret : new List <InteractTile>());
}
// on receive hit play damage animation
// and face towards enemy if attacked from the front
void OnReceiveHit(HitCollider self, HitCollider other)
{
UnitHealth attacker = other.GetOwner();
float angle = Mathf.Abs(Vector3.SignedAngle(transform.forward, (attacker.transform.position - transform.position).normalized, Vector3.up));
lastDamageAngle = angle;
if (angle < 90)
{
transform.LookAt(attacker.transform, Vector3.up);
}
if (unitHealth.Health > 0)
{
animator.SetTrigger("Hit");
}
alertTimer = AlertTime;
AlertAlliesInRadius(AllyAlertRange);
}
// initiate attack routine on button press
public void OnAttackInputDown()
{
// do attack
if (playerCanMove)
{
if (!playerAttacking)
{
playerAttacking = true;
Debug.Log("playerAttacking = true");
// Create an invisible collider in front of the player to check for collision with another interactable object
GameObject newHitBox = Instantiate(playerAttackHitBox, new Vector3(attackHitBoxPos.x, attackHitBoxPos.y), transform.rotation);
HitCollider hitBox = newHitBox.GetComponent <HitCollider>();
hitBox.hitBoxOwner = gameObject;
hitBox.hitBoxDir = playerController.collisions.facingDir;
attackTimer = defaultAttackTimer;
}
}
}
public override void Use(InteractTile tile)
{
if (!Currency.singleton.Pay(Price))
{
return;
}
InteractComponent.singleton.RainFade();
if (selectedTiles == null)
{
Debug.LogError("NO TILES WERE FOUND!");
}
foreach (InteractTile selectedTile in selectedTiles)
{
selectedTile.SetFireState(false);
}
if (Random.Range(0.0f, 1.0f) < LightningstrikeChance)
{
InteractComponent.singleton.ThunderFade();
SoundHandler.singleton.CardSource.PlayOneShot(LightningClip[Random.Range(0, LightningClip.Length)]);
InteractTile lightningTile = selectedTiles[Random.Range(0, selectedTiles.Count)];
Destroy(Instantiate(World.singleton.LightningModel, lightningTile.transform.position + new Vector3(0, 1f, 0), Quaternion.Euler(0, 45, 0)).gameObject, 1);
Collider[] HitColliders = Physics.OverlapSphere(lightningTile.transform.position, Random.Range(0.0f, LightningStrikeRadius), 1 << 8);
foreach (Collider HitCollider in HitColliders)
{
InteractTile hitTile = HitCollider.GetComponent <InteractTile>();
if (hitTile)
{
hitTile.SetFireState(true);
}
}
}
else
{
GameObject rain = Instantiate(World.singleton.RainModel, tile.transform.position + new Vector3(0, 1f, 0), Quaternion.Euler(0, 45, 0)).gameObject;
rain.transform.localScale *= 1.2f;
Destroy(rain, 1);
SoundHandler.singleton.CardSource.PlayOneShot(UseSound[Random.Range(0, UseSound.Length)]);
}
}
public void ReceiveAttack(HitCollider hitCollider, AttackProperties attack)
{
bool blocked = false;
Moves nextMove = Moves.None;
switch (playerState.CheckBlocking(attack.angle))
{
case true:
nextMove = Moves.Blocking;
blocked = true;
break;
case false:
nextMove = Moves.BeingHit;
blocked = false;
playerHealth.TakeDamage(attack.damage);
particle.Play();
break;
}
playerState.SetStateTimer(nextMove, attack.hitStun, attack.blockStun, attack.angle);
hitCollider.ReceiveAttackFeedback(attack, blocked);
}
void OnAttackHit(HitCollider self, HitCollider other)
{
if (activeHit)
{
if (attackIsHit)
{
self.enabled = false;
return;
}
UnitHealth owner = other.GetOwner();
float angle = Mathf.Abs(Vector3.SignedAngle(owner.transform.forward, (transform.position - owner.transform.position).normalized, Vector3.up));
// attacks from the back deal triple the damage
if (angle > 90)
{
owner.Damage(100);
}
else
{
owner.Damage(36);
}
if (other.GetOwner().IsDead())
{
Transform chest = other.GetOwner().GetComponent <Animator>().GetBoneTransform(HumanBodyBones.Chest);
Vector3 force = (chest.position - transform.position);
force.y = 0;
force = force.normalized;
force.y += 0.8f;
force = force.normalized;
force *= 200;
chest.GetComponent <Rigidbody>().AddForce(force, ForceMode.Impulse);
}
attackIsHit = true;
}
}
private void FixedUpdate()
{
if (Time.time > ExplosionTriggerTime)
{
if (Time.time > ExplosionEndTime)
{
Destroy(this);
}
float ExplosionTime = Time.time - ExplosionTriggerTime;
float Radius = ExplosionRadius.Evaluate(ExplosionTime);
float Force = ExplosionForce.Evaluate(ExplosionTime);
if (Radius <= 0)
{
return;
}
Collider[] HitColliders = Physics.OverlapSphere(transform.position, Radius);
foreach (Collider HitCollider in HitColliders)
{
if (HitCollider.gameObject == this.gameObject)
{
continue;
}
Rigidbody Body = HitCollider.GetComponent <Rigidbody>();
if (Body == null)
{
continue;
}
float BodyDistance = Vector3.Distance(Body.transform.position, transform.position);
Body.AddExplosionForce(Force * ForceFalloff.Evaluate(BodyDistance / Radius), ExplosionLocation, 0.0f, 0.0f, ForceMode.Force);
}
}
}
void OnHitContact(Collider other)
{
if (unitHealth == null)
{
return;
}
if (!this.enabled)
{
return;
}
HitCollider otherHitCollider = other.GetComponent <HitCollider>();
if (otherHitCollider == null || !otherHitCollider.enabled)
{
return;
}
if (unitHealth == otherHitCollider.unitHealth)
{
return;
}
unitHealth.OnHitColliderContact(this, otherHitCollider);
}
void Start()
{
this.TreesPlaced = new List <InteractTile>();
//Places tiles
tiles = new InteractTile[(int)Size.x, (int)Size.y];
for (int x = 0; x < (int)Size.x; x++)
{
for (int y = 0; y < (int)Size.y; y++)
{
tiles[x, y] = Instantiate(TilePrefab, new Vector3(x, 0, y), Quaternion.Euler(0, Random.Range(0, 3) * 90, 0), WorldParent).GetComponent <InteractTile>();
tiles[x, y].x = x;
tiles[x, y].y = y;
}
}
//River water tiles
Vector2 currPos = Vector2.zero;
Vector2 direction = Vector2.zero;
Vector2 tangent = Vector2.zero;
switch (Random.Range(0, 4))
{
case 0:
currPos = new Vector2(Mathf.Cos(Random.Range(0, Mathf.PI / 2)) * (Size.x - 1), 0);
direction = new Vector2(0, 1);
tangent = new Vector2(1, 0);
break;
case 1:
currPos = new Vector2(Mathf.Cos(Random.Range(0, Mathf.PI / 2)) * (Size.x - 1), Size.y - 1);
direction = new Vector2(0, -1);
tangent = new Vector2(1, 0);
break;
case 2:
currPos = new Vector2(0, Mathf.Cos(Random.Range(0, Mathf.PI / 2)) * (Size.y - 1));
direction = new Vector2(1, 0);
tangent = new Vector2(0, 1);
break;
case 3:
currPos = new Vector2(Size.x, Mathf.Cos(Random.Range(0, Mathf.PI / 2)) * (Size.y - 1));
direction = new Vector2(1, 0);
tangent = new Vector2(0, 1);
break;
}
do
{
Collider[] HitColliders = Physics.OverlapSphere(new Vector3(currPos.x, 0, currPos.y), RiverStepDistance, 1 << 8);
foreach (Collider HitCollider in HitColliders)
{
InteractTile TileComponent = HitCollider.GetComponent <InteractTile>();
if (TileComponent)
{
if (TileComponent.SetType(TileType.Water))
{
if (Random.Range(0, 2) == 0)
{
TreesToPlace--;
}
else
{
GrassToPlace--;
}
}
}
}
currPos += direction * RiverStepDistance;
direction += tangent * Random.Range(-1.0f, 1.0f) * RiverTurnStrength;
direction.Normalize();
}while(currPos.x > 0 && currPos.y > 0 && currPos.x < Size.x && currPos.y < Size.y);
//Border water tiles
for (int x = (int)(-Size.x * 0.5f) - 1; x < Size.x * 1.5 + 3; x++)
{
float test = (x < Size.x / 2?(int)(Size.y) + x:(Size.y - x + Size.x / 2));
for (int y = (int)(x < Size.x / 2 ? -x : -Size.y + x) - 1; y < (x < Size.x / 2?(int)(Size.y) + x:(Size.y - x + Size.x)) + 3; y++)
{
if (x >= -2 && y >= -2 && x < Size.x + 2 && y < Size.y + 2)
{
if (x >= 0 && y >= 0 && x < Size.x && y < Size.y)
{
continue;
}
Instantiate(TilePrefab, new Vector3(x, 0, y), Quaternion.Euler(0, Random.Range(0, 3) * 90, 0), WorldParent).GetComponent <InteractTile>().SetType(TileType.Water);
continue;
}
Instantiate(WaterTilePrefab, new Vector3(x, -0.9f, y), Quaternion.Euler(0, Random.Range(0, 3) * 90, 0), WorldParent);
}
}
//Spreads random trees from 4 random locations
for (int i = 0; i < 4;)
{
InteractTile tile = GetRandomTile();
if (tile.type == TileType.Dirt)
{
tile.SetType(TileType.Tree);
TreesPlaced.Add(tile);
i++;
}
}
for (int i = 0; i < TreesToPlace * 100 && TreesPlaced.Count < TreesToPlace - 4; i++)
{
InteractTile tile = GetTile(TreesPlaced[Random.Range(0, TreesPlaced.Count)].GetDirection(Random.Range(0, 4)));
if (tile && tile.type == TileType.Dirt)
{
tile.SetType(TileType.Tree);
TreesPlaced.Add(tile);
}
}
TreesAmount = TreesPlaced.Count;
//Spreads random grass
List <InteractTile> grassPlaced = new List <InteractTile>();
for (int i = 0; i < 4;)
{
InteractTile tile = GetRandomTile();
if (tile.type == TileType.Dirt)
{
tile.SetType(TileType.Grass);
grassPlaced.Add(tile);
i++;
}
}
for (int i = 0; i < GrassToPlace * 100 && grassPlaced.Count < GrassToPlace; i++)
{
InteractTile tile = GetTile(grassPlaced[Random.Range(0, grassPlaced.Count)].GetDirection(Random.Range(0, 4)));
if (tile && tile.type == TileType.Dirt)
{
tile.SetType(TileType.Grass);
grassPlaced.Add(tile);
}
}
//Places random houses
int HousesToPlace = Random.Range(0, 10);
int HousesPlaced = 0;
while (HousesPlaced < HousesToPlace)
{
InteractTile tile = GetRandomTile();
if (tile && tile.type == TileType.Dirt)
{
tile.Child = Instantiate(HouseModel, tile.transform.position + new Vector3(0, 0.5f, 0), Quaternion.Euler(0, Random.Range(0, 4) * 90, 0));
tile.type = TileType.House;
HousesPlaced++;
}
}
}
