Unit LoadSavedUnit(AODGameLibrary2.SavedUnit su, int group, bool player, Vector3 position)
{
Unit u;
if (player)
{
u = Unit.Create(gameWorld, su.UnitType, group, position, true, false);
}
else
{
u = Unit.Create(gameWorld, su.UnitType, group, position, false, true);
}
gameWorld.units.Add(u);
gameWorld.variables.LastCreatedUnit = u;
u.weapons.Clear();
u.skills.Clear();
u.missiles.Clear();
foreach (AODGameLibrary2.SavedInf s in su.Weapons)
{
Weapon w = new Weapon(gameWorld, gameWorld.game.Content.Load <WeaponType>(s.AssetName), u);
w.AmmoNum = s.AmmoNum;
u.weapons.Add(w);
}
foreach (AODGameLibrary2.SavedInf s in su.Missiles)
{
MissileWeapon w = new MissileWeapon(gameWorld, gameWorld.game.Content.Load <MissileWeaponType>(s.AssetName));
w.Num = (int)s.AmmoNum;
u.missiles.Add(w);
}
foreach (AODGameLibrary2.SavedInf s in su.Spells)
{
u.AddSkill(s.AssetName);
}
return(u);
}
private void drawWeapon(int weapon)
{
if (weapons[selectedWeapon] != null)
{
hideWeapon();
}
selectedWeapon = weapon;
weapons[selectedWeapon].transform.SetParent(rightHand.transform);
weapons[selectedWeapon].transform.localPosition = new Vector3(0f, 0f, 0f);
weapons[selectedWeapon].transform.localRotation = Quaternion.identity;
if (weapons[selectedWeapon] is MissileWeapon)
{
currentSelectedMissileWeapon = weapons[selectedWeapon] as MissileWeapon; // will be later in DrawWeapon
}
else
{
currentSelectedMissileWeapon = null;
}
if (weapons[selectedWeapon] is MeleeWeapon)
{
currentSelectedMeleeWeapon = weapons[selectedWeapon] as MeleeWeapon;
}
else
{
currentSelectedMeleeWeapon = null;
}
}
IEnumerator GenerateWaveCoroutine()
{
_bGeneratingWave = true;
_manager.WriteCom("Alerta");
for (int i = 0; i < _enemiesQuantityPerWave; ++i)
{
GameObject spawnPoint = _spawnPoints[i];
GameObject newEnemy = _enemyPool.GetObjectFromPool("Enemy");
newEnemy.transform.position = spawnPoint.transform.position + Random.insideUnitSphere * _spawnRadio;
newEnemy.transform.forward = spawnPoint.transform.forward;
newEnemy.transform.SetParent(spawnPoint.transform);
Enemy enemy = newEnemy.GetComponent <Enemy>();
enemy.LifePoints += (_currentWave + 1) + _difficulty * (_currentWave + 1);
enemy.target = _player.gameObject;
LaserWeapon laser = newEnemy.GetComponent <LaserWeapon>();
laser.Damage += _currentWave + _difficulty * _currentWave;
MissileWeapon missile = newEnemy.GetComponent <MissileWeapon>();
missile.Damage += (_currentWave + 1) * _difficulty * _currentWave;
_currentEnemies++;
yield return(new WaitForSeconds(.1f));
}
_manager.WriteCom(string.Format("Oleada {0}" +
"\nEnemigos en combate: {1}", _currentWave + 1, _currentEnemies));
_currentWave++;
_enemiesQuantityPerWave += _enemiesQuantityPerWave / (_currentWave + 1);
//_enemiesQuantityPerWave += (int)(_spawnPoints.Length/12 + _difficulty*2);
_bGeneratingWave = false;
}
protected virtual void Awake()
{
LifePoints = _maxLife;
_laserWeapon = GetComponent <LaserWeapon>();
_missileWeapon = GetComponent <MissileWeapon>();
_rigidbody = GetComponent <Rigidbody>();
}
public virtual bool Shoot(Character enemy, MissileWeapon wep)
{
RangedWeapon = wep;
var result = Attack(enemy);
RangedWeapon = null;
return(result);
}
// Use this for initialization
void Awake()
{
_player = FindObjectOfType <Player>();
_playerAutoAim = _player.GetComponent <AutoAim>();
_playerLaser = _player.GetComponent <LaserWeapon>();
_playerMissile = _player.GetComponent <MissileWeapon>();
_playerShieldManager = _player.GetComponent <ShieldManager>();
InvokeRepeating("WaitingCom", 0, 1);
}
//ändert den bool isReadyToShoot nach der loadTime
IEnumerator WeaponSpannen()
{
MissileWeapon weapon = weapons[selectedWeapon] as MissileWeapon;
weapon.isPreparingWeapon = true;
yield return(new WaitForSeconds(weapon.missileReloadTime));
weapon.isPreparingWeapon = false;
weapon.weaponReadyToShoot = true;
}
private void RandomRotator(MissileWeapon weapon)
{
if (!perfectAim)
{
float step = 1 / missileAimSkill * 25; //5 ist grad um die wir rotieren
weapon.transform.Rotate(
Random.Range(-step, step),
Random.Range(-step, step),
Random.Range(-step, step));
}
}
public void UpdateHUD(Weapon weapon)
{
MissileWeapon mw = weapon as MissileWeapon;
weaponName.text = weapon.name;
if (weaponSystem.IsReloading())
{
reloadingPanel.SetActive(true);
}
else
{
reloadingPanel.SetActive(false);
}
if (mw != null)
{
if (mw.ammoType == AmmoType.Infinite)
{
if (mw.infiniteMagazine)
{
currentAmmo.text = "";
ammoLeftInPoaches.text = "";
infinityPoach.enabled = false;
infinityPoachAndMagazine.enabled = true;
line.enabled = false;
}
else
{
currentAmmo.text = mw.currentMagazineAmmo.ToString();
ammoLeftInPoaches.text = "";
infinityPoach.enabled = true;
infinityPoachAndMagazine.enabled = false;
line.enabled = true;
}
}
else
{
currentAmmo.text = mw.currentMagazineAmmo.ToString();
ammoLeftInPoaches.text = weaponSystem.GetAmmo(mw.ammoType).ToString();
infinityPoach.enabled = false;
infinityPoachAndMagazine.enabled = false;
line.enabled = true;
}
}
else
{
currentAmmo.text = "";
ammoLeftInPoaches.text = "";
infinityPoach.enabled = false;
infinityPoachAndMagazine.enabled = false;
line.enabled = true;
}
}
private void SetWishedWeaponRotation(float launchAngle, MissileWeapon weapon)
{
launchAngle = -launchAngle; //cause localTransform goes in the other direction
float xTilt = 0f;; //we when the back is on the side of the Units it also needs to aim directly at the enemy - trigonometrie cos(a) = b/c, now theres a etter way
Quaternion angleOfWeapon = Quaternion.LookRotation((currentAttackingTargetTransform.position - weapon.transform.position));
Quaternion angleOfUnit = Quaternion.LookRotation((currentAttackingTargetTransform.position - transform.position));
xTilt = Quaternion.Angle(angleOfWeapon, angleOfUnit);
wishedWeaponRotation = Quaternion.Euler(transform.rotation.eulerAngles.x + xTilt, transform.rotation.eulerAngles.x + launchAngle, transform.rotation.eulerAngles.z);
}
//ändert den bool isReadyToShoot nach der drawTime
IEnumerator LoadWeapon()
{
MissileWeapon weapon = weapons[selectedWeapon] as MissileWeapon;
weapon.isPreparingWeapon = true;
yield return(new WaitForSeconds(weapon.missileReloadTime));
weapon.isPreparingWeapon = false;
weapon.weaponReadyToShoot = true;
//Debug.Log("Waffe geladennnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn ");
}
private void AbortDrawOrLoad()
{
MissileWeapon weapon = weapons[selectedWeapon] as MissileWeapon;
if (weapon.isPreparingWeapon)
{
StopCoroutine("LoadOrDrawWeapon");
weapon.AbortLoadOrDraw();
}
if (weapon.missileWeaponType == MissileWeapon.MissileWeaponType.Drawable && weapon.weaponReadyToShoot)
{
weapon.RevertDraw();
}
}
//ändert den bool isReadyToShoot nach der drawTime
//TODO Load Weapon das gleiche wie weapon Spannen?
IEnumerator LoadOrDrawWeapon()
{
MissileWeapon weapon = weapons[selectedWeapon] as MissileWeapon;
//weapon.missileWeaponAnimator.SetTrigger("DrawLoad");
//weapon.isPreparingWeapon = true;
weapon.StartLoadOrDraw();
//Debug.Log("startLoad");
yield return(new WaitForSeconds(weapon.missileReloadTime));
//weapon.isPreparingWeapon = false;
//weapon.weaponReadyToShoot = true;
//Debug.Log("Waffe geladennnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn ");
weapon.FinishLoadOrDraw();
//Debug.Log("finishLoad");
}
public Weapon ChooseWeapon()
{
Console.WriteLine("Please choose weapon: Laser (1), Missile (2), Machine (3).");
var useruserInput = Console.ReadLine();
Weapon weapon;
switch (useruserInput)
{
case "1": weapon = new LaserWeapon(); break;
case "2": weapon = new MissileWeapon(); break;
case "3": weapon = new MachineWeapon(); break;
default: throw new ArgumentException();
}
return(weapon);
}
private bool RotateWeapon(float launchAngle, MissileWeapon weapon)
{
launchAngle = -launchAngle; //cause localTransform goes in the other direction
float yTilt = 0f;; //we when the back is on the side of the Units it also needs to aim directly at the enemy - trigonometrie cos(a) = b/c, now theres a etter way
Quaternion angleOfWeapon = Quaternion.LookRotation((currentAttackingTargetTransform.position - weapon.transform.position));
Quaternion angleOfUnit = Quaternion.LookRotation((currentAttackingTargetTransform.position - transform.position));
yTilt = Quaternion.Angle(angleOfWeapon, angleOfUnit);
Quaternion wishedRotation = Quaternion.Euler(transform.rotation.eulerAngles.x + launchAngle, transform.rotation.eulerAngles.x - yTilt, transform.rotation.eulerAngles.z);
weapon.transform.localRotation = Quaternion.RotateTowards(weapon.transform.localRotation, wishedRotation, Time.deltaTime * weapon.aimSpeed);
if (weapon.transform.localRotation == wishedRotation)
{
return(true);
}
return(false);
}
public void EndReload()
{
state = WeaponSystemState.Default;
if (currentSelectedWeapon is MissileWeapon)
{
MissileWeapon currentMW = currentSelectedWeapon as MissileWeapon;
if (currentMW.ammoType == AmmoType.Infinite)
{
currentMW.Reload(currentMW.magazineSize);
}
else
{
ammo[currentMW.ammoType] += currentMW.currentMagazineAmmo;
int clamped = Mathf.Clamp(ammo[currentMW.ammoType], 0, currentMW.magazineSize);
currentMW.Reload(clamped);
ammo[currentMW.ammoType] -= clamped;
}
}
}
protected override void Update()
{
base.Update();
//check if we already killed our Target
if (state == State.Attacking)
{
if (currentAttackingTarget == null)
{
killedCurrentTarget = true;
//now search for another target or change state to idle
state = State.Idle;
}
else
{
killedCurrentTarget = false;
if (weapons[selectedWeapon] is MeleeWeapon)
{
MeleeAttack();
}
else if (weapons[selectedWeapon] is MissileWeapon)
{
MissileAttack();
}
}
}
else if (state == State.Idle)
{
//automaticly Load when we stay in a position
if (!moving && weapons[selectedWeapon] is MissileWeapon)
{
MissileWeapon weapon = weapons[selectedWeapon] as MissileWeapon;
if (!weapon.weaponReadyToShoot && !weapon.isPreparingWeapon && weapon.missileWeaponType == MissileWeapon.MissileWeaponType.Loadable)
{
StartCoroutine("LoadWeapon");
}
}
}
}
private void AbortAttack()
{
if (state == State.Attacking)
{
state = State.Idle;
}
if (weapons[selectedWeapon] is MissileWeapon)
{
MissileWeapon weapon = weapons[selectedWeapon] as MissileWeapon;
if (weapon.missileWeaponType == MissileWeapon.MissileWeaponType.Loadable)
{
//Debug.Log("stoppeWaffeLaden/Spannen ");
StopCoroutine("LoadWeapon");
weapon.isPreparingWeapon = false;
}
else if (weapon.missileWeaponType == MissileWeapon.MissileWeaponType.Drawable)
{
//StopCoroutine("WeaponSpannen");
weapon.isPreparingWeapon = false;
}
}
}
bool DirectFireCheck(MissileWeapon weapon) //returns true if directFire is checked
{
bool isTheWayFree = false;
RaycastHit hit;
// Does the ray intersect any objects excluding the player layer
Vector3 direction = currentAttackingTargetTransform.position - weapon.transform.position;
direction.Normalize();
if (Physics.Raycast(weapon.transform.position + direction, direction, out hit, weapon.missileRange)) //hier mal layermask zur performanceOptimierung hinzufügen
{
Debug.Log(hit.collider.gameObject);
if (hit.collider.gameObject.GetComponent <UnitMovement>() == currentAttackingTarget)
{
isTheWayFree = true;
}
else
{
isTheWayFree = false;
}
}
return(isTheWayFree);
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.Alpha1))
{
ChangeWeapon(0);
}
else if (Input.GetKeyDown(KeyCode.Alpha2))
{
ChangeWeapon(1);
}
else if (Input.GetKeyDown(KeyCode.Alpha3))
{
ChangeWeapon(2);
}
switch (state)
{
case WeaponSystemState.Default:
if (Input.GetMouseButtonDown(0))
{
currentSelectedWeapon.HandleLMBDown();
}
else
{
if (Input.GetMouseButton(0))
{
currentSelectedWeapon.HandleLMBHold();
}
}
if (Input.GetKeyDown(KeyCode.R))
{
MissileWeapon mw = currentSelectedWeapon as MissileWeapon;
if (mw != null)
{
if (!mw.infiniteMagazine)
{
if (!mw.IsMagazineFull())
{
StartReload();
}
}
}
}
break;
case WeaponSystemState.Reloading:
Debug.Log("Reloading");
if (Time.time > reloadingEndTime)
{
EndReload();
}
break;
}
//point the weapon to aim correctly
if (currentSelectedWeapon is MissileWeapon)
{
//raycast
Ray ray = rayCastCamera.ViewportPointToRay(new Vector3(0.5F, 0.5F, 0));
RaycastHit hit;
if (Physics.Raycast(ray, out hit))
{
//print("I'm looking at " + hit.transform.name);
currentSelectedWeapon.transform.forward = hit.point - currentSelectedWeapon.transform.position;
}
else
{
currentSelectedWeapon.transform.forward = ray.direction;
}
}
weaponHUD.UpdateHUD(currentSelectedWeapon);
}
public void PrepareMissileAttack()
{
//if (currentAttackingTargetTransform != null) {
MissileWeapon weapon = weapons[selectedWeapon] as MissileWeapon; //cast Notwendig //später das nur einmal machen beim selectWeapon
//set Range
if (Vector3.Distance(transform.position, currentAttackingTargetTransform.position) < weapon.missileRange)
{
inRange = true;
}
else
{
inRange = false;
}
// wenn wir im Range sind
if (inRange)
{
enemyWasInRange = true;
//agent.isStopped = true; old way, better, reset the path
agent.ResetPath();
if (weapon.missileWeaponType == MissileWeapon.MissileWeaponType.Loadable) //extraabfrage loadable Weapons können nicht beim laden zielen, bogen schon
{
if (weapon.weaponReadyToShoot)
{
Aim(weapon);
//Debug.Log("aim aufgerufen");
}
else
{
TurnToPosition(currentAttackingTargetTransform.position);
//und lade - automatisch in update
}
}
else //also if drawable //sonst drawable Weapons können während des drawen zielen //den bogen/Wurfspeer spannen wir erst wenn wir in range sind
{
if (!weapon.weaponReadyToShoot && !weapon.isPreparingWeapon)
{
StartCoroutine("LoadOrDrawWeapon");
}
Aim(weapon);
}
if (Quaternion.Angle(transform.rotation, wishRotation) < 5 && !raycastSendForThisAttack)
{//if turnedToDestination
if (automaticDirectFire)
{
directFire = DirectFireCheck(weapon);
}
raycastSendForThisAttack = true;
//Debug.Log("send Raycast");
}
missileAttackPrepared = true; //only in range
}
//Wenn nicht im Range
else
{
//wenn noch nicht geladen
if (weapon.missileWeaponType == MissileWeapon.MissileWeaponType.Loadable && !weapon.weaponReadyToShoot)
{
agent.isStopped = true;
if (!weapon.isPreparingWeapon)
{
StartCoroutine("LoadOrDrawWeapon"); //starte laden neu, falls noch nicht der Fall
}
//TurnToDestination(currentAttackingTargetTransform.position);
}
else if (!enemyWasInRange || followEnemyMissile)
{
SetDestinationAttack(currentAttackingTargetTransform.position);
}
else if (enemyWasInRange || !followEnemyMissile)
{
AbortAttack();
//Debug.Log("abortAttack");
}
//hasCheckedDirectFire = false;
missileAttackPrepared = false; //only in range
// wenn laudable - dann lade hier falls nicht geladen ist, wir laden schon bevor wir in Range sind
}
//}
}
void Aim(MissileWeapon weapon) //returns true if aiming is finished -
{
bool predictedFutureLocation = false;
//Debug.Log("Aim");
//goto here
AimAtPredicted:
Vector3 distDelta = currentAttackingTargetTransform.position - weapon.launchPoint.transform.position;
float launchAngle = GetLaunchAngle(
weapon.missileLaunchVelocity,
new Vector3(distDelta.x, 0f, distDelta.z).magnitude, //Vector3.Distance(new Vector3(currentAttackingTargetTransform.x, 0f, currentAttackingTargetTransform.z), new Vector3(transform.position.x, 0f, transform.position.z)),
distDelta.y, //currentAttackingTargetTransform.y - transform.position.y,
directFire
);
//Debug.Log(launchAngle);
if (float.IsNaN(launchAngle))
{
//Debug.Log("Too far from Target - NaN");
launchAngle = 0;
//TODO dont shoot anymore, get nearer to target, but should not happen
}
//new time in air https://www.youtube.com/watch?v=jb2dWXp_tlw&t=234s&list=LLnkuTCY2XUW7UV3g2Apo5ww&index=2
//initiallVelocityYComponent = missileLaunchVelocity * sin(launachAngle)
//initiallVelocityYComponent = vY
//gravity = g in positive magnitude
//Formula: time in air = (vY + Sqr[(vY)²-4*(0.5*g)*(-(startH-finalH))]/g
// but this works only for destinations lower than our starting keight, maybe make a abs of (startH-finalH)
if (!predictedFutureLocation)
{
float timeInAir;
float g = Physics.gravity.magnitude;
float vY = weapon.missileLaunchVelocity * Mathf.Sin(launchAngle * (Mathf.PI / 180));
//vY = 5f;
float startH = weapon.launchPoint.transform.position.y;
float finalH = currentAttackingTargetTransform.position.y;
if (finalH < startH)
{
timeInAir = (vY + Mathf.Sqrt((float)(Mathf.Pow(vY, 2) - 4 * (0.5 * g) * (-(startH - finalH))))) / g;
}
else
{
//t = distanceX/initiallVeclocityXComponent
float vX = weapon.missileLaunchVelocity * Mathf.Cos(launchAngle * (Mathf.PI / 180));
float distanceX = Vector3.Distance(currentAttackingTargetTransform.position, weapon.launchPoint.transform.position);
timeInAir = distanceX / vX;
}
//change the currentAttackingTargetTransform based on this time , take his velocity times this time //predict his future location
predictedAttackingPositionOffset = currentAttackingTarget.agent.velocity.magnitude * (timeInAir);
predictedFutureLocation = true;
goto AimAtPredicted;
}
else
{
// Debug.Log("launchAngle: " + launchAngle);
SetWishedWeaponRotation(launchAngle, weapon); //wenn wir zuende mir der Waffe gezielt haben
}
}
bool Aim(MissileWeapon weapon) //returns true if aiming is finished -
{
bool predictedFutureLocation = false;
bool _aimed = false;
//goto here
AimAtPredicted:
Vector3 distDelta = currentAttackingTargetTransform.position - weapon.launchPoint.transform.position;
float launchAngle = GetLaunchAngle(
weapon.missileLaunchVelocity,
new Vector3(distDelta.x, 0f, distDelta.z).magnitude, //Vector3.Distance(new Vector3(currentAttackingTargetTransform.x, 0f, currentAttackingTargetTransform.z), new Vector3(transform.position.x, 0f, transform.position.z)),
distDelta.y, //currentAttackingTargetTransform.y - transform.position.y,
directFire
);
if (float.IsNaN(launchAngle))
{
//Debug.Log("Too far from Target - NaN");
launchAngle = 0;
//TODO dont shoot anymore, get nearer to target, but should not happen
}
if (RotateWeapon(launchAngle, weapon))
{
_aimed = true; //wenn wir zuende mir der Waffe gezielt haben
}
//new time in air https://www.youtube.com/watch?v=jb2dWXp_tlw&t=234s&list=LLnkuTCY2XUW7UV3g2Apo5ww&index=2
//initiallVelocityYComponent = missileLaunchVelocity * sin(launachAngle)
//initiallVelocityYComponent = vY
//gravity = g in positive magnitude
//Formula: time in air = (vY + Sqr[(vY)²-4*(0.5*g)*(-(startH-finalH))]/g
// but this works only for destinations lower than our starting keight, maybe make a abs of (startH-finalH)
float timeInAir;
float g = Physics.gravity.magnitude;
float vY = weapon.missileLaunchVelocity * Mathf.Sin(launchAngle * (Mathf.PI / 180));
//vY = 5f;
float startH = weapon.launchPoint.transform.position.y;
float finalH = currentAttackingTargetTransform.position.y;
if (finalH < startH)
{
timeInAir = (vY + Mathf.Sqrt((float)(Mathf.Pow(vY, 2) - 4 * (0.5 * g) * (-(startH - finalH))))) / g;
}
else
{
//t = distanceX/initiallVeclocityXComponent
float vX = weapon.missileLaunchVelocity * Mathf.Cos(launchAngle * (Mathf.PI / 180));
float distanceX = Vector3.Distance(currentAttackingTargetTransform.position, weapon.launchPoint.transform.position);
timeInAir = distanceX / vX;
}
//change the currentAttackingTargetTransform based on this time , take his velocity times this time //predict his future location
if (!predictedFutureLocation)
{
predictedAttackingPosition = currentAttackingTargetTransform.position + currentAttackingTarget.agent.velocity * (timeInAir);
predictedFutureLocation = true;
goto AimAtPredicted;
}
else
{
base.TurnToPosition(predictedAttackingPosition);
if (Quaternion.Angle(transform.rotation, wishRotation) < 5) //hier kommt ein anderer Drehcode, weil er sonst die letzten grad vie lzu langsam dreht
{
agent.updateRotation = false;
Vector3 ourPosition = new Vector3(transform.position.x, 0f, transform.position.z);
Vector3 destinationPosition = new Vector3(predictedAttackingPosition.x, 0f, predictedAttackingPosition.z);
Quaternion perfectAimRotation = Quaternion.LookRotation(destinationPosition - ourPosition);
transform.rotation = perfectAimRotation;
agent.updateRotation = true;
}
if (Quaternion.Angle(transform.rotation, wishRotation) > 0.1) //1 dann zielt er etwas länger aber genauer unnecessary jetzt wo die waffe sich sowieso zum gegner dreht
{
_aimed = false; //wishRotation vom Parent, wenn beide sich um mehr als 1 grad unterscheiden, dann haben wir uns noch nicht zum Gegner gedreht
}
}
//now it should perfectly hit, so we apply a skillbased random rotator function
return(_aimed);
}
private void MissileAttack()
{
MissileWeapon weapon = weapons[selectedWeapon] as MissileWeapon; //cast Notwendig //später das nur einmal machen
//wenn laudable - dann lade hier falls nicht geladen ist, wir laden schon bevor wir in Range sind
if (weapon.missileWeaponType == MissileWeapon.MissileWeaponType.Loadable && !weapon.weaponReadyToShoot && !weapon.isPreparingWeapon)
{
TurnToPosition(currentAttackingTargetTransform.position);
StartCoroutine("LoadWeapon");
//Loading
}
if (Vector3.Distance(transform.position, currentAttackingTargetTransform.position) < weapon.missileRange) // wenn wir im Range sind
{
//aiming
/*if (!hasCheckedDirectFire && automaticDirectFire && !moving) //checken wir nur wenn wir stehenbleiben
* {
* directFire = DirectFireCheck(weapon);
* hasCheckedDirectFire = true;
* }*/
agent.isStopped = true;
if (weapon.missileWeaponType == MissileWeapon.MissileWeaponType.Loadable) //extraabfrage loadable Weapons können nicht beim laden zielen, bogen schon
{
if (weapon.weaponReadyToShoot)
{
aimed = (Aim(weapon));
Debug.Log("loaded");
}
else
{
TurnToPosition(currentAttackingTargetTransform.position);
}
}
else
{
aimed = (Aim(weapon));
}
if (Quaternion.Angle(transform.rotation, wishRotation) < 5 && !raycastSendForThisAttack)
{//if turnedToDestination
directFire = DirectFireCheck(weapon);
raycastSendForThisAttack = true;
}
if (weapon.missileWeaponType == MissileWeapon.MissileWeaponType.Drawable) //den bogen/Wurfspeer spannen wir erst wenn wir in range sind
{
if (!weapon.weaponReadyToShoot && !weapon.isPreparingWeapon)
{
StartCoroutine("WeaponSpannen");
}
}
if (aimed && weapon.weaponReadyToShoot)
{
if (weapon.AmmoLeft())
{
RandomRotator(weapon);
weapon.Shoot();
raycastSendForThisAttack = false;
}
//else Debug.Log("no Ammo left");
}
}
else
{
SetDestinationAttack(currentAttackingTargetTransform.position);
//hasCheckedDirectFire = false;
}
}
private void Create()
{
// Create root gameobject
GameObject gameObject = new GameObject("NewMissileWeapon");
Selection.activeGameObject = gameObject;
// Create 3D model
if (missileWeaponModel != null)
{
GameObject meshObject = Instantiate(missileWeaponModel, gameObject.transform);
meshObject.name = "Model";
meshObject.transform.localPosition = Vector3.zero;
meshObject.transform.localRotation = Quaternion.identity;
}
// Create spawn point
GameObject spawnPointObject = new GameObject("MissileSpawnPoint");
spawnPointObject.transform.parent = gameObject.transform;
// Create and initialize necessary components
Module module = gameObject.AddComponent <Module>();
SerializedObject moduleSO = new SerializedObject(module);
moduleSO.Update();
MissileWeapon missileWeapon = gameObject.AddComponent <MissileWeapon>();
SerializedObject missileWeaponSO = new SerializedObject(missileWeapon);
missileWeaponSO.Update();
TargetLocker targetLocker = gameObject.AddComponent <TargetLocker>();
SerializedObject targetLockerSO = new SerializedObject(targetLocker);
targetLockerSO.Update();
Triggerable triggerable = gameObject.AddComponent <Triggerable>();
SerializedObject triggerableSO = new SerializedObject(triggerable);
triggerableSO.Update();
Repeater repeater = gameObject.AddComponent <Repeater>();
SerializedObject repeaterSO = new SerializedObject(repeater);
repeaterSO.Update();
ProjectileLauncher projectileLauncher = gameObject.AddComponent <ProjectileLauncher>();
SerializedObject projectileLauncherSO = new SerializedObject(projectileLauncher);
projectileLauncherSO.Update();
// Link Unity Events
UnityEventTools.AddPersistentListener(triggerable.onStartTriggering, repeater.StartTriggering);
UnityEventTools.AddPersistentListener(triggerable.onStopTriggering, repeater.StopTriggering);
UnityEventTools.AddPersistentListener(triggerable.onTriggerOnce, repeater.TriggerOnce);
UnityEventTools.AddPersistentListener(repeater.OnAction, projectileLauncher.LaunchProjectile);
// Update Module settings
moduleSO.FindProperty("label").stringValue = "HOMING MISSILE";
moduleSO.FindProperty("description").stringValue = "Homing missile.";
if (moduleType != null)
{
moduleSO.FindProperty("moduleType").objectReferenceValue = moduleType;
}
if (menuSprite != null)
{
moduleSO.FindProperty("menuSprite").objectReferenceValue = menuSprite;
}
moduleSO.ApplyModifiedProperties();
moduleSO.Update();
// Update projectile launcher settings
projectileLauncherSO.FindProperty("spawnPoint").objectReferenceValue = spawnPointObject;
projectileLauncherSO.FindProperty("addLauncherVelocityToProjectile").boolValue = true;
if (missilePrefab != null)
{
projectileLauncherSO.FindProperty("projectilePrefab").objectReferenceValue = missilePrefab.gameObject;
}
projectileLauncherSO.ApplyModifiedProperties();
projectileLauncherSO.Update();
// Update Missile Weapon settings
missileWeaponSO.FindProperty("targetLocker").objectReferenceValue = targetLocker;
missileWeaponSO.FindProperty("triggerable").objectReferenceValue = triggerable;
missileWeaponSO.FindProperty("repeater").objectReferenceValue = repeater;
missileWeaponSO.FindProperty("projectileLauncher").objectReferenceValue = projectileLauncher;
missileWeaponSO.ApplyModifiedProperties();
missileWeaponSO.Update();
}
/// <summary>
/// 返回该物体对目标单位来说是否可以自动拾取(即拾取后不会丢掉原来的东西)
/// </summary>
/// <param name="u"></param>
public static bool IsAutolootable(Unit u, LootItem loot)
{
if (loot.Dead != true && u.Dead != true && u.IsLootAble == true)
{
switch (loot.LootSettings.LootType)
{
case LootType.Weapon:
{
Weapon w = u.WeaponFromAssetName(loot.LootSettings.ObjectName);
if (w != null)
{
if (w.AmmoNum < w.maxAmmo)
{
return(true);
}
}
else if (loot.lootSettings.IsWeapon)
{
if (u.weapons.Count < u.maxWeaponNum)
{
return(true);
}
}
}
break;
case LootType.MissileWeapon:
{
MissileWeapon w = u.MissileWeaponFromAssetName(loot.LootSettings.ObjectName);
if (w != null)
{
if (w.Num < w.missileWeaponType.maxNum)
{
return(true);
}
}
else if (loot.lootSettings.IsWeapon)
{
if (u.missiles.Count < u.maxMissileWeaponNum)
{
return(true);
}
}
}
break;
case LootType.SkillItem:
if (u.skills.Count < u.maxSkillNum)
{
return(true);
}
break;
case LootType.QuestItem:
return(true);
break;
default:
break;
}
}
return(false);
}
public static void Loot(Unit u, LootItem loot)
{
if (loot.Dead != true && u.Dead != true && u.IsLootAble == true)
{
switch (loot.LootSettings.LootType)
{
case LootType.Weapon:
{
Weapon w = u.WeaponFromAssetName(loot.LootSettings.ObjectName);
if (w != null)
{
if (w.AmmoNum < w.maxAmmo)
{
w.AmmoNum += loot.BulletNum;
loot.BeginToDie();
loot.gameWorld.ShowLoot(u, loot);
}
}
else if (loot.lootSettings.IsWeapon)
{
u.GetWeapon(loot.LootSettings.ObjectName, loot.bulletNum);
loot.BeginToDie();
loot.gameWorld.ShowLoot(u, loot);
loot.gameWorld.ShowLootWeapon(u, loot);
}
}
break;
case LootType.MissileWeapon:
{
MissileWeapon w = u.MissileWeaponFromAssetName(loot.LootSettings.ObjectName);
if (w != null)
{
if (w.Num < w.missileWeaponType.maxNum)
{
w.Num += (int)loot.BulletNum;
loot.BeginToDie();
loot.gameWorld.ShowLoot(u, loot);
}
}
else if (loot.lootSettings.IsWeapon)
{
u.GetMissileWeapon(loot.LootSettings.ObjectName, loot.bulletNum);
loot.BeginToDie();
loot.gameWorld.ShowLoot(u, loot);
loot.gameWorld.ShowLootWeapon(u, loot);
}
}
break;
case LootType.SkillItem:
{
Skill s = u.SkillFromAssetName(loot.lootSettings.ObjectName);
if (s == null)
{
if (u.skills.Count < u.maxSkillNum)
{
u.AddSkill(loot.LootSettings.ObjectName);
loot.BeginToDie();
loot.gameWorld.ShowLoot(u, loot);
}
else
{
u.Interrupt();
if (u.CurrentSkill != null)
{
u.skills.Remove(u.CurrentSkill);
}
u.AddSkill(loot.LootSettings.ObjectName);
loot.BeginToDie();
loot.gameWorld.ShowLoot(u, loot);
}
}
}
break;
case LootType.QuestItem:
break;
default:
break;
}
}
}
