Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Temas - Antonio

#1
Interfaz / ¿Cómo se encajan los elementos de UI?
Enero 20, 2020, 07:26:01 PM
Ayer estuve dando vueltas otra vez intentando hacer menús, pero se me siguen mareando los elementos UI.(Las ventanas son Image UI)
 

 
Este es mi ejemplo más reciente, pero llevo lidiando con este problema mucho tiempo.
 
En este ejemplo, intento que aparezca esa ventana a la derecha:
 
- Que aparezca pegada a la ventana de Settings (ni más lejos ni que se pisen), 

- Que no se corte al final de la ventana.

- Que se mantengan ciertos márgenes.

- Que la ventana de Settings aparezca relativamente a la izquierda de la pantalla (podía ponerla en el centro y que se estrechara, pero prefiero que aparezca fija a la izquierda y usar el centro y la mitad derecha para mostrar la información, distintos paneles y tal).
 
Esto esta hecho con un canvas usando Screen-Space camera y Scale with Screen Size.

Como hijo tiene otros 2 canvas (uno para el menu pause, y otro para el menu Settings. El menu pause no tiene ventana a la derecha y sus botones tienen otros nombres y funciones, pero visualmente son muy similares).

Cada subCanvas (pause y settings) tiene un Elemento imagen que es el cuadrado azul, y este elemento, tienen varios hijos múltiples que son los botones).
 
La ventana a la derecha, no sé si hacerla como sub-canvas de Settings o si ponerla simplemente como otro hijo o qué hacer con ella... @_@
 
He probado distintas configuraciones con los anclajes y el escalado, pero no consigo mantenerlo, también he probado el Layout horizontal, pero aunque me mantiene los márgenes, hace que las dos ventanas se pisen o se separen.
 
Buscando, veo que muchos hacen un diseño de un menó con objetos flotantes separados, pero si quisiera objetos unidos, ¿como podría hacerlo?
 
Otras veces he intentado completar más un menú para gestiones (un lado columna de objetos, al otro lado un mapa y debajo unas estadísticas)  pero me siguen dando la tabarra problemas similares.  ¿Conocéis algún procedimiento para tratar con este embrollo? @_@
 
 
#2
Tengo un problema recurrente, varias veces he hecho algún código para mover el jugador utilizando el Character Controller pero a la hora de aplicar gravedad, doy con un problema.
 
 
 
A diferencia del controlador de rigid body, el character controller no tiene physic materials, así que cuando este colisiona no hay deslizamiento, eso hace que mi personaje, al pasar por algún bordillo se quede atascado en el aire (a menos que vaya corriendo, entonces la velocidad de desplazamiento es tan alta que al caer está más alejado del borde y no colisiona). Pero aunque parezca un caso raro, resulta que ocurre mucho cuando lo pruebo, jugando a escalar y bajar, muchas veces se me queda el personaje congelado ahí por esto mismo.  (Como no puede bajar hasta el suelo, se queda congelado con la animación de caida en el estado de caida).
 

 
 
 


En el Update, para el movimiento había intentado esto:
 

//Move
         if ((AllowControls) && (GravState == GravityState.Land))
         {
            moveDirection = vertical * (Vector3.Scale(cam.forward, new Vector3(1, 0, 1)).normalized) + horizontal * cam.right;
            IsMoving = (moveDirection.magnitude > 0.1f)? true : false;
            moveDirection.Normalize();
            moveDirection = transform.InverseTransformDirection(moveDirection);
         }
                if ((GravState == GravityState.Falling) || (GravState == GravityState.FreeFalling))
                {
                        //moveDirection = transform.forward * 0.02f * Time.deltaTime;
                }
                moveDirection.y = moveDirection.y - verticalDirection;

 


Esa línea que esta comentada, pretendía mover al jugador hacia delante (y después un poco hacia abajo) en caso de que estuviera cayendo, pero la cosa tampoco me funciona, al activarla, el personaje va haciendo glitches hasta llegar al suelo, (como si se saliese del estado de caída y volviese a entrar continuamente).
 
También probé reducir el tamaño de la cápsula (está a 0.4 y la puse a 0.2) efectivamente reduce las veces en las que este problema se da, pero me causa otros problemas de clipping en la animación de esacalada (el personaje entra más de lo que está previsto y escala con las piernas hundidas en el bloque), así que lo he vuelto a poner a 0.4 para que haya más espacio entre la colisión y el origen del jugador.
 
¿Alguien se le ocurre alguna manera de como enfocar esto? No creo que sea algo que sólo me pase a mi, ¿como se suele solventar este problema con los bordillos? O_ò

 
 
 
 
 
 
Pongo aquí el código del jugador que estoy escribiendo en spoiler porque es un poco largo.
 




 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
[RequireComponent(typeof(Animator))]
public class GO_Player : MonoBehaviour
{
//REFERENCES
Player_Input PI;
Camera_Manager CM;
Animator anim;
CharacterController controller;
public GameObject Model; //This need to be public to can be accessed from the outside.
public Transform CameraTarget;
public Transform cam;      //Used to update the camForward.
//INPUTS

public float horizontal;
public float vertical;
public bool walk;
public bool sprint;
public bool jump =false;
public bool crouch = false;
public bool action = false;
public bool aim = false;
public bool inv = false;
public bool speak = false;

public float mouseX;
public float mouseY;
//VARS
public   enum State {Explorer, Aiming, AimingCorner, Lay, Crawling, Sneaking, Covering, Sliding, Escalating, Special, Swimming, Diving, Driving, Death};
    public enum GravityState { Land, Falling, FreeFalling, Jumping, Floating, Deactivated};
    public State CurrentState = State.Explorer;
public State AnimState = State.Explorer;
    public GravityState GravState = GravityState.Land;
   
private Vector3 moveDirection = Vector3.zero;
    public float MoveSpeed = 6.0f;
    private float verticalDirection = 0.0f;
    public float gravity = 20.0f;
    private Vector3 rotDirection = Vector3.zero; //This is variable, to calculate the progress of the rotation
private Vector3 rotTarget = Vector3.zero; //This is a reference, used when this is not calculated in the update because AllowRot is false.
    public float NormalRotationSpeed = 360.0f;
    public float AimingRotationSpeed = 360.0f;
    //Blockers
    public bool StopInputUpdate = false; //Debug
public bool AllowControls = true;
public bool AllowRot = true;
public bool AllowGravity = true;
public bool AllowAnimationMatch = false;
//Sensors
public bool IsMoving = false;
public bool IsGrounded = true;
RaycastHit hit;
public float DistanceToFloor;
public LayerMask GroundLayer;
public float TimeStartedToFall;

//Weights of Animator Layers
float LayerFallingWeight = 0.0f;
float AimingCornerWeight = 0.0f;
//For special animations, set by external triggers
Transform AnimIKTransform; //For edge climbing or switches interactions.
Transform DynamicIKTransform; //For edge climbing that can happens anywhere. Instead to go creating and erasing, ensures that there is only one and reuses it.
AvatarTarget AnimAvatarTarget; //Chose which piece of the body match with the AnimIKTransform.
void Start ()
{
   Model.transform.SetAsFirstSibling();
   controller = GetComponent<CharacterController>();
   PI = GetComponent<Player_Input>();
   SetupAnimator();
   
   CM = cam.gameObject.GetComponent<Camera_Manager>();
   CM.PI = PI;
   if (CameraTarget != null)
   {
      CM.target = CameraTarget;
   }else{
      CM.target = transform;
      print ("Error: No camera target in player");
   }
   DynamicIKTransform = new GameObject().transform;
}
public void SetupAnimator (Animator targetAnim = null)
{
   anim = GetComponent<Animator>();
   if (targetAnim == null) //Destroy all the animators that were in the children object.
   {
      Animator[] anims = GetComponentsInChildren<Animator> ();
      for (int i = 0; i < anims.Length; i++)
      {
         if (anims [i] != anim)
         {
            anim.avatar = anims [i].avatar;
            Model =  anims[i].gameObject;
            Destroy (anims [i]);
            break;
         }
      }
   } else {
      anim.avatar = targetAnim.avatar;
      Model =  targetAnim.gameObject;
      Destroy (targetAnim);
   }
}

/*
It sets the direction of the camera, according to the pressed keys.
Then it uses it to find out, if the player is actually moving, (to activate the walk animation that makes the player actually move)
And also it uses that direction to find out where the player needs to be facing.
 */
 
void Update ()
{
   //INPUTS
   if (!StopInputUpdate)   PI.UpdateInput ();
        verticalDirection = CheckGravity();
       
   //Compute actions //{Explorer, Aiming, Lay, Crawling, Sneaking, Covering, Sliding, Escalating, Special, Swimming, Diving, Driving, Death};
   switch (CurrentState)
   {
      case State.Explorer://-------------------------------------------------------------------------------------------------------------//
      {
         //Move
         if ((AllowControls) && (GravState == GravityState.Land))
         {
            moveDirection = vertical * (Vector3.Scale(cam.forward, new Vector3(1, 0, 1)).normalized) + horizontal * cam.right;
            IsMoving = (moveDirection.magnitude > 0.1f)? true : false;
            moveDirection.Normalize();
            moveDirection = transform.InverseTransformDirection(moveDirection);
         }
                if ((GravState == GravityState.Falling) || (GravState == GravityState.FreeFalling))
                {
                        //moveDirection = transform.forward * 0.02f * Time.deltaTime;
                }
                moveDirection.y = moveDirection.y - verticalDirection;
                //Rotation
                if (AllowRot)
         {
            //rotDirection = transform.InverseTransformDirection(moveDirection);
            rotDirection = moveDirection;
         }else{
            rotDirection = transform.InverseTransformDirection(rotTarget); //Rotation from the target.
         }
         // Apply rotation
         float GoalRotation = Mathf.Atan2(rotDirection.x, rotDirection.z);
         transform.Rotate(0, GoalRotation * NormalRotationSpeed * Time.deltaTime, 0);
         //Sensors
         //Climb
         RaycastHit wallhit;
         Debug.DrawRay (transform.position + new Vector3 (0.0f,0.5f,0.0f), transform.forward * 0.75f,Color.green);
         if (Physics.Raycast(transform.position + new Vector3 (0.0f,0.5f,0.0f), transform.forward, out wallhit, 0.75f, GroundLayer))
         {
            Col_Tags tags = wallhit.transform.GetComponent<Col_Tags>();
            if (tags != null)
            {
               if (tags.Climb)
               {
                  if ((AllowControls) && (action))
                  {
                     
                     //1st, check the height
                     RaycastHit heighthit;
                     Vector3 WallhitPoint = wallhit.point - (wallhit.normal * 0.1f);
                          if (Physics.Raycast(WallhitPoint + Vector3.up * 100, -Vector3.up, out heighthit, 105, GroundLayer))
                          {
                        //Get the height and set the climb animation.
                        //Set the low climb by default
                        float EdgeHeight = Vector3.Distance (WallhitPoint, heighthit.point) + 0.5f;
                        int AnimationType = 1;
                        if (EdgeHeight > 1.25f)//It the medium climb
                        {
                           AnimationType = 2;
                        }
                        //print (EdgeHeight + " " + Time.time);
                        //2nd, check if theres is space
                        if (!Physics.CapsuleCast(heighthit.point + (Vector3.up * 0.1f), heighthit.point + (Vector3.up * controller.height), controller.radius, transform.forward, 0.3f, GroundLayer))
                        {
                           AvatarTarget at = AvatarTarget.RightHand;
                           //3rd, place the HelperPoint.   
                              if (AnimationType == 1)
                              {
                                 DynamicIKTransform.position = transform.position - (wallhit.normal * 0.2f) + (Vector3.up * EdgeHeight * 2.0f);
                                 at = AvatarTarget.RightHand;
                              }else{
                                 DynamicIKTransform.position = transform.position + (wallhit.normal * 0.5f) +  (Vector3.up * EdgeHeight);
                              }
                              Vector3 dir = (-wallhit.normal);
                              MatchAnim (DynamicIKTransform, AnimationType, dir, at );
                              //print ("It is climbing" + Time.time);
                        }else{
                           print ("There is not space to climb: " + Time.time + ", : " + wallhit.transform.name);
                        }
                     }else{
                        print ("It's too high to climb: " + Time.time + ", : " + wallhit.transform.name);
                     }
                  }
               }//End of tag.climb
            }
         }
                break;
      }
      case State.Special://-------------------------------------------------------------------------------------------------------------//
      {
         //Rotation
         rotDirection = transform.InverseTransformDirection(rotTarget); //Rotation from the target.
         // Apply rotation
         float GoalRotation = Mathf.Atan2(rotDirection.x, rotDirection.z);
         transform.Rotate(0, GoalRotation * NormalRotationSpeed * Time.deltaTime, 0);
         break;
      }
      default:
      {
         break;
      }
   }
   UpdateAnimator();      
    }
    float CheckGravity ()
    {
        float result = 0.0f;
        //Ground Sensor
        if (!AllowGravity)
        {
            GravState = GravityState.Deactivated;
            anim.SetBool("Falling", false);
            anim.SetBool("Landing", false);
            return result;
        }
        switch (GravState)
        {
            case GravityState.Land:
                //Update Distance To Floor
                //if (Physics.SphereCast(transform.position + Vector3.up* (controller.stepOffset + 0.1f), 0.1f , -Vector3.up, out hit, Mathf.Infinity, GroundLayer))
                if (Physics.Raycast(transform.position + Vector3.up * controller.stepOffset, -Vector3.up, out hit, Mathf.Infinity, GroundLayer))
                {
                    DistanceToFloor = hit.distance - controller.stepOffset;
                }else{
                    DistanceToFloor = 100.0f; //Doesn´t detect anything, let´s suposse that there are nothing, and leave the rest of the code manage if it has to fall or not.
                }
               
                if (DistanceToFloor > controller.stepOffset) //too much space below, is not grounded anymore.
                {//But, because this situation can happens in many circunstancies, we are not activating state changes yet. We are calculating the time it will be on non-ground contact, and if it´s a meaningful value, then consider it.
                    if (IsGrounded)
                    {
                        TimeStartedToFall = Time.time;
                        IsGrounded = false;
                    }else{
                        if (Time.time - TimeStartedToFall > 0.15f)//If it's not Grounded and has been falling for more than 0.15 secs, start the falling state.
                        {
                            anim.SetBool("Falling", true);
                            anim.SetBool("Landing", false);
                            GravState = GravityState.Falling;
                        }
                    }
                }else{//DistanceToFloor is short, so it's on the floor again (before the 0.15 time), return IsGrounded and remain in this Land state.
                    IsGrounded = true;
                }
                break;
            case GravityState.Falling:
                result = gravity * Time.deltaTime / 2;
                //Update Distance To Floor
                //if (Physics.SphereCast(transform.position + Vector3.up* (controller.stepOffset + 0.1f), 0.1f , -Vector3.up, out hit, Mathf.Infinity, GroundLayer))
                if (Physics.Raycast(transform.position + Vector3.up * controller.stepOffset, -Vector3.up, out hit, Mathf.Infinity, GroundLayer))
                {
                    DistanceToFloor = hit.distance - controller.stepOffset;
                }else{
                    DistanceToFloor = 100.0f; //Doesn´t detect anything, let´s suposse that there are nothing, and leave the rest of the code manage if it has to fall or not.
                }
                if (DistanceToFloor < controller.stepOffset)//If now is grounded again...
                {
                    //But, we must consider if it's a flat ground or not, because depending of that, there is a landing or more falling yet.
                    if (Vector3.Dot(transform.up, hit.normal) >= 0.95f) //Is flat floor.
                    {
                        //Keeps falling normally till the distance to floor were lower than 0.01f to remain sticked on the ground.
                        if (DistanceToFloor < 0.01f)
                        {
                            anim.SetBool("Falling", false);
                            anim.SetBool("Landing", true);
                            GravState = GravityState.Land;
                        }
                    }else{
                        //Is not flat. So land inmediately, but doing the ground fix teleportation to stick the feets on the ground.
                        anim.SetBool("Falling", false);
                        anim.SetBool("Landing", true);
                        GravState = GravityState.Land;
                        transform.position = new Vector3(transform.position.x, transform.position.y - DistanceToFloor, transform.position.z);
                    }
                }else{ //there are not ground, so keep falling. (Check if has been falling for too long to change the Free fall state).
                    if (Time.time - TimeStartedToFall > 0.3f) //Has been falling for too much time
                    {
                        GravState = GravityState.FreeFalling;
                    }
                }
                break;
            case GravityState.FreeFalling:
                result = gravity * Time.deltaTime;
                //Update Distance To Floor
                //if (Physics.SphereCast(transform.position + Vector3.up* (controller.stepOffset + 0.1f), 0.1f , -Vector3.up, out hit, Mathf.Infinity, GroundLayer))
                if (Physics.Raycast(transform.position + Vector3.up * controller.stepOffset, -Vector3.up, out hit, Mathf.Infinity, GroundLayer))
                {
                    DistanceToFloor = hit.distance - controller.stepOffset;
                }else{
                    DistanceToFloor = 100.0f; //Doesn´t detect anything, let´s suposse that there are nothing, and leave the rest of the code manage if it has to fall or not.
                }
                //Something similar to the Falling state, but with different animations.
                if (DistanceToFloor < controller.stepOffset)//If now is grounded again...
                {
                    //But, we must consider if it's a flat ground or not, because depending of that, there is a landing or more falling yet.
                    if (Vector3.Dot(transform.up, hit.normal) >= 0.95f) //Is flat floor.
                    {
                        //Keeps falling normally till the distance to floor were lower than 0.01f to remain s
#3
Un año nuevo, un curso nuevo, la profesora hablando del portfolio, nos ha recordado como el trabajo de fin de curso debemos enfocarlo a lo que queremos hacer en el futuro pues según ella, ese proyecto será el que perfile nuestra carrera en la industria...  Dejando dramatismos a parte. Me preguntaba, como programador, ¿Qué alternativas hay?. Muchas veces en los eventos, nos dice los veteranos, "Tú céntrate, hazte profesional de un área" y tal. (Algo muy opuesto a los indies que por narices deben aprender un poco de todo para sacar el proyecto adelante), estará conectado las dos cosas?


Bueno, echándole algo de imaginación, supongo que puede haber:
 


  •    Programador gráfico. (Que escriba shaders, ya sean para materiales o de post procesamiento). (Me gusta, pero ¿tanto como para dedicarme a ello 40 horas semanales?)


  •    Programador de iluminación. (Admito que les tengo mucho más respeto ahora XD )


  •    Programador de menús (Alguien tendrá que hacerlos...)


  •    Programador de IAs  (¿Podría estar bien?)


  •    Programador de físicas (Un compañero tiró por aquí, aunque a mi no me hace ni fu ni fa... O_ò )


  •    Programador de mecánicas? (El movimiento del personaje, los ataques, disparadores? )


  •    Programador de redes (Para las funcionalidades online y actualizaciones)


  •    Programador de sistemas? (Alguien que lleve un control más general de la estructura del proyecto, el ejecutable y que también se encargue de adaptarlo a las distintas plataformas de juego?)


  •    Programador de herramientas. (Me parece una lata programar herramientas, pero la verdad es que después es muy útil poder usar editores, conversores y tal...)


No sé, ¿Me he dejado alguno?
 
Yo creo que parte de lo que me gusta del desarrollo de videojuegos, es la creación de escenarios, ¿Es eso competencia de los programadores? (El año pasado con el grupo de la universidad, sí, sin duda, lo mismo en las game jam, pero no sé si en las empresas formales esa tarea está más destinadas a los artistas (creo tendría sentido así).
 
¿Hay alguien que pueda compartir alguna experiencia que de perspectiva a este asunto? 
#4
Saludos.
 


Abro tema porque quiero preguntar por indicaciones e ideas para mejorar el aspecto de un personaje.
 


  •    El modelo fue hecho con Adobe fuse, con algunos recortes y cambios en Maya LT, (aún tengo que quitarle los dientes y rehacerle unos sin tantos vértices) pero generalmente estoy satisfecho con la topología de la malla. (bueno, quizás le ensanche un poco el cuello)


  •    Las proporciones no son realistas, (estoy usando la de las 8 cabezas y media) pero a estas alturas, estoy también contento con ellas


Lo que no termino de conseguir creo que es la textura, (y bueno, mi odisea con los peinados, pero esa es otra batalla a parte). 
 

 
Estoy trabajándolo y creo que no se ve tan mal, pero en muchísimos momentos también se le ve como con cara de palo.   A veces creo que es el FOV de la cámara, pero otras tantas me parece que no consigo darle el toque a la textura para que se vea bien.


No busco fotorealismo, simplemente creo que la cara de este personaje, no es memorable, le falta algo. Lo veo, soso, simple, amargado, (vale que también le tengo la cara muy vista O_ò)  pero aunque le ponga shaders de post procesamiento para el bloom y los colores, todavía no se ve pulido.
 
No sé, estaba pensando algunas cosas, (cambiar color de las sombras? ¿borrar el marcado de los pómulos o reforzar los pómulos? ¿quitar las cejas y ponerlas con transparencia en una capa encima?...)
 
 
 
¿Alguien tiene alguna sugerencia o idea de qué o como podría mejorar la cabeza?
 
 
#5
Saludos, tengo este código para cargar y guardar. Funciona.
 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
public class Serializer_Level : MonoBehaviour
{
    public GameObject player;
    void Start ()
    {
        Load ();
    }
    void Update ()
    {
        if (Input.GetKeyDown (KeyCode.S))
        {
            Save ();
        }
    }
    public void Save ()
    {
        BinaryFormatter bf = new BinaryFormatter();
        FileStream file = File.Create(Application.persistentDataPath + "/playerInfo.dat");
        SavedData data = new SavedData();
        data.x = player.transform.position.x;
        data.y = player.transform.position.y;
        data.z = player.transform.position.z;
        bf.Serialize (file, data);
        file.Close();
    }
    public void Load ()
    {
        if (File.Exists(Application.persistentDataPath + "/playerInfo.dat"))
        {
            BinaryFormatter bf = new BinaryFormatter();
            FileStream file = File.Open (Application.persistentDataPath + "/playerInfo.dat", FileMode.Open);
            SavedData data = (SavedData)bf.Deserialize (file);
            file.Close();
            player.transform.position = new Vector3 (data.x, data.y, data.z);
        }
    }
}
[Serializable]
class SavedData
{
    public float x;
public float y;
public float z;
}

 
 
 
La cosa es que necesito ir más allá, yo lo que estoy haciendo es como una pequeña zona de decoración, hay un área, y el jugador puede poner, quitar, mover, rotar, los objetos en ella.
 

 
 
 
 
 
Ahora lo que necesito es salvar la posición, rotación y número de identificación para una serie grande de objetos (No sólo la posición del jugador como tengo en el código). ¿Alguien sabe como hacer esto?
 


Estoy pensando en estructuras y rayándome un poco. ¿Quizás algo como esto?:
 

 
Una lista vector con las zonas de construcción (los cuadrados) estas son fijas en el nivel, así que no tengo que salvar nada de ellas salvo una lista vector con los objetos que contienen. Después cada objeto de esa "sub-lista" podría tener la información del ID, la posición y la rotación.
 
Lo que no sé es como meter esa estructura de lista dinámica (vector, deque, list o como sea), en el archivo binario que tengo que crear. (He leído una sugerencia de crear varios archivos externos por cada GameObject, pero dado que es posible que haya muchos objetos construidos en el nivel, creo que sería impensable tener un archivo externo por cada GameObject. 
 
 
 
¿Alguna idea? O_ò
 
 
 
/---/EDIT
Asunto solucionado en post 2
#6
Presentaciones / Antonio, un casual regresando
Abril 15, 2019, 04:37:32 PM
Buenas tardes.
 
Hace unos años visitaba estos foros con el nombre usuario de Adngel, pero no he podido recuperar la clave de la cuenta ni recuerdo a qué correo estaba linkeada. O_ò (Años más tarde sigo con el mismo lío de correos y teléfonos). Anyway.
 
 
 
Generalmente, sobre mi pues:
 
Tengo 32 años, emigrado a Reino Unido, he trabajado en muchas áreas ( Tele-asistencia, Magisterio, Retail, Correos, Tester de localización, Seguridad y actualmente Diseñador Web)  pero siempre he tenido el diseño de los videojuegos como un hobby para las tardes, por cuestiones de la vida decidí volver a la universidad para hacer un curso de programación y lo que antes era mi hobby ahora lo hago con unas expectativas mucho más serias.
 
Me vuelvo a unir al foro con la intención de poder preguntar dudas o más bien, poder coger otros puntos de vista en cuanto a diseños de métodos. En clase estamos en 2º año, aprendiendo shaders, Directx y Open GL, pero Unity y Unreal es para el año que viene, así que no puedo hablar de Unity con mis compis de allí, y los del año siguiente prefieren Unreal (A la hora de usar Unreal en las games Jam me siento como un minusválido :(  ).
 


En fin, no sé si seré un usuario muy activo, o si seré un usuario visto y no visto, pero bueno, si no tengo cuenta, de seguro que no puedo hacer mucho así que dejo este 1º paso de registro por finalizado.
 
 
 
 
#7
Pues eso. ¿Cómo se programaría la IA de algún simulador de personas? No es un proyecto serio, más bien un prototipo que estoy mirando por curiosidad. Jugando al Fallout 4, he visto su sistema de asentamientos que a pesar de ser una pequeña parte del juego, pues lo cierto es que me ha gustado bastante. Fallout 4 es un juego sand box, en él, el jugador puede ir conquistando asentamientos por el mapa y colocar transmisores de radio, entonces a medida que pasa el tiempo de juego, van llegando colonos que viven en el asentamiento (no más de 21).
 
Estos colonos se les asigna una tarea (recolectar comida, defensa, comercio, desguace, y creo que ya está XD) y entonces, a lo largo del día, pues van teniendo sus vidas, duermen, se levantan por la mañana, se ponen a trabajar desde las 9 hasta las ¿20? tras lo cual se ponen a pasear por ahí (o se van a la cantina) hasta que llega la hora de dormir. En el transcurso, puede ocurrir que el jugador hable con ellos, lo que para su actividad un momento para decir la bobada de turno. También puede ocurrir que el asentamiento sea atacado, en ese momento todos dejan su actividad para luchar contra los invasores. A ver si puedo imitar algo así, creo que sería útil para varios tipos de juegos.
 


El asunto de irse a dormir y a trabajar, es fácil, he hecho un código que gestione la hora global, y entonces cada colono, mira dicha hora para decidir su estado e irse a la cama o al puesto de trabajo. Pero me gustaría ir un poco más allá, ¿cómo podría imitar cierto libre albedrío? especialmente para sus horas libres, me viene a la cabeza los sims, que tienen una serie de variables (energía, comodidad, hambre, sociedad, higiene, etc...) y van realizando ciertas acciones dependiendo un poco de lo que necesiten y los objetos que tengan a su alcance, (que por cierto, ¿qué sería mejor? guardarlos en listas a medida que se incorporen al asentamiento, o decirle al colono que haga un casteo para ver los objetos cercanos él mismo?) En fin, lo de las barras de necesidades tipo sims podría ser una manera, pero tengo curiosidad por el tema, ¿se os ocurren otros métodos? O.ò
 
 
 
 
 
 
#8
Yo me estoy quemando otra vez la cabeza Sigo con mi fangame, y me llegó la hora de enfrentarme a las cinemáticas, (cutscenes, eventos, y tal), un par de ellas para el inicio y el final, no muy complicadas ni muy largas. 
- Sé que puedo coger el 3ds max y hacerlas ahí.
- También está la opción de hacerlas en el propio Unity, (le estoy cogiendo truco y todo gracias al sistema de hijos que me permite posar varios modelos a la vez, y lo cierto es que la animación de cámara me es muchísmo más cómodo hacerlo ahí)..Bueno, como último recurso pues están ahí esas dos opciones para salir del paso, pero la verdad es que, en mis objetivos está:Requisitos:
  • Poder hacer algo más flexible, que pueda combinar con animaciones ya hechas (tener que animar los pasos del personaje manualmente todo el tiempo sería un tostón... @_@) así, en vez de hacer la super animación de 1 minuto estilo Tomb Raiders antiguos, pues voy haciendo animaciones cortas y las voy activando en su momento por código.
  • Y también está el de poder reutilizar esas animaciones con distintos modelos. En este proyecto, tengo la intención de cambiar el modelo del personaje con distintos trajes como recompensa, de momento va funcionando en la partida pero ahora, pues tengo que ver como adapto el sistema de las cinemáticas para que eso siga funcionando.
  • Uso de animaciones faciales.
  • No son pre-renderizadas ni quiero eso, si no en tiempo real con el motor del juego.

Así que bueno tengo un lío con todo esto que no me aclaro.

A ver, creo que algo así necesitaría:
 Cámara- Un objeto vacío (invisible y sin colisión) para ponerle la cámara de cinemáticas, y el animator, y así, usar el sistema gráfico del mecanim para crear los distintos estados con las distintas animaciones de cámara.- Un código que maneje las cámaras: Esto podría ser un array de tipo personalizado, cada nodo, tendría una variable float, que sería el tiempo en el que se cambiará al siguiente nodo, y en el proceso, le diría a mecanim de la cámara que pase al siguiente estado de animación. En este código también podría hacer cosas como modificar los efectos de las cámaras, el FoV, y cosas de ese estilo.Animatings- Cada objeto de la escena, tendrán también su propia animación en mecanim, con una variable de tiempo, algún código se encargará de actualizarla como es debido, usando esta variable, los estados de la animación se sucederán en el momento necesario. Ya dentro de las animaciones propia, les pondría sus eventos para que activen los sonidos que necesiten. Ya tengo un código para los sonidos que puedo reutilizar ahí. También podría crear algunas ordenes sencillas de esas de apuntar a cierto objetivo, o de recrear un pequeño temblor para simular el efecto de una cámara manual.Personajes- Necesito el código para inutilizar el comportamiento del jugador y poder añadir su nuevo del animating. ¿alguna idea por aquí O.ò?- Estos personajes también usan mecanim, así que pueden intercambiar las animaciones corporales, sus gráficos de mecanim, tendrán 3 capas:
  1. La general, que es la que siempre maneja la posición del personaje en el espacio.
  2. La del tronco superior (si está andando, y quiero que esté hablando o moviendo los brazos, con esto podría ahorrarme los pasos, y tal).
  3. La de animaciones faciales. (Que es la que no sé como transferir de un modelo a otro, ¿alguna idea por aquí O.ò ? ).
- Su paso entre animaciones, creo que podría hacerlo también con la variable de tiempo, y así, cada capa podría actualizarse de manera interna. Tendría que distinguir entre las animaciones que son cíclicas durante un tiempo (correr, caminar) y las que son únicas (encender comunicador, apoyarse en una silla), estoy podría hacerlo haciendo que las animaciones  cíclicas dependan del trigger, y las animaciones únicas, al terminar, pasarán a la siguiente animación o a un estado vacío en caso de que no haya, y este será el que espere a la llamada del siguiente disparador.- Entonces en realidad el código tan sólo tendría que encargarse de actualizar el tiempo en el mecanim, y asegurarse de cortarlo todo cuando acabe. Nop, no puedo, necesito añadir más cosas a parte de la animación, la rotación, o el punto de destino, podría hacerlo como un PNJ con IA, para que se pueda mover por el escenario, en algunos momentos, algo parecido a las escenas de los RPGs antiguos, que los pnjs se van a una posición donde realizan alguna animación, puede que a veces tenga que moverlos mediante el root motion, otras veces puede que tenga que trasladarlos a la fuerza, pero creo que valdría la pena dejar esas funciones implementadas.Efectos- Aquí imagino que iré de nuevo a algo como el código del array que usé en las cámaras, ya que el caso de los subtítulos, tal y como lo tengo, he de acceder a distintos archivos dependiendo del idioma, es algo que tendría que mirar por código, no creo que pueda automatizarlo con una animación de datos.- El asunto de la música, aun tengo que programar todo eso @_@, pero imagino que necesitaré un par de listas, una para la música y otro para los efectos de sonido que no vayan a ir en las animaciones si es que pongo alguno. O_ò, no creo que tenga voces.  Bueno, visto ahora, no parece tan imposible, aunque sigo con la incógnita del manejo de animaciones faciales entre distintos modelos. Mecanim, por lo que sé, sólo guarda la animación de los ojos y la mandíbula. Necesitaría los labios, las cejas y los párpados. 

Se me ocurre, que quizás, podría crear un objeto vacío, que esté a la altura del cuello y con su animator, como hijo de este objeto vacío pues podría crear más hijos invisibles (para cada uno de esos huesos significativos), a la hora de hacer la animación facial, estos huesos vacíos, son los que se moverían, y son los que guardarían la animación, así que esta cara ficticia, sería un prefab, algo como una máscara. Cuando el personaje, entre en modo cinemática, se instanciaría esa máscara, y se enlazarían los huesos del personaje, (los que existan) con los huesos de la máscara. para esto podría ayudarme algún pequeño código en el personaje que tenga los huesos ya guardados manualmente, habría que configurarlo para cada modelo, pero sería información que se podría guardar en su prefab así que creo que podría ser factible. Vale, creo que de momento con esto tengo algunas pasos que seguir, (imagino que habrá que empezarlo en algún momento) pero aún así si alguien tiene ideas u otros enfoques para el tema que puedan facilitar el asunto, serían bienvenidas, 
#9
General (Antiguo) / Odio Blender
Noviembre 20, 2015, 03:50:00 AM
Alerta rabieta, Alerta rabieta. Pero es que ni mi familia ni mis amigos entienden de esto.

Ahora mismo estoy en uno de esos puntos de frustración en los que disfruto más planchando la ropa que trabajando en mi juego. Llevo años trabajando con una copia pirata de 3ds max, sé modelar, editar geometría, modificar texturas, materiales y malla UV, sé animar y he perdido la cuenta de cuantos riggings faciales y completos he hecho. Pero bueno, todo para ocio personal y el fandom, Ahora que ando pensando en algo más comercial, pues no quiero usar licencias piratas. Así que, como no ando con unas 4000 libras sueltas, pues nada, BLENDER. Todas las pistas apuntan allí, todo los consejos indican esa dirección y hay una comunidad enorme que se las ha apañado para manejar el programa con soltura, pero yo no paro de encontrarme problema tras problema, y sí, este mundillo es así, pero mecachis en la mar, frustración es la palabra. 

Y es que el puñetero fantasmito podría haberlo tenido listo en 20 minutos, tras lo cual podría haberlo ya importado y creado su colisión, probar mis códigos de IA en él, pero NO, porque llevo 6 horas viendo como el "Rigidfy" este no me hace lo mismo que a los tios que graban tutoriales en youtube. (a parte de la guia que hay en el manual de Unity, he visto 3 vídeos de youtube, y les funciona, le dan a generar el rig y se crea bien, a la altura del personaje, con los brazos en el mismo sitio que los huesos de referencia, y después lo enlazan y el personaje se deforma (algunas veces mejor que otras) pero algo es algo. A mi no pasa eso.

Yo cuando genero el rig, a veces me crea uno que es más pequeño que el fantasma, otras veces me lo crea pero sin heredar la pose del esqueleto, y además, no me crea todos los huesos, ¿es porque el fantasma no tiene piernas?. Y bueno, ya cuando le aplico el rig a la malla, lo más normal es que el 75% del mesh desaparezca, no sé a donde va, he mirado los layers y he intentado buscar en las escalas (a ver si es que el rig minimiza las caras o las agranda tanto que se sale de la pantalla ¿?) Y lo que queda, (parte del pecho y el brazo izquierdo) ni siquiera se comporta como debería al rotar los huesos. :S  En fin, me iré a la cama y el domingo sábado por la tarde después del trabajo pues supongo que le daré otro intento.

¿Sabéis de alguna otra alternativa viable para un juego indie? programas que puedan modelar 3d, rigear, animar y modificar las mallas UV. (Los materiales y renderizado me da igual porque como sabéis, después tengo que rehacer los materiales en Unity para la optimización de texturas, shaders específicos y tal).
- Cinema 4d por lo que he visto anda por los 450 libras la versión más baja que he visto, no sé que diferencias tendrá. 
- 3d Canvas es gratis, leí que se pueden hacer animaciones con él, pero ¿no acepta el formato FBX?
- He visto que Autodesk le ha dado por meterse en la competencia de los engines para juegos indies con Stingray, sí si maravilloso, me importa bien poco el motor, la cosa que si me ha llamado la atención es que por ello, han puesto un programa de modelado low cost, "Maya Lite" a precio de 30$ mensuales, no he probado la trial todavía, pero será por la hora que hasta me lo estoy planteando y todo @_@
- En Deviantart tengo un compañero aficionado al moding del Miku Miku Dance y sé que tienen otra herramienta con la que rigean personajes,  ¿sabéis si sería legal usarla para proyectos comerciales? 
- Otro programa que anda por ahí, se llama K3d, dicen que permite modelado y animación, ¿alguien lo ha probado?.
- He visto otros programas de modelados, algunos más toscos que otros, pero empiezan a faltarle acciones que necesito, (las animaciones podría hacerlas en Unity aunque no me parece el ideal para ello, pero rigeo no puedo hacerlo en Unity  )


Y sobre el camino de Blender, ¿hay luz al final del tunel este lleno de piedras? en mi interior sé que es cuestión de paciencia y de no ser impaciente, pero aains. No estoy cómodo con él, por eso "algo" algo tengo que hacer para cambiar esto. Otro programa, mi metodología o no sé.
 
#10
Hola, finalmente he dejado mi amado 3ds max piratoso a un lado y estoy tratando de usar el Blender, estoy atascado con una actividad que no consigo hacerla aquí, se trata de adaptar la malla UV para que se tome una forma predefinida (que es la que tengo en la textura ya hecha, en fin no es más que acoplar todo el cuello del jersey a un simple rectángulo que es donde está el dibujo de las arrugas y donde más tarde se aplicará también el UVMap).

La cosa es que le creo los bordes y selecciono las caras del modelo 3d para crear el Unwrap map, pero este pues, se crea un poco desajustado como se ve en la imagen.

Estoy tratando de buscar tutoriales, y todo lo que encuentro trata de lo mismo, de como hacer el UV map primero y después lo abre en el programa de dibujo y crea la textura para encajarla en ese UVmap, (y de hecho, ni siquiera lo hacen con mucho control, es un poco como lo que salga salió... )  pero no encuentro vídeos que traten mi caso, es decir, que tengan una textura y adapten el UVmap a ella. En los problemas que me encuentro están:
Al intentar mover los vértices, resulta que sin querer se me mueven los vértices del torso (a pesar de haberlos separado con el Mark, pero nada, al seleccionar el vértice del cuello, también se selecciona el del torso) ¿cómo puedo hacer que esto no pase? para poder editar libremente el cuello sin más problema.

También, en 3ds max hay una opción de selección, el Freeform Mode, que selecciono un conjunto de vértices, y puedo escalarlos todos en referencia a uno de las esquinas, ¿Hay algo así en Blender?, sé que con la S puedo escalar, pero todo lo hace desde el centro que es un poco más latoso para ajustarlo. Esta es la tarea que estoy intentando hacer, quiero ajustar ese cuello a ese rectángulo superior derecho de la textura. 
#11
Money, money, money...  (Y aún así, sé que seguirán surgiendo problemas, pero bueno, así es la vida).

Quienes estáis en grupo de juegos indies, ¿cómo lleváis esto? 
#12
Buenos días.

Estoy intentando hacer un puzzle, se trata de un panel, con varios nodos, el jugador puede unir los distintos nodos con líneas para simular así un dibujo. El objetivo es que por el escenario, encontrará el dibujo, y tiene que recrearlo en este panel.using UnityEngine;
using System.Collections;


public class Puzzle_DrawerJoint_Manager : MonoBehaviour
{

GameObject Origin;

public GameObject Selector;
public Material Mat;
GameObject Sel;


public void ReceiveInput (GameObject input)
{
   if (Origin == null)
   {//Place the input in the origin
      Origin = input;
      Sel = Instantiate (Selector ,Origin.transform.position, Quaternion.identity) as GameObject;
      Sel.transform.localScale =
Vector3.one * 0.2f;
      Sel.transform.LookAt (Sel.transform.position + Vector3.up);
      Sel.transform.parent = Origin.transform;
      Sel.SendMessage ("Appear");
   }else{
      if (Origin == input)
      {//Clear the origin
         Sel.SendMessage ("Disappear");
         Origin = null;
      }else{//Place the input in the destiny and draw a line.
         bool Validated = true;
         Puzzle_DrawerJoint_Piece CodeOrigin = Origin.GetComponent <Puzzle_DrawerJoint_Piece>();
         Puzzle_DrawerJoint_Piece CodeDestiny = input.GetComponent <Puzzle_DrawerJoint_Piece>();

         foreach (GameObject cg in CodeOrigin.LinesDone)
         {
            if (input == cg)
 Validated = false;
         }

         foreach (GameObject cg in CodeDestiny.LinesDone)
         {
            if (Origin == cg)
 Validated = false;
         }

         if (Validated)//For Check if the line has not been already drawn.
         {//Draw the line
            CodeOrigin.LinesDone.Add (input);
            CodeDestiny.LinesDone.Add (Origin);

            GameObject go = new GameObject();
            go.transform.parent = Origin.transform;
            LineRenderer Ln = go.AddComponent<LineRenderer>() as LineRenderer;
            Ln.SetPosition (0, Origin.transform.position );
            Ln.SetPosition (1, input.transform.position );
            Ln.SetWidth (0.1f, 0.1f);
            Ln.material = Mat;
            Origin = null;
            Sel.SendMessage ("Disappear");
         }
      }
   }
}
} Pieces
using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class Puzzle_DrawerJoint_Piece : MonoBehaviour
{
Puzzle_DrawerJoint_Manager GraphicManager;
Puzzle_SeqManager LogicManager; //De momento no hace nada
public int MyID; //De momento no hace nada

public List <GameObject> LinesDone = new List<GameObject> ();

void Start ()
{
   GraphicManager = GetComponentInParent <Puzzle_DrawerJoint_Manager>();
   //LogicManager = GetComponentInParent <Puzzle_SeqManager>(); //De momento no hace nada
}

void OnMouseDown ()
{
   GraphicManager.ReceiveInput (gameObject);
   //LogicManager.ReceiveInput (MyID); //De momento no hace nada
}
}

Funcionamiento:
Cuando el jugador pulsa algún nodo, este envía una señal al manager y pueden pasar varias cosas:
- si no había ningún nodo seleccionado, se selecciona el nodo que ha pulsado ahora.
- si ya había algún nodo seleccionado, mira a ver si ha vuelto a pulsar el mismo nodo, en tal caso, el nodo se desselecciona.
- si ya había algún nodo seleecionado, y no ha pulsado 2 veces sobre el mismo nodo, comprueba si la línea ya existe. Si existe, pues no hace nada, si no existe, la crea.
(Cada nodo tiene una lista de nodos ya conectados para evitar crear múltiples líneas en la misma conexión, cada vez que se crea una). Ahora, no se me ocurre cómo hacer la comprobación. ¿Alguna idea? O.ò 

(El LogicManager es otro código que tengo que crea una clave, y verifica si se cumple, pero en este caso creo que no podré reutilizarlo porque ese código busca la clave lineal, (primero el primer valor, después el segundo, y tal, pero aquí en este puzzle, el jugador puede que empiece a dibujar por cualquier parte, así que seguramente tenga que crear un nuevo código para este puzzle en particular).


 
#13
Buenas noches. 

Con el Unity 5, todo lo que tenía hecho en RAIN se me fue al traste, T_T pero bueno, no pasa nada, he estado re-haciendo la IA de los enemigos con el nav mesh de Unity 5, la mayoría de las funciones ya están implementadas, y estoy intentando pues resolver problemas, pero este no consigo dar con la tecla. @_@

Resulta que los enemigos, cuando van persiguiendo al jugador, se atascan en algunos puntos, del escenario, parece que principalmente en los bordes, que no caen. El escenario, tiene su Navmesh preparado con una serie de Off-Mesh links generados automáticamente para que un enemigo salte a una zona inferior para seguir con la ***cución o el paseo. Suele funcionar, pero en este ejemplo, con 10 enemigos en tropa siguiéndome, no todos pasan la prueba, con frecuencia, algunos se van quedando por el camino. 



He revisado el código, pero tampoco no veo el error, vemos, el enemigo tiene una serie de estados, y algunos de ellos ordena al enemigo que se mueva, eso lo hace llamando a esta función:
 pic 1: https://yadi.sk/i/8vJfVHmKigUXZ">https://yadi.sk/i/8vJfVHmKigUXZ
pic 2: https://yadi.sk/i/wrIBwQEkigUYC">https://yadi.sk/i/wrIBwQEkigUYC
pic 3: https://yadi.sk/i/6MPpI_dIigUYa">https://yadi.sk/i/6MPpI_dIigUYa 
   void MoveTo(Vector3 destination, bool aim, Vector3 lookPos)
{
   agent.transform.position = transform.position; //Le dice al NavMeshAgent cual es su posición actual.
       agent.destination = destination; //Le dice cual es el destino, (que es una posición que entra en la función).

   Vector3 velocity = agent.desiredVelocity * 0.5f; //con el destino, el NavMeshAgent crea una velocidad y dirección, desiredVelocity.
                                                           //la reduzco un poco que sale muy larga.
   charMove.Move (velocity,aim,lookPos);
 //Y la mando a mi character controller que es quien mueve el personaje.
}
Del character controller no tengo dudas, exactamente ese mismo código es el que uso para mover a mi personaje, con la diferencia de que en el personaje, es el script de "inputs" quien decide la dirección (en base a las teclas que esté pulsando y la posición de la cámara), como esto es un enemigo que se mueve sólo, esa dirección en teoría la coge del NavMeshAgent.

El character controller es básicamente el 3rd player controller del estandar de Unity, sólo que con modificaciones por doquier @_@, pero dudo que esté el error por ahí, el personaje sube y baja perfectamente, Poniendo un print (gameObject + "  " + velocity); puedo ver la velocidad que el navMesh agent le da a esos enemigos atascados, y parece acertada. (no es 0, es 0,5 en una dirección, otro con un 1.5f en otra, lo que explica que esté corriendo contra el borde), pero el caso es que de ahí, no se mueven.

Si en vez de NavMesh, le digo al enemigo que siga al jugador a lo básico (Vector3 velocity = EnemyToAttack.transform.postion - transform.position; ) todos van como posesos a por el jugador en línea recta, escalando y cayéndose como es debido, de modo que la cosa tiene que ser algo del Nav Mesh. @_@

He probado aumentar la velocidad angular, reducir el radio, aumentar el radio, también he probado en el Nav Mesh de la zona, modificar el radio de ahí, para que genere más o menos Off-Mesh links (esos nodos que salen en el borde para indicar al enemigo que puede contar esa bajada para hacer su camino). pero en fin, se mis pequeños se quedan perdidos por ahí.  

¿Alguien sabe cómo solucionar esto? algunos atascos en algunos pequeños escalones, es algo fácil de evitar, pero teniendo al enemigo que no puede bajar ningún desnivel, pues es un handicap. :S 
 
#14
Buenas noches.

Resulta que estaba yo tan feliz añadiendo funciones mi paranoya de proyecto, y estaba aplicando el desvío de las balas, el juego es un Third Person Shooter, cuando el jugador mueve la cámara, se desplaza, o dispara, la cruceta se va abriendo, y se va cerrando también cuando el jugador mantiene la cámara apuntando al objetivo, la velocidad a la que se cierra, también se ve afectada por los atributos del arma que lleve, En fin, hasta ahí va todo bien.

Ahora la cosa es que al rayo de dirección, le aplico el "desvío", pero malamente, porque el desvío no queda relativo a la dirección del disparo, si no relativo al escenario. (Es decir, dependiendo de a donde dispare, el desvío a veces hace que las balas vayan hacia atrás... :S ). ¿Alguien sabe como funciona el traspaso ese de plano XY a puntos del mundo?.  El script donde esta lleva cerca de las 600 líneas, pero la parte del desvío en cuestión es esta:
void ShootRay ()
{

        //Buscando el punto de origen donde se instancia el disparo. Será desde el centro de la pantalla hacia el frente...
   float x = Screen.width / 2;
   float y = Screen.height / 2;

   Ray ray = Camera.main.ScreenPointToRay (new Vector3 (x, y, 0));
   RaycastHit hit;

        //Esto es que al disparar, también creo un pequeño LineRenderer para dejar un poco el efecto de la bala.
   GameObject go = Instantiate (bulletPrefab, transform.position, Quaternion.identity) as GameObject;
   LineRenderer line = go.GetComponent <LineRenderer> ();

        //Estos 2 valores, los uso mayormente para el lineRenderer.
   Vector3 startPos = weaponManager.ActiveWeapon.bulletSpawn.TransformPoint (Vector3.zero);
   Vector3 endPos = Vector3.zero;

        //De acuerdo, aquí lanzo el rayo de disparo. (desde el centro de la pantalla, hacia el infinito).
   if (Physics.Raycast (ray, out hit, Mathf.Infinity, myLayerMask))
   {

      //Bien, aqui empieza el asunto del desvio. El rayo que lancé, ha colisionado con algún objeto y ha devuelto el hit.point
            //hit.point es un Vector3 con la posición del punto donde ha dado y a donde se va a dirigir el disparo de mi arma,
            //disparando directamente a ese punto, pues sale el disparo bueno.
            //lo que quiero es añadir un poco la desviación (dependiendo del valor de ExtendingCross.spreadValue, que oscila entre 15 y 45
            //pero funciona bien, es fiable). Por ello...

            //Creo los offsets para el desvio.
      float DesvioX = 0;
      float DesvioY = 0;

            //Si el defaultSpread es >= 16. se aplica el desvio (en caso contrario, la cruceta está tan cerrada que no se nota diferencia
            //Por eso, si defaultSpread es <16, los Desvios serán 0 directamente.
      if (ExtendingCross.spreadValue >= ExtendingCross.defaultSpread+1)
      {
         float Rn = Random.Range (0,100); //Empiezo con el DesvioX, esto es para elegir si se desviará a la izq o a la derecha.
         if (Rn < 50)
         {
            DesvioX = -1;
         }else{
            DesvioX = 1;
         }

                //Aqui en la siguiente línea, el Desvio (1 o -1, se multiplica por spreadValue que tendrá un valor
                //entre 15 y 45 menos defaultSpread que tiene el valor 15.
                //De modo que al final queda DesviotX * (spreadValue - 15);
                //Si spreadValue es 15, 15-15= 0, no hay desvio,
                //Si SpreadValue es 20, 20-15= 5, y así va de momento
         DesvioX = DesvioX * (ExtendingCross.spreadValue - ExtendingCross.defaultSpread );

         Rn = Random.Range (0,100);//Esto es lo mismo pero para el DesvioY, esto elegira si se desviará para arriba o para abajo.
         if (Rn < 50)
         {
            DesvioY = -1;
         }else{
            DesvioY = 1;
         }
         DesvioY = DesvioY * (ExtendingCross.spreadValue - ExtendingCross.defaultSpread );
      }

            //Bien, esta línea está MAL, por lo dicho, no cai y esto está colocando las cosas en la zona del mundo XYZ, no relativo a la pantalla.
            //¿Alguna ida aqui O.ò ?

      Vector3 Destiny = new Vector3 (hit.point.x+ DesvioX,hit.point.y+DesvioY,hit.point.z);


            //Lo siguiente es ya lanzar el disparo que va desde el arma, hacia el punto de colisión que encontró el rayo anterior. (Que siempre está
            //en el centro de la pantalla y al que intento aplicarle el desvio.

            float distance = Vector3.Distance (Camera.main.transform.position, hit.point);
      //RaycastHit[] hits = Physics.RaycastAll (startPos, hit.point - startPos, distance);//Esta linea funciona bien.
      RaycastHit[] hits = Physics.RaycastAll (startPos, Destiny - startPos, distance);//Esta es la linea que estoy probando para aplicarle el desvio.

      foreach (RaycastHit hit2 in hits) //Y bueno, aqui ya son los objetos detectados, 3 casos de momento, si es destruible, si es enemigo  y si tiene Rigidbody.
      {
         if (hit2.transform.GetComponent<Obj_Destructible> ())//Si es destruible, lo rompemos.
         {
            hit2.transform.GetComponent<Obj_Destructible> ().destruct = true;
         }

         if (hit2.transform.GetComponent<Enemy_DamageCollider> ())//Si es un enemigo
         {
            AtacandoEnemigo (hit2.transform);               
         }else{
            //Posteriormente, si no es un enemigo, pues miraremos si tiene Rigidbody para empujarlo.
            if (hit2.transform.GetComponent<Rigidbody> ())
            {
               Vector3 direction = hit2.transform.position - transform.position;
               direction = direction.normalized;
               hit2.transform.GetComponent <Rigidbody> ().AddForce (direction * weaponManager.ActiveWeapon.Power);
            }
         }
      }

      //endPos = hit.point;
      endPos = Destiny;//Este es el end.Point con el Desvio en teoria, pero eso, hay que arreglarlo arriba.
   } else { //if(rayo 1)  // Esto es si no ha tocado nada, porque ha disparado al cielo o quien sabe que.
      endPos = ray.GetPoint (100); //Pues simplemente coge un punto que haya en el centro de la pantalla, a 100 unidades al fondo.
   }

        //Esto es ya para ajustar el line renderer de las balas.
   go.GetComponent <Utility_LineRendererShortener> ().currentPos = startPos;
   go.GetComponent <Utility_LineRendererShortener> ().targetPos = endPos;

   line.SetPosition (0, startPos);
   line.SetPosition (1, endPos);
}
Bueno, mucho tocho, aunque en verdad no hace tantas cosas, pero eso, ahí tengo que aplicar el DesvioX y DesvioY para desplazar el hit.point, pero no se me ocurre muy bien como hacerlo para que sea relativo a la cámara.

¿Alguna idea? @_@