void FixedUpdate()
{
// se crea el area rectangular (hitbox) del dañador
crearHitbox();
//Debug.DrawLine(puntoA, puntoB, Color.red);
// OverlapArea comprueba si un colisionador cae dentro del hitbox del atacante
// los colisionadores se van a filtrar por las capas atacables especificadas
// devuelve un int que indica la cantidad de colliders que entraron al hitbox
int cantCollidersAtacados = Physics2D.OverlapArea(puntoA, puntoB, filtroContactoAtaque, resultsAtaqueCollider);
// se recorren todos los colliders que entro al hitbox del dañador
for (int i = 0; i < cantCollidersAtacados; i++)
{
colliderAtacable = resultsAtaqueCollider[i];
// se obtiene el script dañable del collider que entró al hitbox
Dañable dañable = colliderAtacable.GetComponent <Dañable>();
// si el collider tiene el script de dañable
if (dañable)
{
// la colision que entró al hitbox recibe daño, y se pasa como parametro este dañador
// para indicar cuanto daño debe recibir el dañable
dañable.recibirDaño(this);
// si el dañador es una bala y colisiona con un dañable el gameobject de este script (bala) se destruye
if (this.tag == "Bala")
{
Bala.destruirBala(this.gameObject);
}
}
}
}
void detectPosition(float X, float Y, GameObject go)
{
bala = go.GetComponent<Bala>();
if (Mathf.Abs(X) < Mathf.Abs(Y))
{
Xaux = 0;
if (Y >= 0)
{
bala.setSpeed(new Vector2(0, velocidadBala));
Yaux = velocidadBala;
}
else
{
bala.setSpeed(new Vector2(0, -velocidadBala));
Yaux = -velocidadBala;
}
}
else
{
Yaux = 0;
if (X >= 0)
{
bala.setSpeed(new Vector2(velocidadBala, 0));
Xaux = velocidadBala;
}
else
{
bala.setSpeed(new Vector2(-velocidadBala, 0));
Xaux = -velocidadBala;
}
}
}
void Shoot()
{
if (!presiono && balaPrefab != null && _firePoint != null)
{
GameObject miBala = Instantiate(balaPrefab, _firePoint.position, Quaternion.identity) as GameObject;
Bala balaComponente = miBala.GetComponent <Bala>();
if (movimiento.direccionX != 0)
{
if (movimiento.direccionX > 0)
{
balaComponente.direccion = Vector2.right;
}
else
{
balaComponente.direccion = Vector2.left;
}
}
else
{
if (movimiento.direccionY > 0)
{
balaComponente.direccion = Vector2.up;
}
else
{
balaComponente.direccion = Vector2.down;
}
}
}
}
/// <summary>
/// El jugador dispara una bala (la crea)
/// </summary>
public void Disparar()
{
if (balasJugador == null)
{
this.balasJugador = this.raquetaJugador.Disparar();
}
}
private void Disparar()
{
GameObject bala = Instantiate(BalaDeCanon);
Rigidbody rb = bala.GetComponent <Rigidbody>();
Bala balaComponent = bala.GetComponent <Bala>();
rb.transform.position = spawnBullet.position;
rb.transform.rotation = spawnBullet.rotation;
balaComponent.miTanque = gameObject;
//***Seccion para las balas especiales***//
if (balasFire) //Estas balas tienen un daño de 3 puntos sobre las paredes.
{
balaComponent.damage = 3;
enfriando = true; //Activamos el enfriamiento para luego poder volver a disparar
//disparado = false; //Habilitamos volver a disparar con esto
}
else if (balasDiamond) //Estas balas tienen daño de 3 puntos sobre las paredes y además...
{ //no se destruyen con ellas, de modo que las atraviesan
balaComponent.balaDiamond = true;
bala.GetComponent <SphereCollider>().isTrigger = true;
enfriando = true; //Activamos el enfriamiento para luego poder volver a disparar
//disparado = false; //Habilitamos volver a disparar con esto
}
else if (balasMachineGun)//Estas balas se disparan en ráfagas
{
balasMGRestantes--;
} //Se restan balas hasta que se termine la ráfaga
else //Para las balas comunes
{
enfriando = true;
} //Activamos el enfriamiento para luego poder volver a disparar
//disparado = false; //Habilitamos volver a disparar con esto
}
void Disparar()
{
GameObject obj = Instantiate(balita, this.transform.position, Quaternion.identity);
Bala bala = obj.GetComponent <Bala>();
bala.ActivarBala(this);
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.Mouse0))
{
Bala bala = (Bala)Instantiate(prefab, this.transform.position, this.transform.rotation);
}
}
/// <summary>
/// Carrega os assets necessários e cria centenas de instâncias
/// </summary>
/// <param name="contents">Instância de ContentManager</param>
public static void LoadContent(ContentManager contents)
{
content = contents;
balasAtivas = new List <Bala>(500);
balasMortas = new List <Bala>(500);
misseisAtivos = new List <Missil>(500);
misseisMortos = new List <Missil>(500);
balaplayer = contents.Load <Texture2D>("balaplayer");
balainimigo = contents.Load <Texture2D>("balainimigo");
missilplayer = contents.Load <Texture2D>("missilPlayer");
missilinimigo = contents.Load <Texture2D>("missil");
baladefesas = contents.Load <Texture2D>("baladefesas");
vectorTemp = Vector2.Zero;
//gerar 100 balas vazias
for (int i = 0; i < 500; i++)
{
balaTemp = new Bala(content, "balaplayer", 0, OrigemBala.player, DireccaoBala.EmFrente);
balasMortas.Add(balaTemp);
}
//gerar 50 misseis vazios
for (int i = 0; i < 500; i++)
{
missilTemp = new Missil(content, "missilPlayer", TipoMissil.EmFrente, 0, OrigemBala.player);
misseisMortos.Add(missilTemp);
}
}
void Disparar()
{
Bala bala = DespacharBalaLibre();
disparo.Play();
bala.ActivarBala(this);
}
/// <summary>
/// Recicla uma bala que é necessária para o jogo
/// </summary>
/// <param name="assetname">Nome da textura a utilizar</param>
/// <param name="direcao">Direção do ecrã em que a bala se movimenta</param>
/// <param name="origemBala">Entidade que originou a bala</param>
/// <param name="direcaoBala">Tipo de bala - Em frente, cima ou baixo</param>
/// <param name="parent">Turret que disparou a bala</param>
/// <returns>Uma bala reciclada</returns>
public static Bala addBala(string assetname, int direcao, OrigemBala origemBala, DireccaoBala direcaoBala, Defence parent = null)
{
balaTemp = balasMortas.First();
if (assetname == "balaplayer")
{
balaTemp.image = balaplayer;
}
else if (assetname == "baladefesas")
{
balaTemp.image = baladefesas;
}
else
{
balaTemp.image = balainimigo;
}
balaTemp.parent = parent;
vectorTemp.X = 1f;
vectorTemp.Y = (float)balaTemp.image.Height / (float)balaTemp.image.Width;
balaTemp.size = vectorTemp;
balaTemp.spriteEffects = direcao > 0 ? SpriteEffects.None : SpriteEffects.FlipHorizontally;
balaTemp.direccao = direcao;
balaTemp.origemBala = origemBala;
balaTemp.direccaobala = direcaoBala;
balaTemp.direction = Vector2.Zero;
balasAtivas.Add(balaTemp);
balasMortas.Remove(balaTemp);
return(balaTemp);
}
void Shoot()
{
switch (_player)
{
case Player.PLAYER_1:
if (_turno == true)
{
_cannonBall = Instantiate(_bomb);
_bala = _cannonBall.GetComponent <Bala>();
_cannonBall.transform.position = _canonTarget.position;
_bala.Angle = _canon.transform.eulerAngles.z;
_bala.Vel = _balaVelP1;
_bala.Fired = true;
}
break;
case Player.PLAYER_2:
if (_turno == false)
{
_cannonBall = Instantiate(_bomb);
_bala = _cannonBall.GetComponent <Bala>();
_cannonBall.transform.position = _canonTarget.position;
_bala.Angle = _canon.transform.eulerAngles.z;
_bala.Vel = _balaVelP2;
_bala.Fired = true;
}
break;
}
}
public void Shoot()
{
contadorDeDisparos++;
if (contadorDeDisparos > 5)
{
vidaJugador.añadirDaño(1);
}
if (prefabBala != null && _Cañon != null)
{
GameObject myBala = Instantiate(prefabBala, _Cañon.position, Quaternion.identity) as GameObject;
Bala componenteDeLaBala = myBala.GetComponent <Bala>();
if (transform.localScale.x < 0f)
{
componenteDeLaBala.direccion = Vector2.left;
}
else
{
componenteDeLaBala.direccion = Vector2.right;
}
}
}
public void disparar()
{
Bala obj = Instantiate(disparo);
obj.transform.position = transform.position;
obj.transform.forward = transform.forward;
obj.speed += inertia;
}
/// <summary>
/// Recicla uma bala que já não é necessária no jogo
/// </summary>
/// <param name="bala">Instância de bala a reciclar</param>
public static void removeBala(Bala bala)
{
if (balasAtivas.Contains(bala))
{
balasAtivas.Remove(bala);
balasMortas.Add(bala);
}
}
void Start()
{
velRot = 70;
for (int i = 0; i < balasInstanciadas.Length; i++)
{
balasInstanciadas[i] = Instantiate(bala, punta.position, punta.rotation);
infoBala = balasInstanciadas[i].GetComponent <Bala>();
infoBala.Desactivarse();
}
}
private void Update()
{
if (Input.GetKeyDown(disparar))
{
GameObject copiaBala = GameObject.Instantiate(modeloBala);
Bala bala = copiaBala.GetComponent <Bala>();
bala.Disparar(fuego.transform);
StartCoroutine(mostrarFuego());
}
}
void shoot()
{
GameObject balaGO = (GameObject)Instantiate(balaprefab, firepoint.position, firepoint.rotation);
Bala bala = balaGO.GetComponent <Bala>();
if (bala != null)
{
bala.Seek(target);
}
}
void Shoot()
{
GameObject bulletGO = (GameObject)Instantiate(bulletPrefab, bulletPoint.position, bulletPoint.rotation);
Bala bala = bulletGO.GetComponent <Bala>();
if (bala != null)
{
bala.damage = danyoPorNivel[nivelActual];
bala.setTarget(target);
}
}
void DisparTorreObjectiu()
{
//Iniciament de la bala ASSET
GameObject balaTrajecte = (Instantiate(balaCano, puntDispar.position, puntDispar.rotation));
Bala balaTorre = balaTrajecte.GetComponent <Bala>();
//Passam parametre de balaTorre d'aquest objectiu
if (balaTorre != null)
{
balaTorre.TrovarObjectiu(objectiu);
}
}
private Bala DespacharBalaLibre()
{
Bala libre = null;
for (int i = 0; i < balas.Length; i++)
{
libre = balas[i].GetComponent <Bala>();
if (!libre.Disparada)
{
break;
}
}
return(libre);
}
public void Shoot()
{
if (prefabBala != null && _Cañon != null && jugador != null)
{
GameObject myBala = Instantiate(prefabBala, _Cañon.position, Quaternion.identity) as GameObject;
Bala componenteDeLaBala = myBala.GetComponent <Bala>();
if (jugador.transform.localScale.x < 0f)
{
componenteDeLaBala.direccion = Vector2.left;
}
else
{
componenteDeLaBala.direccion = Vector2.right;
}
}
}
void Update()
{
if (Input.GetKey(apuntArriva))
{
transform.Rotate(Vector3.right * Time.deltaTime * -velRot);
}
if (Input.GetKey(apuntAbajo))
{
transform.Rotate(Vector3.right * Time.deltaTime * velRot);
}
if (Input.GetKey(apuntDerecha))
{
transform.Rotate(Vector3.up * Time.deltaTime * velRot, Space.World);
}
if (Input.GetKey(apuntIzquierda))
{
transform.Rotate(Vector3.up * Time.deltaTime * -velRot, Space.World);
}
if (Input.GetKeyDown(disparar))
{
int i = 0;
while (i != balasInstanciadas.Length)
{
if (!balasInstanciadas[i].activeInHierarchy)
{
infoBala = balasInstanciadas[i].GetComponent <Bala>();
infoBala.Activarse(punta.position, punta.rotation);
//balasInstanciadas[i].transform.position = punta.position;
//balasInstanciadas[i].transform.rotation = punta.rotation;
//balasInstanciadas[i].SetActive(true);
i = balasInstanciadas.Length;
}
else
{
i++;
}
}
}
}
public void dispararBala(int tipobala, int direccion)
{
TgcMesh instance = balamesh.createMeshInstance(balamesh.Name + "_");
if (tipobala == 1)
{
instance.Scale = new Vector3(3f, 3f, 3f);
}
else
{
instance.Scale = new Vector3(2f, 2f, 2f);
}
var pos = this.Mesh.Position;
var rot = this.Mesh.Rotation;
Vector3 a = new Vector3(0,10,0);
instance.Position = this.Mesh.Position +a ;
instance.Rotation = this.Mesh.Rotation;
//dispara a 90 grados
if (direccion == 0)
{
instance.rotateY(Geometry.DegreeToRadian(270));
}
else
{
instance.rotateY(Geometry.DegreeToRadian(90));
}
var enemigos = new List<Barco>();
if (tipobala == 1)
{
var bala = new Bala(instance, Danio, BarcosEnemigos, tipobala);
balas.Add(bala);
}
else
{
var bala = new Bala(instance, Danio, BarcosEnemigos, tipobala);
balas.Add(bala);
}
}
public void disparar()
{
Bala disparo = new Bala(canion, logica);
disparo.init("Canionero", canion); //el parametro es el nombre de la textura para el mesh
}
/// <summary>
/// Mueve todo lo que hay en pantalla, la pelota, las balas y las raquetas
/// </summary>
public void Mover()
{
if (this.bola.Direccion)
{
this.bola.Posicion = this.NuevoPunto(this.bola.Posicion.Y + this.bola.Velocidad);
}
else
{
this.bola.Posicion = this.NuevoPunto(this.bola.Posicion.Y - this.bola.Velocidad);
}
bool acertado = false;
if (this.balasJugador != null)
{
this.balasJugador.Mover(true);
acertado = this.raquetaEnemigo.RecibirDisparo(balasJugador);
if (acertado || this.balasJugador.Posicion.Y < 0)
{
this.balasJugador = null;
}
}
if (this.balasEnemigo != null)
{
this.balasEnemigo.Mover(false);
acertado = this.raquetaJugador.RecibirDisparo(balasEnemigo);
if (acertado || this.balasEnemigo.Posicion.Y > 250)
{
this.balasEnemigo = null;
}
}
if (bola.Posicion.X < raquetaEnemigo.Posicion.X)
{
raquetaEnemigo.Mover(-1, 0);
}
else
{
raquetaEnemigo.Mover(1, 0);
}
if (this.balasEnemigo == null)
{
this.balasEnemigo = raquetaEnemigo.Disparar();
}
if (destino.X > raquetaJugador.Posicion.X)
{
raquetaJugador.Mover(raquetaJugador.Velocidad, 0);
}
if (destino.X < raquetaJugador.Posicion.X)
{
raquetaJugador.Mover(-raquetaJugador.Velocidad, 0);
}
if (destino.Y > raquetaJugador.Posicion.Y)
{
raquetaJugador.Mover(0, raquetaJugador.Velocidad);
}
if (destino.Y < raquetaJugador.Posicion.Y)
{
raquetaJugador.Mover(0, -raquetaJugador.Velocidad);
}
}
/// <summary>
/// El Enemigo recibe un disparo
/// </summary>
/// <param name="balasera">Bala que le pega</param>
public void PegarEnemigo(Bala balasera)
{
raquetaEnemigo.RecibirDisparo(balasera);
}
/// <summary>
/// El jugador recibe un disparo
/// </summary>
/// <param name="balasera">Bala que le pega</param>
public void PegarJugador(Bala balasera)
{
raquetaJugador.RecibirDisparo(balasera);
}
