Desarrollo y creacion de videojuegos.Godot,Unity,Blender,Gimp,Game Maker,: mayo 2023

martes, 30 de mayo de 2023

Play a ostia limpia 2 con itch.io;

domingo, 28 de mayo de 2023

desmotivado;pérdida del entusiasmo, la disposición y la energía para llevar a cabo determinadas actividades;

😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔😔

https://videojuegosenlineaasaco4.blogspot.com/2023/06/motivado-de-nuevo.html

(¿Qué es una persona desmotivado?

La desmotivación, al contrario, es la falta de esas razones para guiar nuestro comportamiento, es la pérdida del entusiasmo, la disposición y la energía para llevar a cabo determinadas actividades. Es un sentimiento de desesperanza y pesimismo que surge cuando nos enfrentamos a determinados obstáculos.)

Breve resumen de mi afición a desarrollar videojuegos asta la fecha y dificultades que me encuentro actualmente.

Empece publicando en gamejolt, y con publicidad había alguna motivación para seguir en esta plataforma, pero como había gente que abusaba de esa publicidad gamejolt corto por lo sano y no tiene ningún incentivo por ese lado, puedes publicar de pago, pero pasando datos personales y de momento no lo veo claro…...resultado me desmotive de gamejolt y ya no pongo nada hay asta que no sepa mas.

Seguí con itch.io , el mejor sitio y cuando estoy empezando a avanzar y ser conocido y a estar mas motivado que nunca de repente soy invisible en esta plataforma, por alguna razón estoy vetado y mis mas de 100 juegos solo los puedo ver yo, y no me dejan poner ninguno de pago, estoy esperando alguna explicación desde el soporte de esta plataforma, según ellos me dirán algo, algún error cometí sin ser conciente de ello, o abuse de subir juegos, o algo esta censurado, pero bamos que se me han quitado las ganas de seguir con la aficcion de seguir desarrollando….

Estoy probando otras plataformas de subir mis juegos, pero no encuentro información de ningún tipo sobre ellas y no consigo que funcione ningún juego en html webGL, osea que me acaban de hundir el barco….estas webs

https://www.kongregate.com/ aquí para subir un juego primero has de escribirles a su web de soporte

https://www.indiexpo.net aquí subes uno y no hay manera de corregir ni anular nada ni encuentro información en ningún sitio sobre este lugar…..

Creo que voy a dejar el tema y plegar definitivamente….me rindo.

Si ago algo sera sin internet y sin conectarme ni mostrar nada en ningún sitio, solo por diversión y curiosidad personal de cuando se me ocurra o me apetezca hacer algo….

De Steam

no digo nada, no tengo conocimientos, ni tiempo, y creo que ni una conexión de internet lo suficientemente buena para meterme hay ni siquiera creo que pudiese con el juego mas sencillo del mundo.

¿ continuare…..?

https://videojuegosenlineaasaco4.blogspot.com/2023/06/motivado-de-nuevo.html

😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞😞

jueves, 25 de mayo de 2023

tortilandiawebgl;

miércoles, 24 de mayo de 2023

tortilandia;

martes, 16 de mayo de 2023

Execution with love by TOZUDO;

sábado, 13 de mayo de 2023

Como funciona un ThirdPersonController en Unity.;

using System;
using UnityEngine;

namespace UnityStandardAssets.Characters.ThirdPerson
{
    [RequireComponent(typeof (UnityEngine.AI.NavMeshAgent))]
    [RequireComponent(typeof (ThirdPersonCharacter))]
    public class AICharacterControl : MonoBehaviour
    {
        public UnityEngine.AI.NavMeshAgent agent { get; private set; }             // the navmesh agent required for the path finding
        public ThirdPersonCharacter character { get; private set; } // the character we are controlling
        public Transform target;                                    // target to aim for

        private void Start()
        {
            // get the components on the object we need ( should not be null due to require component so no need to check )
            agent = GetComponentInChildren<UnityEngine.AI.NavMeshAgent>();
            character = GetComponent<ThirdPersonCharacter>();

            agent.updateRotation = false;
            agent.updatePosition = true;
        }

        private void Update()
        {
            if (target != null)
                agent.SetDestination(target.position);

            if (agent.remainingDistance > agent.stoppingDistance)
                character.Move(agent.desiredVelocity, false, false);
            else
                character.Move(Vector3.zero, false, false);
        }

        public void SetTarget(Transform target)
        {
            this.target = target;
        }
    }
}

😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇

using UnityEngine;

namespace UnityStandardAssets.Characters.ThirdPerson
{
   [RequireComponent(typeof(Rigidbody))]
   [RequireComponent(typeof(CapsuleCollider))]
   [RequireComponent(typeof(Animator))]
   public class ThirdPersonCharacter : MonoBehaviour
   {
        [SerializeField] float m_MovingTurnSpeed = 360;
        [SerializeField] float m_StationaryTurnSpeed = 180;
        [SerializeField] float m_JumpPower = 12f;
        [Range(1f, 4f)][SerializeField] float m_GravityMultiplier = 2f;
        [SerializeField] float m_RunCycleLegOffset = 0.2f; //specific to the character in sample assets, will need to be modified to work with others
        [SerializeField] float m_MoveSpeedMultiplier = 1f;
        [SerializeField] float m_AnimSpeedMultiplier = 1f;
        [SerializeField] float m_GroundCheckDistance = 0.1f;

        Rigidbody m_Rigidbody;
        Animator m_Animator;
        bool m_IsGrounded;
        float m_OrigGroundCheckDistance;
        const float k_Half = 0.5f;
        float m_TurnAmount;
        float m_ForwardAmount;
        Vector3 m_GroundNormal;
        float m_CapsuleHeight;
        Vector3 m_CapsuleCenter;
        CapsuleCollider m_Capsule;
        bool m_Crouching;

        void Start()
        {
            m_Animator = GetComponent<Animator>();
            m_Rigidbody = GetComponent<Rigidbody>();
            m_Capsule = GetComponent<CapsuleCollider>();
            m_CapsuleHeight = m_Capsule.height;
            m_CapsuleCenter = m_Capsule.center;

            m_Rigidbody.constraints = RigidbodyConstraints.FreezeRotationX | RigidbodyConstraints.FreezeRotationY | RigidbodyConstraints.FreezeRotationZ;
            m_OrigGroundCheckDistance = m_GroundCheckDistance;
        }

        public void Move(Vector3 move, bool crouch, bool jump)
        {

            // convert the world relative moveInput vector into a local-relative
            // turn amount and forward amount required to head in the desired
            // direction.
            if (move.magnitude > 1f) move.Normalize();
            move = transform.InverseTransformDirection(move);
            CheckGroundStatus();
            move = Vector3.ProjectOnPlane(move, m_GroundNormal);
            m_TurnAmount = Mathf.Atan2(move.x, move.z);
            m_ForwardAmount = move.z;

            ApplyExtraTurnRotation();

            // control and velocity handling is different when grounded and airborne:
            if (m_IsGrounded)
            {
                HandleGroundedMovement(crouch, jump);
            }
            else
            {
                HandleAirborneMovement();
            }

            ScaleCapsuleForCrouching(crouch);
            PreventStandingInLowHeadroom();

            // send input and other state parameters to the animator
            UpdateAnimator(move);
        }

        void ScaleCapsuleForCrouching(bool crouch)
        {
            if (m_IsGrounded && crouch)
            {
                if (m_Crouching) return;
                m_Capsule.height = m_Capsule.height / 2f;
                m_Capsule.center = m_Capsule.center / 2f;
                m_Crouching = true;
            }
            else
            {
                Ray crouchRay = new Ray(m_Rigidbody.position + Vector3.up * m_Capsule.radius * k_Half, Vector3.up);
                float crouchRayLength = m_CapsuleHeight - m_Capsule.radius * k_Half;
                if (Physics.SphereCast(crouchRay, m_Capsule.radius * k_Half, crouchRayLength, Physics.AllLayers, QueryTriggerInteraction.Ignore))
                {
                    m_Crouching = true;
                    return;
                }
                m_Capsule.height = m_CapsuleHeight;
                m_Capsule.center = m_CapsuleCenter;
                m_Crouching = false;
            }
        }

        void PreventStandingInLowHeadroom()
        {
            // prevent standing up in crouch-only zones
            if (!m_Crouching)
            {
                Ray crouchRay = new Ray(m_Rigidbody.position + Vector3.up * m_Capsule.radius * k_Half, Vector3.up);
                float crouchRayLength = m_CapsuleHeight - m_Capsule.radius * k_Half;
                if (Physics.SphereCast(crouchRay, m_Capsule.radius * k_Half, crouchRayLength, Physics.AllLayers, QueryTriggerInteraction.Ignore))
                {
                    m_Crouching = true;
                }
            }
        }

        void UpdateAnimator(Vector3 move)
        {
            // update the animator parameters
            m_Animator.SetFloat("Forward", m_ForwardAmount, 0.1f, Time.deltaTime);
            m_Animator.SetFloat("Turn", m_TurnAmount, 0.1f, Time.deltaTime);
            m_Animator.SetBool("Crouch", m_Crouching);
            m_Animator.SetBool("OnGround", m_IsGrounded);
            if (!m_IsGrounded)
            {
                m_Animator.SetFloat("Jump", m_Rigidbody.velocity.y);
            }

            // calculate which leg is behind, so as to leave that leg trailing in the jump animation
            // (This code is reliant on the specific run cycle offset in our animations,
            // and assumes one leg passes the other at the normalized clip times of 0.0 and 0.5)
            float runCycle =
                Mathf.Repeat(
                    m_Animator.GetCurrentAnimatorStateInfo(0).normalizedTime + m_RunCycleLegOffset, 1);
            float jumpLeg = (runCycle < k_Half ? 1 : -1) * m_ForwardAmount;
            if (m_IsGrounded)
            {
                m_Animator.SetFloat("JumpLeg", jumpLeg);
            }

            // the anim speed multiplier allows the overall speed of walking/running to be tweaked in the inspector,
            // which affects the movement speed because of the root motion.
            if (m_IsGrounded && move.magnitude > 0)
            {
                m_Animator.speed = m_AnimSpeedMultiplier;
            }
            else
            {
                // don't use that while airborne
                m_Animator.speed = 1;
            }
        }

        void HandleAirborneMovement()
        {
            // apply extra gravity from multiplier:
            Vector3 extraGravityForce = (Physics.gravity * m_GravityMultiplier) - Physics.gravity;
            m_Rigidbody.AddForce(extraGravityForce);

            m_GroundCheckDistance = m_Rigidbody.velocity.y < 0 ? m_OrigGroundCheckDistance : 0.01f;
        }

        void HandleGroundedMovement(bool crouch, bool jump)
        {
            // check whether conditions are right to allow a jump:
            if (jump && !crouch && m_Animator.GetCurrentAnimatorStateInfo(0).IsName("Grounded"))
            {
                // jump!
                m_Rigidbody.velocity = new Vector3(m_Rigidbody.velocity.x, m_JumpPower, m_Rigidbody.velocity.z);
                m_IsGrounded = false;
                m_Animator.applyRootMotion = false;
                m_GroundCheckDistance = 0.1f;
            }
        }

        void ApplyExtraTurnRotation()
        {
            // help the character turn faster (this is in addition to root rotation in the animation)
            float turnSpeed = Mathf.Lerp(m_StationaryTurnSpeed, m_MovingTurnSpeed, m_ForwardAmount);
            transform.Rotate(0, m_TurnAmount * turnSpeed * Time.deltaTime, 0);
        }

        public void OnAnimatorMove()
        {
            // we implement this function to override the default root motion.
            // this allows us to modify the positional speed before it's applied.
            if (m_IsGrounded && Time.deltaTime > 0)
            {
                Vector3 v = (m_Animator.deltaPosition * m_MoveSpeedMultiplier) / Time.deltaTime;

                // we preserve the existing y part of the current velocity.
                v.y = m_Rigidbody.velocity.y;
                m_Rigidbody.velocity = v;
            }
        }

        void CheckGroundStatus()
        {
            RaycastHit hitInfo;
#if UNITY_EDITOR
            // helper to visualise the ground check ray in the scene view
            Debug.DrawLine(transform.position + (Vector3.up * 0.1f), transform.position + (Vector3.up * 0.1f) + (Vector3.down * m_GroundCheckDistance));
#endif
            // 0.1f is a small offset to start the ray from inside the character
            // it is also good to note that the transform position in the sample assets is at the base of the character
            if (Physics.Raycast(transform.position + (Vector3.up * 0.1f), Vector3.down, out hitInfo, m_GroundCheckDistance))
            {
                m_GroundNormal = hitInfo.normal;
                m_IsGrounded = true;
                m_Animator.applyRootMotion = true;
            }
            else
            {
                m_IsGrounded = false;
                m_GroundNormal = Vector3.up;
                m_Animator.applyRootMotion = false;
            }
        }
   }
}

😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇

using System;
using UnityEngine;
using UnityStandardAssets.CrossPlatformInput;

namespace UnityStandardAssets.Characters.ThirdPerson
{
    [RequireComponent(typeof (ThirdPersonCharacter))]
    public class ThirdPersonUserControl : MonoBehaviour
    {
        private ThirdPersonCharacter m_Character; // A reference to the ThirdPersonCharacter on the object
        private Transform m_Cam;                  // A reference to the main camera in the scenes transform
        private Vector3 m_CamForward;             // The current forward direction of the camera
        private Vector3 m_Move;
        private bool m_Jump;                      // the world-relative desired move direction, calculated from the camForward and user input.


        private void Start()
        {
            // get the transform of the main camera
            if (Camera.main != null)
            {
                m_Cam = Camera.main.transform;
            }
            else
            {
                Debug.LogWarning(
                    "Warning: no main camera found. Third person character needs a Camera tagged \"MainCamera\", for camera-relative controls.", gameObject);
                // we use self-relative controls in this case, which probably isn't what the user wants, but hey, we warned them!
            }

            // get the third person character ( this should never be null due to require component )
            m_Character = GetComponent<ThirdPersonCharacter>();
        }

        private void Update()
        {
            if (!m_Jump)
            {
                m_Jump = CrossPlatformInputManager.GetButtonDown("Jump");
            }
        }

        // Fixed update is called in sync with physics
        private void FixedUpdate()
        {
            // read inputs
            float h = CrossPlatformInputManager.GetAxis("Horizontal");
            float v = CrossPlatformInputManager.GetAxis("Vertical");
            bool crouch = Input.GetKey(KeyCode.C);

            // calculate move direction to pass to character
            if (m_Cam != null)
            {
                // calculate camera relative direction to move:
                m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized;
                m_Move = v*m_CamForward + h*m_Cam.right;
            }
            else
            {
                // we use world-relative directions in the case of no main camera
                m_Move = v*Vector3.forward + h*Vector3.right;
            }
#if !MOBILE_INPUT
            // walk speed multiplier
            if (Input.GetKey(KeyCode.LeftShift)) m_Move *= 0.5f;
#endif

            // pass all parameters to the character control script
            m_Character.Move(m_Move, crouch, m_Jump);
            m_Jump = false;
        }
    }
}

😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇

using UnityEngine;
using System.Collections;

public class TransformFunctions : MonoBehaviour
{
   public float moveSpeed = 10f;
   public float turnSpeed = 50f;

   void Update ()
   {

        if (Input.GetKey(KeyCode.W))////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);

        if (Input.GetKey(KeyCode.S))////funciona contantemente al apretar W mayusculas a de ser
        //if(Input.GetKey(KeyCode.DownArrow))
            transform.Translate(-Vector3.forward * moveSpeed * Time.deltaTime);

        if (Input.GetKey(KeyCode.A))////funciona contantemente al apretar W mayusculas a de ser
        //if(Input.GetKey(KeyCode.LeftArrow))
            transform.Rotate(Vector3.up, -turnSpeed * Time.deltaTime);

        if (Input.GetKey(KeyCode.D))////funciona contantemente al apretar W mayusculas a de ser

        //if(Input.GetKey(KeyCode.RightArrow))
            transform.Rotate(Vector3.up, turnSpeed * Time.deltaTime);

   }
}

😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇😇

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 controladordevaquero : MonoBehaviour
{

   public Animator Anim;
   public float WalkSpeed;

   void Update()
   {

        if (Input.GetKey(KeyCode.E))
        {
            Anim.SetBool("CORRER", true);
            transform.Translate(Vector3.forward * WalkSpeed * Time.deltaTime);
        }
        else
        {
            Anim.SetBool("CORRER", false);

            if (Input.GetKey(KeyCode.W))
            {
                Anim.SetBool("ANDA", true);
                transform.Translate(Vector3.forward * WalkSpeed * Time.deltaTime);
            }
            else
            {
                Anim.SetBool("ANDA", false);

                if (Input.GetKey(KeyCode.S))
                {
                    Anim.SetBool("ATRAS", true);
                    transform.Translate(Vector3.forward * WalkSpeed * Time.deltaTime);
                }
                else
                {
                    Anim.SetBool("ATRAS", false);

                    if (Input.GetKey(KeyCode.A))
                    {

                        Anim.SetBool("CORRER", true);
                        transform.Translate(Vector3.forward * WalkSpeed * Time.deltaTime);
                    }
                    else
                    {
                        Anim.SetBool("CORRER", false);

                        if (Input.GetKey(KeyCode.P))
                        {/////ORIGINAL

                            Anim.SetBool("BOMBA", true);
                            transform.Translate(Vector3.forward * WalkSpeed * Time.deltaTime);
                        }
                        else
                        {
                            Anim.SetBool("BOMBA", false);

                            if (Input.GetKey(KeyCode.O))
                            {

                                Anim.SetBool("BOMBA", true);
                                transform.Translate(Vector3.forward * WalkSpeed * Time.deltaTime);
                            }
                            else
                            {
                                Anim.SetBool("BOMBA", false);

                                if (Input.GetKey(KeyCode.D))
                                {

                                    Anim.SetBool("CORRER", true);
                                    transform.Translate(Vector3.forward * WalkSpeed * Time.deltaTime);
                                }
                                else
                                {
                                    Anim.SetBool("CORRER", false);

                                        if (Input.GetButton ("Fire3")) {

                                        Anim.SetBool ("DISPARANDO", true);
                                    transform.Translate(Vector3.forward * WalkSpeed * Time.deltaTime);
                                    } else {
                                        Anim.SetBool ("DISPARANDO", false);

                                    if (Input.GetKey(KeyCode.P))

                                    {

                                        Anim.SetBool("LANZAR", true);
                                        transform.Translate(Vector3.forward * WalkSpeed * Time.deltaTime);
                                    }
                                    else
                                    {
                                        Anim.SetBool("LANZAR", false);


                                        //if (Input.GetButton("Fire1"))/////original que ba
                                            //if (Input.GetButtonUp("Fire1"))//////funciona a otro ritmo
                                            if (Input.GetButtonDown("Fire1"))
                                            {/////ORIGINAL

                                            Anim.SetBool("BOMBA", true);
                                            transform.Translate(Vector3.forward * WalkSpeed * Time.deltaTime);
                                        }
                                        else
                                        {
                                            Anim.SetBool("BOMBA", false);

                                            //if (Input.GetButton ("Fire1"))////// AMETRALLADORA AMETRAYADORA

                                            //if (Input.GetButtonUp("Fire1"))/////TIRO A TIRO
                                            //if (Input.GetButtonDown("Fire1"))/////TIRO A TIRO
                                            if (Input.GetKey(KeyCode.Mouse1))
                                        {///////////ORIGINAL 8-7-22
                                        //if (Input.GetKey (KeyCode.Mouse2)){///////////ORIGINAL 8-7-22
                                        //if (Input.GetKey (KeyCode.M)) {/////////////////////////loroooooooooooooooooooooooo
                                            Anim.SetBool("LANZAR", true);
                                            transform.Translate(Vector3.forward * WalkSpeed * Time.deltaTime);
                                        }
                                        else
                                        {
                                            Anim.SetBool("LANZAR", false);

                                            if (Input.GetKey(KeyCode.Space))
                                            {
                                                //if (Input.GetButtonDown("Fire1"))/////TIRO A TIRO
                                                Anim.SetBool("LANZAR", true);
                                                transform.Translate(Vector3.forward * WalkSpeed * Time.deltaTime);
                                            }
                                            else
                                            {
                                                Anim.SetBool("LANZAR", false);

                                                //if ((Input.GetKey(KeyCode.L)) & (Input.GetKey(KeyCode.Space)))
                                                //    if ((Input.GetKey(KeyCode.S)) & (Input.GetKey(KeyCode.Space)))

                                                if (Input.GetKey(KeyCode.Space))

                                                {
                                                    //if (Input.GetButtonDown("Fire1"))/////TIRO A TIRO
                                                    Anim.SetBool("SEÑALA", true);
                                                    transform.Translate(Vector3.forward * WalkSpeed * Time.deltaTime);
                                                }
                                                else
                                                {
                                                    Anim.SetBool("SEÑALA", false);

                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

        }
   }

}
}

}

sábado, 6 de mayo de 2023

Prototype 8 from World War II by TOZUDO;

jueves, 4 de mayo de 2023

script en C#, sirve para abrir y cerrar puertas, pone los gameobjects necesarios uno animado;

script en C#,para Unity; sirve para abrir y cerrar puertas, pone los gameobjects necesarios uno animado; el otro quieto, imitando las puertas , este es el primero que lo escrito yo combinando varias lineas....apartir de aqui creo podre hacer scripts nuevos originales echos por mi,

Aun nose programar, pero pienso que es como aprender un idioma nuevo, con signos dibujos de letras nuevos....

primero por poner un ejemplo del concepto abstrapto de lo que hay que retener en la mente para programar.......

es como aprender las bocales y sus dibujos de letra...por ejemplo la -a- la -e- la -i- la -o - la -u-

hay que aprender una base. luego las consonantes, osea el abecedario sin las bocales...abcdefghijkqelxiyz....

el siguiente paso es combinar ambas para hacer silabas...la b con la a ba...la b con la e be la b con la i bi.....

combinar estas entre si y hacer palabras por ejemplo la m con la a ma y otra bez la m con la a ma osea la palabra mama, y siguiendo esta forma de imaginar la programacion, seguir haciendo combinacion para nuebas palabras y hacer frases enteras y con esas frases relatos, e ir escalando hacia programas mas complejos........

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

public class COMBINACIONMULTIPLE : MonoBehaviour
{

    public GameObject quieta;
    public GameObject abre;
    public GameObject puerta;

    private void OnTriggerEnter(Collider other)
    {

        if (other.tag == "Player")
        {

          // if (other.tag == "nazi")
           // {

              // if (other.tag == "caca")
               // {

                    quieta.SetActive(true);
                    abre.SetActive(true);
            puerta.SetActive(false);
        }
            }

     //   }
   // }

    private void OnTriggerExit(Collider other)
    {

        if (other.tag == "Player")
        {

           // if (other.tag == "nazi")
           // {

              // if (other.tag == "caca")
               // {

               quieta.SetActive(false);
abre.SetActive(false);
            puerta.SetActive(true);

        }
            }

        }

   // }

//}

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

---------------------------------------------- el script de arriba lo boy a juntar con el de abajo intentare hacer uno nuevo sumando partes de estos dos------------------------------------------------------------------------------------------------------------------------------------------------

Desarrollo y creacion de videojuegos.Godot,Unity,Blender,Gimp,Game Maker,