Unity ajustes de efecto disparos.

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();
}
}

Resumen de lo realizado asta la fecha con mi ultimo videojuego warlike_feats.

Resumen de lo realizado asta la fecha con mi ultimo videojuego warlike_feats.

Lo ultimo hacer una mirilla para disparos del player, estaba confuso el tema de apuntar y disparar lo estoy retocando desde aquí el enlace si lo queréis probar ----------

También estoy probando de modelar con blender unos camiones con enemigos que me van persiguiendo….hoy es domingo e echo un pequeño cambio en mi blog y ahora se ve todo con mucha mas claridad, y en el indice se ven bien todos los temas que llevo haciendo desde hace ya unos 4 años…..recomiendo que miréis el indice y cliqueis donde llame mas la atencion.

 

¿Como se escribe un script en C# para unity que combine dos teclas ala vez para realizar una acción o evento?

 

Sigo trabajando el videojuego, e puesto unos camiones enemigos con soldados dentro que debo destruir con granadas de mano y también e puesto una especie de mirilla para que al disparar sirva de guiá en el juego porque pienso se confundía un poco el tema de mis disparos los del player me vengo a referir, también empiezo a utilizar animaciones desde https://www.mixamo.com

Porque si tengo que hacerlas yo puedo alargar el videojuego meses incluso años….Explicare con mas detalle mis avances de aquí un par de días quizás mañana que es domingo y tengo tiempo libre todo el domingo.

¿Como se escribe un script en C# para unity que combine dos teclas ala vez para realizar una acción o evento?

Así…….en este ejemplo es solamente para movimiento constante de un gameobject hacia delante

pero se tiene que apretar la tecla letra “E” y el botón del ratón izquierdo si no no funciona para que funcione solo con la letra “E” se escribe así….

if (Input.GetKey(KeyCode.E))

CON LAS DOS TECLAS A ALA VEZ ASI

f ((Input.GetButton ("Fire1")) && (Input.GetKey (KeyCode.E)))

otro ejemplo

if ((Input.GetKey (KeyCode.W)) && (Input.GetKey (KeyCode.E)))

------------------------------------------------------------------------------------------------------------------------

-------------------------aqui el scrip-----------------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------------------------

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class fuerzadeempujee : MonoBehaviour {


public float moveSpeed = 30f;
public float turnSpeed = 90f;


void Update ()
{

if ((Input.GetButton ("Fire1")) && (Input.GetKey (KeyCode.E)))
//if (Input.GetKey(KeyCode.E))////funciona contantemente al apretar W mayusculas a de ser
//if (Input.GetKeyDown(KeyCode.W))// funciona pasito a pasito
//if(Input.GetKey(KeyCode.UpArrow))
transform.Translate(Vector3.forward * moveSpeed * Time.deltaTime);
}
}

warlike_feats

 

 LA VERSION DESCARGABLE FUNCIONA PERFECTAMENTE ASTA EL FINAL DEL VIDEOJUEGO