😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃
Mi nuevo videojuego “ATAKEAEREO”
😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁
HOMENAJE A UN VIDEOJUEGO DE MAQUINAS RECREATIVAS DE LOS AÑOS 80 DESTRULLE EL NUCLEO W-A-S-D- MOUSE BOTON IZQUIERDO
TRIBUTE TO A VIDEO GAME OF RECREATIONAL MACHINES FROM THE 80'S DESTROY THE CORE W-A-S-D- MOUSE BUTTON LEFT
videojuegos antiguos de años atras creaciones personales
THE END
warlike feats
Doy por finalizado el videojuego, no puedo mas, quiero hacer otros videojuegos este lo e retocado asta donde mi paciencia a llegado, pero me siento saturado, de todas formas el videojuego tiene un principio y un final con pantalla de éxito o victoria de haber superado los 3 niveles sencillos que tiene.
SIMPLEMENTE ACUMULA VIDAS Y ACUMULA CAPSULAS PARA SUMAR PUNTOS Y ACUMULA ÍTEMS Y EL VIDEOJUEGO LO GANAS CON FACILIDAD.
Resumiendo lo principal del video tutorial es tener en cuenta que la linea que hace de mirilla para apuntar es un duplicado del gameobject un cubo que tiene el script del mouse que sirve para apuntar balanceando el arma, este es hijo la mirilla es hijo del gameobject que contiene ese script y luego el arma también esta puesto de hijo del cubo gameobject que contiene el script del mouse para balancear el arma y apuntar….
Mas fácil pongo un
grafico general del player.
Como un árbol del que salen las ramas, el player seria el tronco, de donde parten los disparos seria una rama del tronco, y de esa rama saldrían otras dos ramas la mirilla que señala las trayectorias de los disparos y el arma ametralladora o rifle.
player…………...gameobject desde donde parten los disparos fogonazos………..gameobject que marca las trayectorias de los disparos mirilla y también el arma……
using
System;
using
UnityEngine;
using
UnityStandardAssets.CrossPlatformInput;
namespace
UnityStandardAssets.Utility
{
public
class
SimpleMouseRotator : MonoBehaviour
{
//
A mouselook behaviour with constraints which operate relative to
//
this gameobject's initial rotation.
//
Only rotates around local X and Y.
//
Works in local coordinates, so if this object is parented
//
to another moving gameobject, its local constraints will
//
operate correctly
//
(Think: looking out the side window of a car, or a gun turret
//
on a moving spaceship with a limited angular range)
//
to have no constraints on an axis, set the rotationRange to 360 or
greater.
public
Vector2 rotationRange = new
Vector3(70,
70);
public
float
rotationSpeed = 10;
public
float
dampingTime = 0.2f;
public
bool
autoZeroVerticalOnMobile = true;
public
bool
autoZeroHorizontalOnMobile = false;
public
bool
relative = true;
private
Vector3 m_TargetAngles;
private
Vector3 m_FollowAngles;
private
Vector3 m_FollowVelocity;
private
Quaternion m_OriginalRotation;
private
void
Start()
{
m_OriginalRotation = transform.localRotation;
}
private
void
Update()
{
//
we make initial calculations from the original local rotation
transform.localRotation = m_OriginalRotation;
//
read input from mouse or mobile controls
float
inputH;
float
inputV;
if
(relative)
{
inputH = CrossPlatformInputManager.GetAxis("Mouse
X");
inputV = CrossPlatformInputManager.GetAxis("Mouse
Y");
//
wrap values to avoid springing quickly the wrong way from positive to
negative
if
(m_TargetAngles.y > 180)
{
m_TargetAngles.y -= 360;
m_FollowAngles.y -= 360;
}
if
(m_TargetAngles.x > 180)
{
m_TargetAngles.x -= 360;
m_FollowAngles.x -= 360;
}
if
(m_TargetAngles.y < -180)
{
m_TargetAngles.y += 360;
m_FollowAngles.y += 360;
}
if
(m_TargetAngles.x < -180)
{
m_TargetAngles.x += 360;
m_FollowAngles.x += 360;
}
#if
MOBILE_INPUT
//
on mobile, sometimes we want input mapped directly to tilt value,
//
so it springs back automatically when the look input is
released.
if
(autoZeroHorizontalOnMobile) {
m_TargetAngles.y
= Mathf.Lerp (-rotationRange.y * 0.5f,
rotationRange.y * 0.5f,
inputH * .5f
+ .5f);
}
else
{
m_TargetAngles.y
+= inputH * rotationSpeed;
}
if
(autoZeroVerticalOnMobile) {
m_TargetAngles.x
= Mathf.Lerp (-rotationRange.x * 0.5f,
rotationRange.x * 0.5f,
inputV * .5f
+ .5f);
}
else
{
m_TargetAngles.x
+= inputV * rotationSpeed;
}
#else
//
with mouse input, we have direct control with no springback
required.
m_TargetAngles.y += inputH*rotationSpeed;
m_TargetAngles.x += inputV*rotationSpeed;
#endif
//
clamp values to allowed range
m_TargetAngles.y = Mathf.Clamp(m_TargetAngles.y,
-rotationRange.y*0.5f,
rotationRange.y*0.5f);
m_TargetAngles.x = Mathf.Clamp(m_TargetAngles.x,
-rotationRange.x*0.5f,
rotationRange.x*0.5f);
}
else
{
inputH = Input.mousePosition.x;
inputV = Input.mousePosition.y;
//
set values to allowed range
m_TargetAngles.y = Mathf.Lerp(-rotationRange.y*0.5f,
rotationRange.y*0.5f,
inputH/Screen.width);
m_TargetAngles.x = Mathf.Lerp(-rotationRange.x*0.5f,
rotationRange.x*0.5f,
inputV/Screen.height);
}
//
smoothly interpolate current values to target angles
m_FollowAngles = Vector3.SmoothDamp(m_FollowAngles,
m_TargetAngles, ref
m_FollowVelocity, dampingTime);
//
update the actual gameobject's rotation
transform.localRotation =
m_OriginalRotation*Quaternion.Euler(-m_FollowAngles.x,
m_FollowAngles.y, 0);
}
}
}
-----------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------
using
System.Collections;
using
System.Collections.Generic;
using
UnityEngine;
public
class
launchermasvelocidad : MonoBehaviour {
public
Rigidbody projectile;
public
Rigidbody explosiveProjectile;
public
float
launchspeed = 50;
public
bool
useExplodingProjectiles = false;
private
float
_LaunchDelayTime = 0.0f;
public
int
stackSize = 60;
public
Transform launchHole1;
public
Transform launchHole2;
private
Stack _Projectiles;
private
Stack _ExplosiveProjectiles;
private
Transform _myTransform;
//
Use this for initialization
void
Start ()
{
_myTransform
= transform;
_Projectiles
= new
Stack();
if(useExplodingProjectiles)
{
_ExplosiveProjectiles
= new
Stack();
}
for(int
i = 0;
i < stackSize; i++)
{
Rigidbody
tr = Instantiate (projectile, _myTransform.position,
_myTransform.rotation) as
Rigidbody;
PushProjectile(tr);
if(useExplodingProjectiles)
{
Rigidbody
rr = Instantiate (explosiveProjectile, _myTransform.position,
_myTransform.rotation) as
Rigidbody;
PushExplosiveProjectile(rr);
}
}
}
//
Update is called once per frame
void
Update ()
{
if(_Projectiles.Count
> 0)
{
if(Time.time
> _LaunchDelayTime)
{
if
(Input.GetButton ("Fire1"))
////ametralladora
// if
(Input.GetButtonDown ("Fire1")) original tiro a
tiro
{
Rigidbody
tr =
PopProjectile();
tr.gameObject.SetActive(true);
tr.transform.position
= launchHole1.position;
tr.transform.rotation
= launchHole1.rotation;
tr.velocity
= transform.TransformDirection (Vector3.forward *
launchspeed);
tr
=
PopProjectile();
tr.gameObject.SetActive(true);
tr.transform.position
= launchHole2.position;
tr.transform.rotation
= launchHole2.rotation;
tr.velocity
= transform.TransformDirection (Vector3.forward *
launchspeed);
_LaunchDelayTime
= Time.time +
0.1f;
}
}
}
if(useExplodingProjectiles)
{
if(_ExplosiveProjectiles.Count
> 0)
{
if(Time.time
> _LaunchDelayTime)
{
if
(Input.GetButtonDown ("Fire2"))
{
Rigidbody
tr =
PopExplosiveProjectile();
tr.gameObject.SetActive(true);
tr.transform.position
= launchHole1.position;
tr.transform.rotation
= launchHole1.rotation;
tr.velocity
= transform.TransformDirection (Vector3.forward *
launchspeed);
tr
=
PopExplosiveProjectile();
tr.gameObject.SetActive(true);
tr.transform.position
= launchHole2.position;
tr.transform.rotation
= launchHole2.rotation;
tr.velocity
= transform.TransformDirection (Vector3.forward *
launchspeed);
_LaunchDelayTime
= Time.time + 0.5f;
}
}
}
}
}
public
void
PushProjectile(Rigidbody
x)
{
x.gameObject.SetActive(false);
_Projectiles.Push(x);
}
public
Rigidbody PopProjectile()
{
return
(Rigidbody)_Projectiles.Pop();
}
public
void
PushExplosiveProjectile(Rigidbody
x)
{
x.gameObject.SetActive(false);
_ExplosiveProjectiles.Push(x);
}
public
Rigidbody PopExplosiveProjectile()
{
return
(Rigidbody)_ExplosiveProjectiles.Pop();
}
}
----------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------
///
<summary>
///
Launcher.
///
///
3/2/2013
///
Steve Peters
///
Game Developers Guild - Miami, FL
///
///
Allows us to launch projectiles at a wall. It preinstantiates and
stores the projectiles in a
///
stack to improve performance
///
</summary>
using
UnityEngine;
using
System.Collections;
public
class
Launcher : MonoBehaviour
{
public
Rigidbody projectile;
public
Rigidbody explosiveProjectile;
public
float
launchspeed = 50;
public
bool
useExplodingProjectiles = false;
private
float
_LaunchDelayTime = 0.0f;
public
int
stackSize = 60;
public
Transform launchHole1;
public
Transform launchHole2;
private
Stack _Projectiles;
private
Stack _ExplosiveProjectiles;
private
Transform _myTransform;
//
Use this for initialization
void
Start ()
{
_myTransform
= transform;
_Projectiles
= new
Stack();
if(useExplodingProjectiles)
{
_ExplosiveProjectiles
= new
Stack();
}
for(int
i = 0;
i < stackSize; i++)
{
Rigidbody
tr = Instantiate (projectile, _myTransform.position,
_myTransform.rotation) as
Rigidbody;
PushProjectile(tr);
if(useExplodingProjectiles)
{
Rigidbody
rr = Instantiate (explosiveProjectile, _myTransform.position,
_myTransform.rotation) as
Rigidbody;
PushExplosiveProjectile(rr);
}
}
}
//
Update is called once per frame
void
Update ()
{
if(_Projectiles.Count
> 0)
{
if(Time.time
> _LaunchDelayTime)
{
if
(Input.GetButton ("Fire1"))
////ametralladora
// if
(Input.GetButtonDown ("Fire1")) original tiro a
tiro
{
Rigidbody
tr =
PopProjectile();
tr.gameObject.SetActive(true);
tr.transform.position
= launchHole1.position;
tr.transform.rotation
= launchHole1.rotation;
tr.velocity
= transform.TransformDirection (Vector3.forward *
launchspeed);
tr =
PopProjectile();
tr.gameObject.SetActive(true);
tr.transform.position
= launchHole2.position;
tr.transform.rotation
= launchHole2.rotation;
tr.velocity
= transform.TransformDirection (Vector3.forward *
launchspeed);
_LaunchDelayTime
= Time.time +
0.5f;
}
}
}
if(useExplodingProjectiles)
{
if(_ExplosiveProjectiles.Count
> 0)
{
if(Time.time
> _LaunchDelayTime)
{
if
(Input.GetButtonDown ("Fire2"))
{
Rigidbody
tr =
PopExplosiveProjectile();
tr.gameObject.SetActive(true);
tr.transform.position
= launchHole1.position;
tr.transform.rotation
= launchHole1.rotation;
tr.velocity
= transform.TransformDirection (Vector3.forward *
launchspeed);
tr
=
PopExplosiveProjectile();
tr.gameObject.SetActive(true);
tr.transform.position
= launchHole2.position;
tr.transform.rotation
= launchHole2.rotation;
tr.velocity
= transform.TransformDirection (Vector3.forward *
launchspeed);
_LaunchDelayTime
= Time.time + 0.5f;
}
}
}
}
}
public
void
PushProjectile(Rigidbody x)
{
x.gameObject.SetActive(false);
_Projectiles.Push(x);
}
public
Rigidbody PopProjectile()
{
return
(Rigidbody)_Projectiles.Pop();
}
public
void
PushExplosiveProjectile(Rigidbody
x)
{
x.gameObject.SetActive(false);
_ExplosiveProjectiles.Push(x);
}
public
Rigidbody PopExplosiveProjectile()
{
return
(Rigidbody)_ExplosiveProjectiles.Pop();
}
}
