Merge de dev a Relese

README.md

@@ -1,37 +1,38 @@
-# TGC - MonoGame - TP
+# TGC - MonoGame - Thundering Tanks
 
 [![.NET](https://github.com/tgc-utn/tgc-monogame-tp/actions/workflows/dotnet.yml/badge.svg)](https://github.com/tgc-utn/tgc-monogame-tp/actions/workflows/dotnet.yml)
 [![Codacy Badge](https://app.codacy.com/project/badge/Grade/63382c4441444632b06d83dcc6dab106)](https://app.codacy.com/gh/tgc-utn/tgc-monogame-tp/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
 [![GitHub license](https://img.shields.io/github/license/tgc-utn/tgc-monogame-tp.svg)](https://github.com/tgc-utn/tgc-monogame-tp/blob/master/LICENSE)
 
 [#BuiltWithMonoGame](http://www.monogame.net) and [.NET Core](https://dotnet.microsoft.com)
 
-## Descripción
+## Descripcion
+Juego de batalla de tanques creado por estudiantes de la carrera de ingenieria en sistemas de la UTN de buenos aires para la materia Tecnicas De Graficos Por Computadora utilizando el FrameWork Monogame.
 
-Proyecto plantilla para los trabajos prácticos de la asignatura electiva [Técnicas de Gráficos por Computadora](http://tgc-utn.github.io/) (TGC) en la carrera de Ingeniería en Sistemas de Información. Universidad Tecnológica Nacional, Facultad Regional Buenos Aires (UTN-FRBA).
-
-## Configuración del entorno de desarrollo
-
-Los pasos a seguir según su sistema operativo se pueden leer en el siguiente documento [install.md](https://github.com/tgc-utn/tgc-monogame-samples/blob/master/docs/install/install.md).
-
-Afuera del mundo Windows, vas a necesitar la ayudar de [Wine](https://www.winehq.org) para los shaders, por lo menos por [ahora](https://github.com/MonoGame/MonoGame/issues/2167).
-
-Los recursos usados se almacenan utilizando [Git LFS](https://git-lfs.github.com), con lo cual antes de clonar el repositorio les conviene tenerlo instalado así es automático el pull o si ya lo tienen pueden hacer `git lfs pull`.
+## Controles
+Tecla           | Accion
+-----           | -----
+W               | Movimiento hacia adelante
+A               | Rotacion izquierda
+S               | Movimiento hacia atras
+D               | Rotacion derecha
+C               | Debug mode
+G               | God mode
+Click Izquierdo | Disparo de cañon
 
 ## Integrantes
 
 TGC, Tgcito  |  Apellido, Nombre
 ------------ | -------------
-| <img src="https://github.com/tgc-utn/tgc-utn.github.io/blob/master/images/robotgc.png" height="500"> | <img src="https://github.com/tgc-utn/tgc-utn.github.io/blob/master/images/trofeotp.png" height="500"> |
+| ![Lucas Gelabert](/FotosTGCitos/Lucas%20Gelabert.png)       | Lucas Gelabert    |
+| ![Santiago Saucedo](/FotosTGCitos/Santiago%20Saucedo.png)   | Santiago Saucedo  |
+| ![Simon Cutrera](/FotosTGCitos/Simon%20Cutrera.png)         | Simon Cutrera     |
+| ![Tomas Zubizarreta](/FotosTGCitos/Tomas%20Zubizarreta.png) | Tomas Zubizarreta |
 
 ## Capturas
 
-![screenshot1](https://github.com/tgc-utn/tgc-monogame-tp/blob/master/TGC.MonoGame.TP/Icon.bmp)
-![screenshot2](https://github.com/tgc-utn/tgc-monogame-tp/blob/master/TGC.MonoGame.TP/Icon.bmp)
-![screenshot3](https://github.com/tgc-utn/tgc-monogame-tp/blob/master/TGC.MonoGame.TP/Icon.bmp)
-![screenshot4](https://github.com/tgc-utn/tgc-monogame-tp/blob/master/TGC.MonoGame.TP/Icon.bmp)
-![screenshot5](https://github.com/tgc-utn/tgc-monogame-tp/blob/master/TGC.MonoGame.TP/Icon.bmp)
+![Menu](/FotosGameplay/Menu.png)
 
-## Game Play
+![Gameplay](/FotosGameplay/Gameplay.png)
 
-[![Watch the video](https://img.youtube.com/vi/pgEwUC0jvH4/0.jpg)](https://www.youtube.com/playlist?list=PLRM4L32DjvnazuMl8wZlbpEYL5Qh63ulG)
+## Game Play

TGC.MonoGame.TP/Animations/DataTypes/AnimationBone.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using ThunderingTanks.Animation;
+
+namespace ThunderingTanks.Animation.DataTypes;
+
+/// <summary>
+///     Keyframes are grouped per bone for an animation clip.
+/// </summary>
+public class AnimationBone
+{
+    /// <summary>
+    ///     The keyframes for this bone.
+    /// </summary>
+    public List<Keyframe> Keyframes { get; set; } = new();
+
+    /// <summary>
+    ///     The bone name for these keyframes.
+    ///     Each bone has a name so we can associate it with a runtime model.
+    /// </summary>
+    public string Name { get; set; } = string.Empty;
+}

TGC.MonoGame.TP/Animations/DataTypes/AnimationClip.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using ThunderingTanks.Animation;
+
+namespace ThunderingTanks.Animation.DataTypes;
+
+/// <summary>
+///     An animation clip is a set of keyframes with associated bones.
+/// </summary>
+public class AnimationClip
+{
+    /// <summary>
+    ///     The bones for this animation clip with their keyframes.
+    /// </summary>
+    public List<AnimationBone> Bones { get; set; } = new();
+
+    /// <summary>
+    ///     Duration of the animation clip.
+    /// </summary>
+    public double Duration { get; set; }
+
+    /// <summary>
+    ///     Name of the animation clip.
+    /// </summary>
+    public string Name { get; set; }
+}

TGC.MonoGame.TP/Animations/DataTypes/Keyframe.cs

@@ -0,0 +1,40 @@
+using Microsoft.Xna.Framework;
+using ThunderingTanks.Animation;
+
+namespace ThunderingTanks.Animation.DataTypes;
+
+/// <summary>
+///     An Keyframe is a rotation and Translation for a moment in time.
+///     It would be easy to extend this to include scaling as well.
+/// </summary>
+public class Keyframe
+{
+    /// <summary>
+    ///     The rotation for the bone.
+    /// </summary>
+    public Quaternion Rotation { get; set; }
+
+    /// <summary>
+    ///     The keyframe time.
+    /// </summary>
+    public double Time { get; set; }
+
+    /// <summary>
+    ///     The Translation for the bone.
+    /// </summary>
+    public Vector3 Translation { get; set; }
+
+    public Matrix Transform
+    {
+        get => Matrix.CreateFromQuaternion(Rotation) * Matrix.CreateTranslation(Translation);
+        set
+        {
+            var transform = value;
+            transform.Right = Vector3.Normalize(transform.Right);
+            transform.Up = Vector3.Normalize(transform.Up);
+            transform.Backward = Vector3.Normalize(transform.Backward);
+            Rotation = Quaternion.CreateFromRotationMatrix(transform);
+            Translation = transform.Translation;
+        }
+    }
+}

TGC.MonoGame.TP/Animations/DataTypes/ModelExtra.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+
+namespace ThunderingTanks.Animation.DataTypes;
+
+/// <summary>
+///     Class that contains additional information attached to the model and shared with the runtime.
+/// </summary>
+public class ModelExtra
+{
+    /// <summary>
+    ///     Animation clips associated with this model.
+    /// </summary>
+    public List<AnimationClip> Clips { get; set; } = new();
+
+    /// <summary>
+    ///     The bone indices for the skeleton associated with any skinned model.
+    /// </summary>
+    public List<int> Skeleton { get; set; } = new();
+}

TGC.MonoGame.TP/Animations/Models/AnimatedModel.cs

@@ -0,0 +1,162 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Graphics;
+using ThunderingTanks.Animation.DataTypes;
+
+namespace ThunderingTanks.Animation.Models;
+
+/// <summary>
+///     An enclosure for an XNA Model that we will use that includes support for Bones, animation, and some manipulations.
+/// </summary>
+public class AnimatedModel
+{
+    /// <summary>
+    ///     The Model asset name.
+    /// </summary>
+    private readonly string _assetName;
+
+    /// <summary>
+    ///     The underlying Bones for the Model.
+    /// </summary>
+    private readonly List<Bone> _bones = new();
+
+    /// <summary>
+    ///     The actual underlying XNA Model.
+    /// </summary>
+    private Model _model;
+
+    /// <summary>
+    ///     Extra data associated with the XNA Model.
+    /// </summary>
+    private ModelExtra _modelExtra;
+
+    /// <summary>
+    ///     An associated animation clip Player.
+    /// </summary>
+    private AnimationPlayer _player;
+
+    /// <summary>
+    ///     The Model animation clips.
+    /// </summary>
+    public List<AnimationClip> Clips => _modelExtra.Clips;
+
+    /// <summary>
+    ///     Creates the Model from an XNA Model.
+    /// </summary>
+    /// <param name="assetName">The name of the asset for this Model.</param>
+    public AnimatedModel(string assetName)
+    {
+        _assetName = assetName;
+    }
+
+    /// <summary>
+    ///     Play an animation clip.
+    /// </summary>
+    /// <param name="clip">The clip to play.</param>
+    /// <returns>The Player that will play this clip.</returns>
+    public AnimationPlayer PlayClip(AnimationClip clip)
+    {
+        // Create a clip Player and assign it to this Model.
+        _player = new AnimationPlayer(clip, this);
+        return _player;
+    }
+
+    /// <summary>
+    ///     Update animation for the Model.
+    /// </summary>
+    public void Update(GameTime gameTime)
+    {
+        _player.Update(gameTime);
+    }
+
+    /// <summary>
+    ///     Draw the Model.
+    /// </summary>
+    /// <param name="world">A world matrix to place the Model.</param>
+    /// <param name="view">The view matrix, normally from the camera.</param>
+    /// <param name="projection">The projection matrix, normally from the application.</param>
+    public void Draw(Matrix world, Matrix view, Matrix projection)
+    {
+        // Compute all of the bone absolute transforms.
+        var boneTransforms = new Matrix[_bones.Count];
+
+        for (var i = 0; i < _bones.Count; i++)
+        {
+            var bone = _bones[i];
+            bone.ComputeAbsoluteTransform();
+
+            boneTransforms[i] = bone.AbsoluteTransform;
+        }
+
+        // Determine the skin transforms from the skeleton.
+        var skeleton = new Matrix[_modelExtra.Skeleton.Count];
+        for (var s = 0; s < _modelExtra.Skeleton.Count; s++)
+        {
+            var bone = _bones[_modelExtra.Skeleton[s]];
+            skeleton[s] = bone.SkinTransform * bone.AbsoluteTransform;
+        }
+
+        // Draw the Model.
+        foreach (var modelMesh in _model.Meshes)
+        {
+            foreach (var effect in modelMesh.Effects)
+            {
+                var skinnedEffect = effect as SkinnedEffect;
+                skinnedEffect.World = boneTransforms[modelMesh.ParentBone.Index] * world;
+                skinnedEffect.View = view;
+                skinnedEffect.Projection = projection;
+                skinnedEffect.EnableDefaultLighting();
+                skinnedEffect.PreferPerPixelLighting = true;
+                skinnedEffect.SetBoneTransforms(skeleton);
+            }
+
+            modelMesh.Draw();
+        }
+    }
+
+    /// <summary>
+    ///     Load the Model asset from content.
+    /// </summary>
+    public void LoadContent(ContentManager content)
+    {
+        _model = content.Load<Model>(_assetName);
+        _modelExtra = _model.Tag as ModelExtra;
+
+        ObtainBones();
+    }
+
+    /// <summary>
+    ///     Get the Bones from the Model and create a bone class object for each bone. We use our bone class to do the real
+    ///     animated bone work.
+    /// </summary>
+    private void ObtainBones()
+    {
+        _bones.Clear();
+        foreach (var bone in _model.Bones)
+        {
+            // Create the bone object and add to the hierarchy.
+            var newBone = new Bone(bone.Name, bone.Transform, bone.Parent != null ? _bones[bone.Parent.Index] : null);
+
+            // Add to the Bones for this Model.
+            _bones.Add(newBone);
+        }
+    }
+
+    /// <summary>
+    ///     Find a bone in this Model by name.
+    /// </summary>
+    public Bone FindBone(string name)
+    {
+        foreach (var bone in _bones)
+        {
+            if (bone.Name == name)
+            {
+                return bone;
+            }
+        }
+
+        return null;
+    }
+}