Title	Subtitle	Date	Lastmod	Tags	Description	Software
Front War 2 - When the lead strikes the steel - C#/Javascript/traçabilité		2023-12-14		Prog	Article sur le dernier projet personnel.	Unity 3D

Front_war_2

Novembre 2023 - When the lead strikes the steel - Jeu RTS Dans la nostalgie et dans la volonté de continuer ma passion, je décide de reprendre les idées de mon premier projet de Jeu datant de 2016. - Jeu vidéo Objectif open source

J'expliquerai ici comment :

1. Télécharger et jouer la dernière version accessible
2. Télécharger et modifier sur unity la dernière version accessible
3. Utiliser certains codes sans tout télécharger : Triangulation, player raycasting ,code des unités.
4. Télécharger et modifier les visuels utilisés. Tous open-sources.

Novembre 2023 - When the lead strikes the steel - Jeu RTS

Dans la nostalgie et dans la volonté de continuer ma passion, je décide de reprendre les idées de mon premier projet de Jeu datant de 2016. - Jeu vidéo

Je souhaite suivre de bout en bout une rigueur de réalisation, que j'ai connu dans le milieu normatif : traçabilité, standardisation et conformité. Organigramme réalisé sous Visio :

Objectifs :

• Jeu en Real Time strategy macroscopique.

• Vue orthographique et design retro (inspirations Cossacks:Art of War, Age of Empire 2 et empire earth).

• Ne doit pas depasser en taille l'espace de mon disque dur (libre) : 1 Go.

• Créer et faire évoluer son camp à travers l'une des époques les plus révolutionnaires au niveau technique et culturel : 16ème à la Fin du 17 ème - Epoque Pikes & Shottes - L'arrivée des européens en Amérique etc.

• Utilisation de bibliothèques gratuites et libre de droit.

• Traçabilité des exigences et arborescence : réaliser l'exigence "client" jusqu'à la ligne de code.

• Multijoueur avec serveur client-side + ressources graphiques côté client + Pre-rendering.

• Mode de jeu "scalable" en fonction du nombre de joueur.

• Open-source et première version qui sera sur github.

Le principe du cycle en V sera mis en place. Cycle en V réalisé sous Visio :

Server client-side. Schéma à revoir, simplement illustratif :

Exigence du cahier de spécification logiciel concernant les interfaces/menus :

Exigence du cahier de spécification logiciel concernant l'architecture de programmation, on définira ici le back-end comme ce qui ne se voit pas et le front-end comme ce qui se voit :

Civilisation Astèque, mindmap

Pre-art exemples

Civilisation Mongole, mindmap

Civilisation Indienne, mindmap

Civilisation Chinoise, mindmap

Civilisation Française, mindmap

Civilisation Anglaise, mindmap

Civilisation Espagnole, mindmap

Pre-art exemples

Civilisation Ottomane, mindmap

Civilisation Japonaise, mindmap

Code pour l'isométrie

Code pour le fog of war

On utilise la librairie : TasharenFogOfWar : https://github.com/insominx/TasharenFogOfWar

Code pour la triangulation de delaunay et la recherche du point le plus proche

On utilise la librairie : Triangle.NET : https://github.com/wo80/Triangle.NET/

1. Triangulation : Unity n'a pas de support intégré pour la triangulation de Delaunay. Cependant, on peut utiliser des bibliothèques tierces comme Triangle.NET qui peuvent gérer cela. La triangulation de Delaunay est un algorithme qui peut être utilisé pour générer un maillage à partir d'une liste de points Vector3. Il génère des triangles de telle sorte qu'aucun point ne se trouve à l'intérieur du cercle circonscrit d'un triangle.

2. Trouver les points les plus proches : Après la triangulation de Delaunay, on souhaitez trouver les points les plus proches dans le maillage généré. On utilise la librairie et une recherche linéaire avec un nombre de points limités.

3. Dessiner des lignes : Le composant LineRenderer de Unity peut être utilisé pour dessiner une ligne entre deux ou plusieurs points dans l'espace 3D. Une fois que l'on a les points les plus proches, on peut utiliser LineRenderer pour dessiner des lignes entre chaque point et son voisin le plus proche.

*Résultat de triangulation des points en mouvement: *

*Résultat de triangulation des points statiques: *

Code fonctionnel contenant seulement la triangulation :

using UnityEngine;
using TriangleNet.Meshing;
using TriangleNet.Geometry;
using TriangleNet.Meshing.Algorithm;
using TriangleNet.Meshing;
using TriangleNet.Smoothing;
using TriangleNet.IO;
using System.Collections.Generic;

public class triangulation_code : MonoBehaviour 
{
    // Unity objects.
    List<Transform> All_unit = new List<Transform>();

    // Triangle.NET vertices (class instance for better memory performance).
    List<Vertex> vertices = new List<Vertex>();

    // For better memory performance.
    TrianglePool trianglePool = new TrianglePool();
    ITriangulator triangulator = new Dwyer();

    // To find nearest neighbours.
    VertexCirculator vertexCirculator;

    LineRenderer lineRenderer;


    void Start()
    {
        // Create a LineRenderer to display on screen
        lineRenderer = gameObject.GetComponent<LineRenderer>();
        lineRenderer.widthMultiplier = 2f;
    }

    void Update()
    {
        if (All_unit == null || All_unit.Count == 0) return;

        int count = All_unit.Count;

        lineRenderer.positionCount = 0;

        vertices.Clear();

        if (vertices.Capacity < count)
        {
            vertices.EnsureCapacity(count);
        }

        // Copy the position
        for (int i = 0; i < count; i++)
        {
            var pos = All_unit[i].position;

            // IMPORTANT: set correct vertex id (corresponding to index in All_unit).
            //            This will automatically establish the mapping between Unity
            //            and Triangle.NET objects.

            vertices.Add(new Vertex(pos.x, pos.z) { ID = i });
        }

        // Perform Delaunay triangulation on vertices

        var mesh = (Mesh)triangulator.Triangulate(vertices, new Configuration(
            () => RobustPredicates.Default,
            () => trianglePool.Restart()));

        vertexCirculator = new VertexCirculator(mesh);

        // GET ALL THE Point from the triangulation in order to display it 

        var positions_upt = new List<Vector3>();

        foreach (var edge in mesh.Edges)
        {
            positions_upt.Add(All_unit[edge.P0].position);
            positions_upt.Add(All_unit[edge.P1].position);
        }

        lineRenderer.SetPositions(positions_upt.ToArray());

        // Find all nearest neighbors
        for (int i = 0; i < count; i++)
        {
            var obj = All_unit[i];
            int closedId = FindClosest(vertices[i]);

            if (closedId < 0)
            {
                // Something went wrong
            }
            else
            {
                var closest = All_unit[closedId];
            }
        }
    }

    int FindClosest(Vertex vertex)
    {
        if (vertexCirculator == null) return -1;

        Vertex closest = null;
        double closestDist = double.MaxValue;

        foreach (var neighbor in vertexCirculator.EnumerateVertices(vertex))
        {
            var dx = (vertex.X - neighbor.X);
            var dy = (vertex.Y - neighbor.Y);

            var squareDist = dx * dx + dy * dy;

            if (squareDist < closestDist)
            {
                closest = neighbor;
                closestDist = squareDist;
            }
        }

        return closest == null ? -2 : closest.ID;
    }
}

Logiciels / Outils : Unity 3D, Blender, mermaid, jira, confluence.