Spring

📰 Title:	Spring	🕹️ / 🛠️ Type:	Tool
🗃️ Genre:	Strategy	🚦 Status:	05. Tested & Working (status)
🏷️ Category:	Strategy ➤ Top-Down Fight of Units ➤ Spring, TA, ...	🌍️ Browser version:
🔖 Tags:	3D engine; Spring engine; Strategy; Tactical; Real Time Tactics; Action; Wargame; Large-Scale Combat; Conquest; Military; Mining; Building; Sci-fi; Mecha; Vehicles; Tanks; Planes; Ships; Naval battles; Physics; Remake; Open World; Weather; Level Editor; Moddable; Replay Value; Flagship; Fog of War; Local Multi; Online Multi; Local Co-op; Co-op; Co-op vs AI; Competitive; PvP; PvE; Keyboard; Mouse; Chat; 3D Sound	📦️ Package Name:	spring \| springrts
🐣️ Approx. start:	2005-04-26	📦️ Arch package:
🐓️ Latest:	2023-01-06	📦️ RPM package:
📍️ Version:	Latest: 106.0.1 / Dev: f66536a	📦️ Deb package:
🏛️ License type:	🕊️ Libre	📦️ Flatpak package:
🏛️ License:	GPL-2+	📦️ AppImage package:
🏝️ Perspective:	Bird's-eye view	📦️ Snap package:
👁️ Visual:	3D Top-Down	⚙️ Generic binary:
⏱️ Pacing:	Real Time	📄️ Source:
👫️ Played:	Single & Multi	📱️ PDA support:
🎖️ This record:		🕳️ Not used:
🎀️ Game design:		👫️ Contrib.:	goupildb & Louis
🎰️ ID:	12929	🐛️ Created:	2010-08-20
🐜️ Updated:	2023-04-14

[en]:	An RTS engine inspired by Total Annihilation. Compared to the latter, it is libre, multi-platform, offers incomparably more beautiful graphics in real 3D real-time, its code and its data are separated, it allows SP (with several types of AIs) / MP (LAN/WAN) games, supports modern hardware ("multi-touch", Mumble, spatialized sound, virtual cameras, ...) and it is maintained / improved regularly. The games feature combat on land, air and sea, where the number of units is only limited by the power of the hardware.	[fr]:	Un moteur de RTS inspiré de Total Annihilation. Par rapport à ce dernier, il est libre, multi-plateforme, offre des graphismes incomparablement plus beaux en vrai 3D temps réel, son code et ses données sont séparés, il permet le jeu solo (avec plusieurs types d'IAs) / multi (LAN/WAN), supporte le matériel moderne ("multi-touch", Mumble, son spatialisé, caméras virtuelles, ...), et il est régulièrement maintenu / amélioré. Les jeux mettent en scène des combats sur terre, air et mer dont le nombre d'unités n'est limité que par la puissance du matériel.

📕 Description [en]

📕🐧"A libre SP/MP 3D RTS engine with beautiful graphics featuring combat on land, air & sea"🐧📕

Spring is a versatile 3D RTS game engine.
Using extensively Lua for scripting game-specific code to make nearly every aspect of the engine customizable, from GUI, to unit AI, to pathfinding.

There are a number of games made for the Spring Engine.

Spring is an engine! It can play many different games and maps. To play, you need at least one Game and Map!

Features

• Many different Games, made just for Spring.
• Play online, on a LAN or offline Single Player.
• Large battles limited only by the power of your computer; support for up to 5000 units.
• Large, highly detailed maps in which to wage those battles, fully 3D with deformable terrain, forest fires, dynamic and reflective water, and custom skyboxes.
• Several camera modes, allowing for anything to be viewed from almost any angle.
• Fully 3D combat in land, sea, and air, with realistic weapon trajectories (physics engine).
• Complex 3rd party AIs, some of which are quite good.
• An extremely powerful UI, designed to minimize unnecessary micromanagement.
• Utf8 font rendering
• Frequent additions and bugfixes.

🍥️ Debian :

Modern full-3D RTS game engine

Spring is a modern full-3D RTS (Real Time Strategy) game engine originally created to bring the gameplay experience of Total Annihilation into 3D. Games are played using one of a number of mods.

This package just includes the game engine and the default AI, with no maps, mods or rich user interface.

🌍️ Wikipedia:

The Spring Engine (also termed SpringRTS and formerly TA Spring), is a game engine for real-time strategy (RTS) video games originally created by Stefan Johansson and Robin Westberg, members of the Swedish Yankspankers game clan. Originally intended to bring the gameplay experience of Total Annihilation into three dimensions, the engine has since evolved to support a plethora of more modern and more flexible features, including built-in high-level extensibility through a Lua scripting interface. The core game engine is free and open-source software, subject to the terms of the GNU General Public License (GPL) version 2.

History

Beginning as a Total Annihilation clone

The development was initiated by Stefan Johansson and Robin Westberg, members of the Swedish Yankspankers game clan under the name TA Spring. Since 2005 it is being developed by the community. The project aimed originally to bring the gameplay experience of Total Annihilation into three dimensions and to have the game run the mods and third-party units from Total Annihilation. The first release was on July 7, 2007, achieving its initial goals.

Evolution to a general RTS game engine

Since then, the project evolved from a mere TA clone to a general RTS game engine including more flexible features like built-in high-level extensibility through a Lua scripting interface. Most of the games running on the engine (as of December 2010) are focused on multiplayer gameplay. There are also currently a number of single player missions, built on frameworks utilizing the engine's Lua scripting abilities. There are also a large number of skirmish artificial intelligences (AIs), allowing for offline play or extra players in an online game.

Software architecture

Most Spring Engine-based games are designed to be played online, in multiplayer matches. The Spring Engine uses a deterministic game simulation which is executed simultaneously on all game clients. Only user commands are sent to other players, preventing any active cheating. Multiplayer is supported on both Linux and Windows. A pre-game lobby uses a specially designed protocol similar to that of Internet Relay Chat to facilitate chat, player match-making, and the adjustment of battle options. A number of spring lobby clients exist.

The lobbies for the game allow setting up single player games also. This can be done either by using a special single player mode, or using the multiplayer mode with a password and adding bots to the game. Instead of using bots, some games also support special game modes that allow single player gameplay. Most popular in this area are the "chicken" modes of Zero-K and Balanced Annihilation, where a player has to defend against waves of monsters. Since version 0.79, Spring also features missions. A mission editor with advanced functions while being intuitive is bundled with the game.

Skirmish AIs (or bots) are needed to get a normal single player game running. They take over the role of controlling a team and can therefore be seen as a machine equivalent to a human player but are of course less cunning. The engine supports Skirmish AI plug-ins to be written in a variety of programming languages. Currently these are Lua, C, C++, Python and the JVM languages like Java and Groovy. It is also possible to develop plug-ins to support more languages.

Spring's rendering features include deformable terrain, 3D projectiles and multiple water renderers. The unit files of Total Annihilation are compatible, allowing third-party units to be imported. The scripting language allows for a customizable gameplay and user interface modifications. Team Players can also draw and write on the game map to coordinate tactical moves with other players. The third-party AI allows for varying degrees of difficulty. Alternatively, the SpringRTS Lobby can be downloaded at mirrors.

Source code

Spring's source code, licensed under the GNU General Public License, is primarily written in the programming language C++, as is springlobby. An alternative lobby, TASClient, is written in Delphi, and there are lobby servers - used to organize multi-player games - written in Java and Python. The C++ code structure is written in an object-oriented manner and is documented to some extent using Doxygen. The official source code package includes project files for various integrated development environments (IDEs) and building tools, including CMake, KDevelop, Visual C++ 7.0/8.0, and Xcode.

Reception and adoption

Various games leveraging the Spring engine range from free content games with minimal restrictions on use and distribution to games with commercially licensed art, such as P.U.R.E. Additionally, content from Total Annihilation has been modified to run on the Spring Engine, although playing games that incorporate such content requires that one own a copy of the original Total Annihilation game.

Spring has many games in various stages of development. Some are based upon and use content from the original Total Annihilation game, this includes the games: Balanced Annihilation, Tech Annihilation, NOTA, and XTA. However, there are many games which are derivatives of other works of fiction, such as a Gundam game, a Warhammer 40,000 game, and a Star Wars game based on the Galactic Civil War. There are also several fully original games, including "Expand & Exterminate", a strategic game inspired by Earth 2150, "The Cursed", a unique mixture of science fiction and fantasy, and "Kernel Panic", a Darwinia-esque game emphasizing simplicity. The website also distributes tools and instructions for making your own game.

Balanced Annihilation

As the name suggests, the game rebalanced Absolute Annihilation, which was a rebalanced version of the Total Annihilation game Uberhack. The unit stats have been modified from Uberhack's base stats making it very dissimilar to Uberhack. It features all the previous units from retail version of Total Annihilation, plus several extras for each faction. The balance does not reflect Total Annihilation gameplay as much as an augmented version of Total Annihilation. (It is still being maintained)

Zero-K

Zero-K (formerly known as Complete Annihilation) started as a fork of Balanced Annihilation, and so can trace its heritage all the way back to the original Total Annihilation. However, all the original Cavedog content has been replaced with original community-provided content. Among Spring games, Zero-K is notable for its extensive use of Lua scripting for interface and gameplay enhancements, and unique RTS concepts such as a flat technology tree. Zero-K was released on Steam as a standalone game on 27 April 2018.

NOTA

NOTA (Not Original Total Annihilation) is a game designed for larger maps with to-scale units, fuel for airplanes and accent for strategic decisions. It has a unique navy, more diversified unit types, and a slower tech/econ development then other TA themed games (BA, XTA). NOTA games can be very quick, seeing only T1 units, or very long, ending with the appearance of incredible superweapons. (still maintained)

The Cursed

This unique game is about an undead demonic army that corrupts the universe and is opposed by humankind. The artistic setup is inspired by arts from Doom I and II, Warcraft III and Warhammer table tops. The free game is released. (still maintained)

P.U.R.E.

Not to be confused with the ATV game Pure, P.U.R.E. is set in a time when humans are at war against an evil AI called the Overmind. It is developed by one person, known by the Spring community as Argh. The game features up to 57 unique units, new and improved GUI,a unique resource system and 2 different sides, and a main menu (though not in-game). P.U.R.E. is featured in ModDB and several other review sites.

Spring:1944

Spring:1944 is one of the most-developed games on the Spring engine, and as the name suggests is based on the later years of World War II. It contains nearly 300 unique units across the four major belligerent factions (United States, United Kingdom, Nazi Germany and the USSR), with all content being produced by several main developers and a handful of contributors, and is the most popular independent production project on the Spring engine. Unlike most conventional WW2-themed real-time strategy games, Spring: 1944 is heavily "epic" in scope, with players commanding hundreds of units and multiplayer team games involving thousands of infantry, vehicles, tanks and aircraft. (still maintained)

Kernel Panic

Kernel Panic is a game that has no connection to Total Annihilation. In this game, there are three races: The System, the Network and the Hacker, all having their own advantages and disadvantages. The game takes place inside of a computer, leading to intense, fast-paced gameplay. There are no resources in Kernel Panic, so the player can build units until the map is full. The game's textures and sounds resemble old games, and maps are like computer boards and chips. (still maintained)

XTA

Preceding all other active games, XTA, short for eXtended Total Annihilation was the original Total Annihilation based game developed on the Spring Project. It features all units from the retail version of Total Annihilation with a few additional ones added to each faction. Since the original development team there have been various developers of the game, meaning the aim of it may now be skewed, however the game attempts to remain true to its heritage whilst bringing in new game play features. (still maintained)

Evolution RTS

Evolution RTS was the first Spring-based game released (as free to play) on Steam, in April 2014. (still maintained)

Reception

Spring was reviewed in French print computer magazine "Linux Pratique" in February 2009.

📕 Description [fr]

Un moteur de jeux de stratégie en 3D temps réel inspiré de "Total Annihilation" de Cavedog Entertainment, par la Spring Team.

Spring (springrts, ex "Total Annihilation Spring" et "TA Spring") est un moteur de RTS inspiré de Total Annihilation. Par rapport à ce dernier, il est libre, multi-plateforme, offre des graphismes incomparablement plus beaux en vrai 3D temps réel, son code et ses données sont séparés, il permet le jeu solo (avec plusieurs types d'IAs) / multijoueur (LAN/WAN), supporte le matériel moderne ("multi-touch", Mumble, son spatialisé, caméras virtuelles, ...), et il est régulièrement maintenu / amélioré. Les jeux mettent en scène des combats sur terre, air et mer dont le nombre d'unités n'est limité que par la puissance du matériel.

À noter que si le moteur est libre, certains jeux (notamment ceux utilisant les modèles d'unités de Total Annihilation) ne le sont pas (mais restent généralement gratuits).

HISTORIQUE :

Pour mieux comprendre l'écosystème de Spring, un petit retour en arrière :

• Total Annihilation (OTA pour Original Total Annihilation) est un jeu commercial qui avait été développé par le studio Cavedog en 1997. Il a été le premier jeu de stratégie comprenant un terrain et des unités modélisées en 3D (néanmoins le jeu ne l'était pas totalement). Son succès est resté en demi-teinte du fait de la concurrence 6 mois plus tard du jeu StarCraft (de Blizzard).
• Total Annihilation 3D (TA3D) est un projet libre d'amélioration du moteur de Total Annihilation : une vraie 3D avec caméra et perspective, un graphisme amélioré et de nouvelles fonctionnalités, tout en préservant la compatibilité. Son développement est achevé depuis 2011.
• Spring (TA Spring aka SpringRTS) est un autre projet libre (et actif) analogue à Total Annihilation 3D, à la différence que son moteur a été complètement ré-écrit et séparé des données, autorisant la création de nombreux jeux par la communauté. Les premiers jeux utilisaient les données non libres du jeu commercial (Total Annihilation), puis le développement de nouvelles données a permis des jeux totalement libres (voir par exemple le mod Zero-k). Aujourd'hui on trouve pour ce moteur des jeux, des cartes, et des IAs à télécharger.

Quelques exemples des jeux "historiques" de Spring :

• ÜberHack (UH) était une "totale conversion" (mod autonome) pour Total Annihilation (OTA), comportant de nombreuses corrections de bugs et réglages de gameplay. UH ne comprenait que quelques unités.
• Absolute Annihilation (AA) s'est basé sur ÜberHack, il a été porté sous Spring dès la conception de Spring, son développement s'est achevé en 2007. Il en modifie les réglages et lui a ajouté une quantité impressionnante de nouvelles unités (AA comprend 366 unités). Il est classé (comme ÜberHack) dans les jeux "OTA", désignant des jeux au gameplay très proche / fidèle au jeu original (Total Annihilation). Par opposition on trouve des jeux Not OTA (voir NOTA), qui s'en éloignent.
• Balanced Annihilation (BA) a démarré fin 2006 comme fork d'Absolute Annihilation 2.23. Le jeu est très proche d'OTA, le gameplay a été repris ("Balanced"), des unités ont été ajoutées et des paramètres revus pour les unités de base.
• Zero-k (anciennement "Complete Annihilation") a démarré comme fork de Balanced Annihilation. Selon wikipedia, il s'agit d'une modification dont le but avoué est d'obliger les joueurs à s'étendre en supprimant les bâtiments générateurs d'une importante quantité de métal. Autre particularité de taille : l'ensemble des textures et modèles non libres a été remplacé par leurs équivalents libres, le jeu est donc totalement libre, contrairement à d'autres jeux.

Néanmoins la liste est loin d'être exhaustive et bien des jeux originaux ont vu le jour depuis : Spring:1944, The Cursed, Kernel Panic, Conflict Terra, ...

--- Sources : Wikipedia et le Wiki de Spring.

Crédit image: jeu Beyond All Reason.

Voir aussi / See also: Planetary Annihilation, Planetary Annihilation: Titans, Total Annihilation (1997, with Robot War Engine), Spring, Total Annihilation 3D,

Spring est un moteur de RTS 3D polyvalent.
Il utilise une version étendue de Lua pour scripter le code spécifique au jeu permettant de rendre presque tous les aspects du moteur personnalisables, de l'interface utilisateur graphique (GUI), à l'IA, jusqu'au pathfinding (NdT : recherche de chemin pour l'IA et les unités).

Il existe un certain nombre de jeux réalisés pour le moteur Spring.

Spring est un moteur ! Il peut jouer de nombreux jeux et cartes différentes. Pour jouer, vous avez besoin d'au moins un Jeu (Game) et d'une Carte (Map) !

Caractéristiques

• De nombreux jeux différents, conçus spécialement pour Spring.
• Jouez en ligne, sur un réseau local ou en mode solo hors ligne.
• De grandes batailles limitées uniquement par la puissance de votre ordinateur ; supporte jusqu'à 5000 unités.
• De grandes cartes très détaillées sur lesquelles mener ces batailles, entièrement en 3D avec un terrain déformable, des feux de forêt, de l'eau dynamique et réfléchissante, et des skyboxes personnalisées.
• Plusieurs modes de caméra, permettant de voir n'importe quoi sous n'importe quel angle.
• Des combats entièrement en 3D sur terre, sur mer et dans les airs, avec des trajectoires d'armes réalistes (moteur physique).
• Des IA tierces complexes, dont certaines sont très bonnes.
• Une interface utilisateur extrêmement puissante, conçue pour minimiser la micro-gestion inutile.
• Rendu des polices Utf8
• Ajouts, et corrections de bogues fréquents.

🍥️ Debian:

Un moteur de RTS en vrai 3D, moderne

Spring est un moteur de RTS (Real Time Strategy) en vrai 3D et moderne, entièrement conçu pour créer l'expérience du gameplay de Total Annihilation en 3D. Les jeux sont joués en utilisant l'un des nombreux mods.

Ce paquet inclut simplement le moteur de jeu et l'IA par défaut, sans cartes, mods ou interface utilisateur riche.

🌍️ Wikipedia:

Spring, anciennement dénommé Total Annihilation Spring puis TA Spring, est un moteur de jeu de stratégie en temps réel open-source sous licence GPL, principalement multijoueur, en Réseau local et sur Internet. Il fonctionne sous Windows, Linux et OS X. Le moteur est à l’origine inspiré par la série de jeu Total Annihilation réalisée par Chris Taylor pour le studio Cavedog.

Description

TA Spring émule et accroît les caractéristiques de base de Total Annihilation : gestion de la production de métal et d'énergie, création de mines d'extraction de métaux, de génératrices, éolienne, marémotrice, géothermie, usines de production d'unités, station de ravitaillement d'avions, et surtout la résurrection ou le recyclage des épaves et des arbres et débris.

• Terrestres (Constructeurs, Chars et Infanteries ou Kbots, Rapides, Antiaériens, Roquettes, Balistiques, Blindés, Artillerie, Amphibies, Kamikazes, Poseurs de mines, Radars et Brouilleurs de Radars…).
• Aériennes (ADAV) (Constructeurs, Reconnaissance, Chasseurs, Bombardiers, Torpilleurs, Helicos, Transports, Awacs…).
• Maritimes (Constructeurs, Vedettes, Destroyers, Croiseurs, Cuirassés, Sous-marins, Antiaériens, Transbordeurs, Navire Radar réparateur d'aéronefs, brouilleur radar…).
• Aéroglisseurs (Constructeurs, Éclaireurs, Antiaériens, Blindés, Balistiques, Roquettes, Transbordeurs).
• Sous-marines.

Le jeu commence avec l'unité principale ou commandeur, fabriquant usines, génératrices, mines et défenses de base.

Les constructeurs issus des usines de base permettant de construire des défenses basiques et des usines de construction évoluées.

Les constructeurs évolués permettant à leur tour d'élever des positions défensives plus coûteuses et destructrices.

Les épaves des véhicules détruits dans le feu de la bataille peuvent soit servir d'obstacle, soit être recyclées, soit être réparées à l'aide de véhicules appropriés.

La version originale du jeu, Total Annihilation, fut l'une des premières avec unités en complète 3D et une gestion des projectiles en temps réel; mais le terrain était encore en 2D et l'angle de vue restait donc fixe en vue isométrique. Sur Spring, il est possible de zoomer sur le champ de bataille, faire pivoter et incliner l'angle de vue ou prendre le contrôle direct des unités en vue subjective.

Autres différences essentielles avec le premier du nom :

• Le relief est maintenant affecté par les explosions et influe sur le champ visuel comme sur la portée radar. Les déformation du terrain ne se font que sur un plan vertical mais avec un effet des plus réalistes : pour exemple une explosion crée un trou en repoussant le sol sur les côtés et lors de l'édification d'un bâtiment, le constructeur commence par aplatir la surface.
• La portée des extracteurs de métaux, la puissance des vents et la force gravitationnelle varient selon les cartes.
• Toute unité peut recevoir des ordres avant la fin de sa construction.
• Une IA peut aider à la gestion des convertisseurs de métaux.
• Une autre IA peut faire mettre à jour par un constructeur les extracteurs de métal niveau 1 vers du niveau 2, dans certains modes la transition est semblable à celle présentée sur Supreme Commander le dernier RTS de Chris Taylor, initialisant celle-ci en cliquant simplement sur la commande Morph pour faire évoluer les unités au niveau de technologie supérieur.
• Chaque partie est sauvegardée et peut être revisionnée plus tard seul ou avec d'autre joueurs (utile pour faire un débriefing et identifier ses propres points faibles comme ceux des autres participants).
• Un bouton "Repeat" permet aux usines, par exemple, de construire à l'infini une séquence d'unités.
• le wiki du logiciel [archive] a été amélioré, il devient possible de créer son propre jeux avec des règles différentes, à condition cependant que l'on veuille un terrain en height map/topographie sans ponts ni tunnels. Sont nécessaires alors seulement un éditeur de texte, un logiciel de dessin assisté par ordinateur pour la 2D et pour la 3D, afin de créer véhicules, cartes et scripts LUA.

Droits d'auteurs

Les auteurs du moteur n'ont pas demandé de licence qui serait nécessaire, dans la plupart des pays, en fonction des systèmes de propriété intellectuelle (images, logo, marque...). Les droits du jeu originel, encore en vente, sont la propriété d'Atari, qui n'a réalisé aucune action pour défendre ou à l'inverse abandonner ses droits, le plaçant dans une situation incertaine de logiciel abandonné, et le développement, la copie, la distribution de Spring pourraient être illégaux dans de nombreux pays.

Jeux réalisés

Si à l'origine la reprise de Total Annihilation était le principal objectif, le moteur a permis la réalisation de quelques jeux additionnels.

Certains de ces jeux sont de simples évolutions de T.A., parmi elles :

• BA : Balanced Annihilation Modification cherchant à reprendre le jeu original en "l'améliorant". Donc très proche du jeu original, avec cependant des unités ajoutées et des paramètres revus pour les unités de base. Le résultat est que la plupart des unités (y compris bâtiments) sont à présent utilisables, y compris les plus décriés, comme le sumo, l'artillerie mobile, la tourelle laser légère ou les scouts. Un inconvénient est que le "rush" ne pardonne absolument plus et qu'il n'y a plus guère le choix pour commencer une partie : ou on suit la "bonne recette", ou on se retrouve éliminé du jeu en moins de deux minutes.

• OTA : Original Total Annihilation: Gameplay du jeu original.

• CA : Complete Annihilation : Modification dont le but avoué est d'obliger les joueurs à s'étendre en supprimant les bâtiments générateur d'une important quantité de métal (tout ce qui est "moho"). Les "mohos" sont remplacés par le fait que l'énergie en « surplus » est automatiquement absorbée par les extracteurs de métal qui voient leur production légèrement augmenter. Ce mode interdit évidemment toutes les stratégies d'extension lente (déjà difficiles à mettre en œuvre dans le jeu originel): Plus encore que dans Total Annihilation, celui qui possède le plus grand territoire est en général celui qui gagne.

D'autres font varier les unités, règles, univers. Parmi eux :

• Kernel Panic : à l'intérieur d'un ordinateur

• Evolution RTS et Zero-K : similaire a T.A.

• A&A (Axis & Allies renommé Spring: 1944) en honneur à l'Opération Spring, ayant eu lieu pendant la bataille de Normandie, durant la Seconde Guerre mondiale. Elle permet de confronter de manière réaliste les armées des nations allemande, américaine, britannique et russe en mettant en accentuant l'importance de la logistique. Contrairement aux autres modes de Spring, de nombreux éléments s'appuient sur des caractéristiques techniques bien réelles telles que la vitesse de déplacement des unités, de rechargement et de rotation de leur tourelle, leur puissance d'armement, leur porté de tir, leur porté visuelle, leur distance maximale de furtivité, le "facing" de leurs blindages, la quantité individuelle de munitions, l'autonomie opérationnelle et surtout la nécessité de maintenir son soutien logistique pour améliorer la cadence de tir et refaire le plein de munitions, ce qui rend prioritaire la destruction de la logistique adverse.

Il y est aussi possible désormais de capturer les fantassins adverses, en plus des drapeaux disséminés sur la carte capturables eux uniquement par les fantassins (ou par un commissaire du peuple pour les troupes soviétiques), pour augmenter la vitesse de régénération des points de commandement permettant de fabriquer de nouveaux bâtiments et unités et d'enrôler de nouvelles troupes. L'autre ressource, les munitions, se régénèrent pour tous les joueurs selon un rythme régulier prédéfinie à l'avance par l'hôte de la partie, leur quantité dépend uniquement du nombre de dépôts de munitions disponibles. Une fois les munitions épuisées, les unités utilisant des obus, tels les canons, les obusiers, les chars, les bombardiers et les navires d'appui feu, ne peuvent plus tirer et doivent se rendre dans une zone de ravitaillement pour compléter leur soute à munitions, dans la mesure où la quantité disponible est suffisante.

• The Cursed : mélange de fantasy et de science-fiction

Les scripts

Spring utilise un langage de script basé sur Lua qui permet l'amélioration des graphismes, à la création d'IA, en passant par la modification de l'interface.

Un exemple des scripts inclus dans Spring :

• XRay Shader affecte aux arêtes des polygones des unités et bâtiments la couleur de leur propriétaire ce qui permet de faciliter la reconnaissances des différentes joueurs en plus de donner un aspect néon/futuriste rappelant le film Tron.
• Metal Maker active et désactive les convertisseurs d'énergie en métal en fonction des besoins du joueur et de son niveau d'énergie.

🚧️ Installation [fr]

🔧️ INSTALLATION:

💡 Nota:
• Pour jouer il est nécessaire d'installer le moteur Spring puis de télécharger et d'installer des jeux et des cartes sur des sites externes car le site du moteur ne livre pas de données (voir plus bas).
• La grande majorité des données très volumineuses (plusieurs Go) de Spring ne peuvent s'installer que dans le répertoire HOME. Un répertoire HOME > 20Go (ou pas de partition spécifique) est recommandé.
• Les fichiers cartes et les fichiers de jeux sont des conteneurs au format ZIP (format .sdz) ou 7z (format .sd7)
• La quasi totalité des cartes sont compatibles avec tous les jeux et toutes les versions de moteurs, ce qui n'est pas le cas des IAs qu'il vous faudra tester une à une (certaines peuvent planter le jeu) ou consulter la fiche correspondante du Bottin et/ou la section dédiée sur le WIKI de Spring.

⚙️ Installation à partir du binaire du jeu :

(✔ v. 104.0+dfsg-3+b2) ▸ Fonctionnement classique (avec la dernière version du moteur, cas courant) :
Le jeu est en dépôt, il suffit d'installer le paquet.

(✔ v. 104.0) ▸ Fonctionnement alternatif (tests avec plusieurs versions du moteur Spring) :
Spring est un projet vivant, et donc il évolue assez rapidement.
Ceci pose assez souvent des soucis de compatibilité avec les jeux qui évoluent à des vitesses différentes et sont en général conçus et testés pour d'anciennes versions de Spring.
D'où l'énorme intérêt du dépôt de versions antérieures statiques de Spring sur SourceForge (voir ci-après)

Si vous constatez qu'avec la dernière version de Spring, aucune IA ne fonctionne et/ou que votre robot / unité n'apparaît pas ou que vous ne pouvez bouger vos unités :
• Essayez de simplifier le contenu de son fichier de configuration (~/.config/spring/springsettings.cfg). Si vous ne savez pas quoi faire, renommez-le (il en recréera un autre au prochain lancement).
• Téléchargez sur SourceForge (lien à la section "Resources" ci-dessus, voir "Misc. versions of Spring") une ou plusieurs versions statiques antérieures à votre version actuelle de Spring. Par exemple, la version 104.0 en 64 bits (une version 32 bits est également disponible) s'appelle : spring_104.0_minimal-portable-linux64-static.7z
• Décompressez-la.
• Dans le répertoire obtenu, cliquez directement sur le binaire "spring". Après plusieurs dizaines de secondes (le temps d'analyser vos jeux et cartes) l'écran noir fera place à l'écran d'accueil de Spring (la version est affiché en bas de l'écran).

(✘ v. 104.0.1)📄️ Installation à partir du source du jeu :

Il est peu utile de compiler Spring car, d'une part il est dans les dépôts Debian (et les versions disponibles sont récentes), et d'autre part il est également disponible en différentes versions binaires statiques (32bit et 64bit).

▸ Installation des dépendances :
• Installez les bibliothèques SDL (voir la fiche "006 - Glossaire & licences courantes" du Bottin).
• Installez au préalable les paquets suivants (conforme au WIKI Spring): # apt install cmake build-essential zip zlib1g-dev libglew-dev libopenal-dev libogg-dev libvorbis-dev libdevil-dev libfreetype6-dev libfontconfig1-dev libboost-all-dev libglew-dev libunwind-dev libxcursor-dev default-jdk xsltproc libcurl4-openssl-dev
• Installez au préalable les paquets suivants (REX de ma compilation de Spring): # apt install libminizip-dev

(Ne semble plus nécessaire : libcurl4-gnutls-dev asciidoc libjava3d-java openjdk-12-source libjsoncpp-dev clang-format p7zip-full )

💡 Nota: si l'une des bibliothèques citées ci-dessus n'est plus disponible en dépôt dans la version indiquée (exemple : openjdk-12-source) n'hésitez pas à en prendre une autre plus récente.

▸ Téléchargement du source (sur GitHub):
Le source nécessite un certain nombre de dépendances internes au projet et non délivrées par défaut.
Le téléchargement (en HTTP) de la version sous forme de container zip ou tar.gz ne suffit pas.
Il est donc nécessaire de télécharger le source via git (procédure décrite ci-après).

• Si vous souhaitez une version publiée / stable : en console : $ git clone -b "Nom_de_la_release" --recursive https://github.com/spring/spring
Nom_de_la_release : à remplacer par le nom d'une release valide indiquée sur la page de développement (sur GitHub, dans la section Release, le nom valide est l'étiquette située à gauche du titre, ou cliquez sur "Tags" pour obtenir la liste des étiquettes valides).
• Si vous souhaitez obtenir la version la plus récente (de développement, non stable, potentiellement non fonctionnelle), dans le répertoire de votre choix, lancez : $ git clone --recursive https://github.com/spring/spring

▸ Compilation du jeu :
• Dans son répertoire racine lancez successivement :

⚬ Si vous souhaitez l'installer dans votre HOME : $ cmake -DCMAKE_INSTALL_PREFIX=~/spring .
⚬ Si vous souhaitez l'installer dans les répertoires /usr/local/bin/spring (pour l'exécutable spring) et /usr/local/share/games/spring (pour les données) (il vous faudra ensuite lancer le # make install): $ cmake .
(n'oubliez pas le ".")
$ make
(ou, pour accélérer la compilation, "$ make -j8" si vous disposez d'un processeur 8 threads, à adapter pour vous)
↪ vous obtenez le binaire : spring

▸ Installation dans les répertoires du système :
Éventuellement (si vous souhaitez le ranger dans les répertoires habituels, car le jeu fonctionne bien dans son répertoire de compilation):
# make install
(Cette dernière commande est à lancer avec les droits de l'utilisateur root).

Si plus tard vous souhaitez désinstaller (si c'est prévu par l'auteur :)):
# make uninstall

➥ Installation des jeux :

▸ Initialisation des répertoires d'installation
Pour la première installation, il est nécessaire d'initialiser 2 répertoires.

Créez les répertoires :
~./config/spring/maps/ dans lequel vous copierez ultérieurement les cartes téléchargées (voir plus bas)
~./config/spring/games/ dans lequel vous copierez ultérieurement les jeux téléchargés (pour les anciens joueurs, notez que ce répertoire se dénommait autrefois mods/)

Installez le pack "Spring Features" :
Il s'agit d'un pack de données communes à plusieurs cartes, permettant de diminuer la taille des livrables.
Téléchargez ce pack (voir le lien "Spring Features Pack" dans la section "Resources" ci-dessus, le fichier se dénomme "spring_features-v01.sdz") et copiez-le dans le répertoire des jeux (~./config/spring/games/) avant tout lancement (certains jeux tel que Evolution RTS plantent si ce pack n'est pas trouvé au démarrage).

▸ Téléchargement et installation des données
Spring dispose d'un grand nombre de ressources (jeux et cartes).
Un échantillon de jeux disponibles est décrit dans le Bottin sous forme de fiches du type "Spring - Nom_du_Jeu".
Les jeux sont livrés sans cartes. Celles-ci étant compatibles avec à peu près tous les jeux, c'est à vous d'assurer la cohérence de l'ensemble (une carte spatiale n'est pas forcément adaptée à un jeu dont les unités sont de la guerre 1939-45, mais elle fonctionnera quand même :)
Ces ressources sont regroupées et classées (pour les cartes) sur la fiche "Spring - Ressources" (dans le Bottin).

Deux méthodes sont disponibles pour accéder à ces ressources.

• Méthode n°1 : Installation automatisée des jeux et contenus via des lobbys, et lancement de parties multijoueur :
Un client lobby est une interface indispensable pour les parties multijoueur en LAN/WAN, permettant la recherche de serveurs spécialisés et prenant en charge le téléchargement automatisé des ressources nécessaires (cartes et jeux), la configuration et le lancement des parties.

On peut aussi l'utiliser pour le jeu en local pour ses atouts dans la simplification de l'installation du contenu.
Néanmoins pour le jeu en local je lui préfère l'installation manuelle (d'autant que mon expérience avec 2 lobbys n'a pas été très concluante). Notamment les lobbys ne gèrent pas certains cas particuliers (tels que les problèmes d'incompatibilité éventuelle entre jeux et versions de moteurs de Spring).

• Méthode n°2 : Téléchargement et copie manuelle des cartes et Jeux
Cette méthode a ma préférence pour le jeu en solo. Bien que demandant davantage d'opérations, elle permet une meilleur maîtrise de ce qui est fait, une optimisation de l'espace disque (certains jeux prennent beaucoup d'espace sur votre HOME) et prend en compte les incompatibilités éventuelles entre versions de moteurs et de jeux.

Sur les sites dédiés (voir ci-après) téléchargez :
• les cartes et copiez-les dans ~./config/spring/maps/
• les jeux et copiez-les dans ~./config/spring/games/

Dans le Bottin :
• Les fiches "Spring - Nom_du_Jeu" vous présentent un échantillon des jeux disponibles. Consultez leur rubrique "Installation" : elle précise éventuellement certaines procédures spécifiques.
• La fiche "Spring - Ressources" vous propose un bon échantillon de cartes classées par thèmes mais aussi des liens vers d'autres cartes et d'autres jeux non listés dans le Bottin.

That's All Folks :)

(✔ v. b406b20 du 31.03.2019) ➥ Optionnel : Installation et utilisation de Rapid (aka pr-downloader) :
Rapid est un outil permettant de télécharger rapidement du contenu (des jeux et des cartes, mais je n'y ai vu que des jeux) pour le moteur Spring par des commandes en console. Il est ensuite possible d'y jouer directement sans autre intervention (Spring sait les trouver).
Inconvénient (majeur pour moi): il semble difficile de récupérer ces jeux pour les archiver (et y rejouer ultérieurement) car il dissémine les jeux en de multiples fichiers dans un répertoire pool/ (voir plus bas).

Installation à partir du binaire de l'utilitaire :
Il est livré avec le paquet Spring en dépôt Debian, donc lorsque vous installez le paquet Spring, Rapid (aka pr-downloader) est installé.

Installation à partir du source de l'utilitaire :
Il n'est pas nécessaire de compiler son source dans la mesure où il est livré avec le paquet Debian de Spring.
Néanmoins si vous souhaitez le compiler :
▸ Installation des dépendances
• Installez au préalable les paquets suivants : # apt install liblua5.1-0-dev libzip-dev zlib1g-dev cmake libssl-dev clang-format libjsoncpp-dev libboost-all-dev

▸ Téléchargement du source (sur GitHub):
• Si vous souhaitez une version publiée / stable :
- En console : $ git clone -b "Nom_de_la_release" --recursive https://github.com/spring/pr-downloader
Nom_de_la_release : à remplacer par le nom d'une release valide indiquée sur la page de développement (sur GitHub, dans la section Release, le nom valide est l'étiquette située à gauche du titre, ou cliquez sur "Tags" pour obtenir la liste des étiquettes valides).
• Si vous souhaitez obtenir la version la plus récente (de développement, non stable, potentiellement non fonctionnelle), dans le répertoire de votre choix, lancez : $ git clone --recursive https://github.com/spring/pr-downloader

▸ Compilation de l'utilitaire :
• Dans son répertoire racine lancez successivement :
$ cmake .
(n'oubliez pas le ".")
$ make
(ou, pour accélérer la compilation, "$ make -j8" si vous disposez d'un processeur 8 threads, à adapter pour vous)
↪ vous obtenez le binaire : src/pr-downloader

▸ Utilisation de Rapid :
Reportez- vous à la liste [Spring WIKI (Rapid Tags)] pour connaître la liste du contenu disponible.
Ensuite :
• Pour voir la liste des commandes disponibles :
- Si vous souhaitez utiliser la version du paquet Spring : $ /usr/games/pr-downloader
- Si vous souhaitez utilise votre version compilée, placez-vous à la racine du source et lancez : $ src/pr-downloader
• Si vous souhaitez télécharger un jeu :
- Si vous souhaitez utiliser la version du paquet Spring : $ /usr/games/pr-downloader --download-game tag_du_jeu
- Si vous souhaitez utiliser votre version compilée, placez-vous à la racine du source et lancez : $ src/pr-downloader --download-game tag_du_jeu
(exemple : src/pr-downloader --download-game bar:test pour le jeu "Balanced Annihilation Reloaded ")

💡 Nota:
Les répertoires de Rapid se trouvent dans ~/.spring/rapid/ et visiblement il utilise ~/.spring/pool/ pour stocker les jeux disséminés sur plus de 18000 fichiers et répertoires, impossible de les récupérer ensuite. Spring sait ensuite les lire, mais si vous voulez récupérer les jeux pour y jouer ultérieurement, il ne me semble pas être le bon outil (il vaut mieux télécharger manuellement les jeux au format sdz).

--------------------------------------------------------------------------------------------------------------------
• (Paragraphe optionnel et obsolète, conservé pour une utilisation ultérieure éventuelle) Pack de base sur le site JeuxLinux
Vous pouvez aussi télécharger sur le site JeuxLinux (cliquez sur le lien "[FTP JeuxLinux (Pack de données de base)]" ci-dessus) le fichier "spring_data_pack.tar.gz" (270Mo), contenant quelques jeux et cartes pour démarrer simplement (utile pour les débutants).
⚠ Néanmoins ce pack datant un peu, après décompression il vous faudra renommer le répertoire "mods" en "games"
Puis :
• copiez le contenu de ce répertoire games/ (2 modes de base : Balanced Annihilation en version 6.0 et XTA en version 9.3) dans le répertoire ~./config/spring/games/
• copiez le contenu de son répertoire maps/ (15 cartes) dans ~./config/spring/maps/
• copiez le contenu de son répertoire base/ (il s'agit de quelques fichiers de textures utilisées par certaines versions de ces anciens mods) dans ~./config/spring/
(Remarquez que vous pouvez télécharger d'autres versions des jeux ci-dessus sur SpringFiles qui ne nécessitent pas la présence de ces textures).

Éventuellement le fichier "base-ota-content.zip" que vous décompressez dans votre répertoire "~./config/spring/base/" (à créer s'il n'existe pas) si vous utilisez certains mods qui réclament le fichier "otacontent.sdz".
--------------------------------------------------------------------------------------------------------------------

🚀️ LANCEMENT DU JEU:

Plusieurs versions statiques du moteur de Spring peuvent coexister avec la dernière version des dépôts (c'est un gros point positif), les différentes versions partageant les mêmes répertoires de données.

• Si vous avez installé le jeu à partir d'un paquet : Alt F2 puis saisissez : spring
• Si vous avez installé le jeu à partir d'un binaire statique, cliquez simplement sur le binaire correspondant (le binaire doit avoir été rendu exécutable pour que cela fonctionne).

💡 Nota :
• Lors d'un premier démarrage d'un moteur, l'écran d'accueil ne s'affiche qu'après 30 secondes à 1 minute d'un écran noir
• Pour jouer en multi-joueur, ouvrez le port UDP 8452

Enjoy :).

LES PREMIERS PAS :

▸ Premiers tests :
• Ne vous lancez pas dans de grandes constructions sans avoir testé un peu le jeu au préalable (voir ci-après).

• choisissez de petites cartes (votre robot sera plus facile à retrouver)
• vérifiez les messages affichés au démarrage (ils peuvent indiquer que quelque-chose n'a pas fonctionné)
• vérifiez que vous trouvez votre robot.
• vérifiez que vous trouvez celui de l'IA. Les cas d'incompatibilité entre jeu, IA (communes à tous les jeux) et cartes ne sont pas rares. Si l'IA (un script Lua) plante, votre robot peut ne pas apparaître (observez les messages affichés au démarrage du jeu, c'est une bonne indication)

▸ Multijoueur via un lobby :
Plusieurs lobbys sont disponibles, facilitant l'installation des mods, cartes et surtout le jeu en multijoueur.
Ils fonctionnent certainement bien. Personnellement je n'ai pas réussi à les faire fonctionner correctement, et comme je préfère le jeu en solo, je n'ai pas approfondi, raison pour laquelle je ne fais que survoler le sujet.

▸ Lancement d'un jeu en solo :
• lancez "$ spring" (mode plein écran) ou "$ spring -w" (si vous souhaitez le mode fenêtré, mais à présent même en configuration Dual Screen le plein écran fonctionne bien),
• en bas et à droite de l'interface, cliquez sur le 1er bouton "Select" (bouton du haut), une fenêtre "Select mod" vous invite à sélectionner un mod, exemple "XTA v9.3 9.2", cliquez sur le bouton "Select",
• en bas et à droite de l'interface, cliquez sur le 2ème bouton "Select" (bouton central), une fenêtre "Select map" vous invite à sélectionner une carte exemple 'DeltaSiegeX.smf', cliquez sur le bouton 'Select',
• en bas et à droite de l'interface, cliquez sur le 3ème bouton "Select" (bouton du bas), une fenêtre "Select script" vous invite à sélectionner une IA (dénommée 'script') exemple "Skirmish AI test: KAIK 0.13", cliquez sur le bouton "Select",
• lancez le jeu en cliquant sur le bouton "Test the Game",
• patientez quelques secondes jusqu'à ce que votre robot apparaisse. Sélectionnez-le du clic gauche, puis d'un clic droit sur un point de la carte vous lui donnez un point où il doit se rendre. Sélectionnez dans la zone de gauche un bâtiment à construire, un clic gauche sur la carte et il le construit. A ce stade vous n'êtes pas seul sur la carte, votre adversaire (une IA) se trouve masquée quelques part et se prépare (en principe :)) déjà au combat :).

Attention, vous devez gérer à la fois votre approvisionnement :
• en Métal (barre-graphe en haut à gauche de l'interface), disponible dans des mines à ciel ouvert, pour l'extraire vous devez installer à minima sur l'une de ces mines un bâtiment dénommé "Metal extractor" (certains jeux proposent en complément un bâtiment permettant de convertir de l'énergie en métal),
• en Énergie (barre-graphe en haut à droite de l'interface), pour extraire de l'énergie vous devez installer à l'endroit qu'il vous convient une centrale solaire, une éolienne, ...
La suite on vous laisse la découvrir ;) ...

POUR LE HACKEUR QUI SOMMEIL EN VOUS :

▸ Paramétrage graphique de spring :
Voir: [Spring (Springsettings.cfg)]

• Versions du moteur Spring > 99.0
Le fichier de configuration est à présent : ~/.config/spring/springsettings.cfg
(vide par défaut)

💡 Nota :
⚬ Si Spring ne trouve pas le fichier springsettings.cfg, il le créé dans le répertoire où se trouve le binaire depuis lequel il a été lancé.
⚬ Un mauvais paramétrage de springsettings.cfg peut conduire à ce que toutes les unités soient bloquées (expérience vécue, le jeu démarre mais il n'est pas possible de bouger ses unités), mais pas de souci, il suffit d'enlever les paramètres ou d'effacer le fichier pour revenir à une situation normale et reprendre le paramétrage.

Voilà ce qu'il y a dans le mien à présent (pour la copie d'écran de la fiche Spring:1944, en fenêtré) :
AdvSky = true
AllowDeferredMapRendering = true
AllowDeferredModelBufferClear = true
AllowDeferredModelRendering = true
BumpWaterBlurReflection = true
DynamicSky = true
Fullscreen = false
GroundDetail = 100
GroundNormalTextureHighPrecision = true
InputTextGeo = 0.26 0.73 0.02 0.028
LastSelectedMap = MiniTabula-beta
LastSelectedMod = Spring: 1944 Operation Fruehlingserwachen 3.0
LastSelectedScript = Player Only: Testing Sandbox
LastSelectedSetting = Fullscreen
MSAALevel = 3
Shadows = 1
UnitIconDist = 250
Water = 3
WindowPosY = 484
XResolutionWindowed = 1096
YResolutionWindowed = 801

Attention : il y a quelques options gourmandes en ressources. Ne vous lancez pas dans ces paramétrages avant d'avoir testé le jeu sans ces paramètres, ainsi vous pourrez valider le fait que le jeu fonctionne. Ensuite testez quelques paramètres.

• Versions du moteur Spring antérieures à la 95.0 :
Avant de commencer à bidouiller les paramétrages de spring, nous vous suggérons fortement d'effectuer une copie du fichier "~.springrc". Il contient les paramètres actuels de lancement (graphisme & son) . Au pire si vos bidouillages plantent spring, vous avez aussi la solution d'effacer ce fichier mais vous perdrez vos paramètres spécifiques précédents que vous devrez à nouveau saisir au prochain démarrage.
L'accès s'effectue en lançant "$ spring" puis sur la page d'accueil vous cliquez sur le bouton "Start SpringSettings", celle-ci laisse la place à l'interface de paramétrage.
Évitez de trop jouer avec l'option "Full-scene anti-aliasing samples" qui mettra facilement à genoux (au delà de 2 ou 3) votre processeur multi-cœurs :)).

💡 Nota: j'ai remarqué (à la rédaction initiale de ces lignes; Le problème a peut-être été réglé depuis) qu'après un certain nombre de bidouillages graphique, le jeu devenait très lent mais qu'il suffisait de relancer le gestionnaire de fenêtre pour retrouver un fonctionnement normal (plantage de l'accélération ?).

ASTUCES EN VRAC :

• IA non adaptée au jeu en cours :
Si au cours du jeu vous voyez des messages du type "LuaUI is not loaded", inutile de poursuivre, vous jouez seul. L'IA que vous avez sélectionné n'est pas adaptée au jeu sélectionné (on ne peux pas mettre n'importe qu'elle IA avec n'importe quel type de jeu). Tentez une autre IA ou jouez en multijoueur en ligne.

• Niveau de vos adversaires informatiques (IA) :
A titre indicatif, voir la liste des principales IA et le tableau comparatif de leur fonctionnalités (liens dans la section "Technical informations" ci-dessus).
J'ai réalisé une batterie de tests d'IA : voir les fiches de jeux Spring du Bottin.
Si vous tenez à souffrir, choisissez (si tant est qu'elle fonctionne) une IA telle que "Skirmish AI: E323AI 3.22.3", "Skirmish AI test : RAI 0.601", "CppTestAI", "C.R.A.I.G." ou "Spammer" (les + fortes)
Si vous voulez vous faire la main sans vous faire immédiatement réduire en cendres, prenez une IA telle que : "Skirmish AI test : NullAI 0.1", "Skirmish AI test : AAI 0.9", "Skirmish AI test : CppTestAI 0.1", ...

• Affichages bizarres :
Il arrive qu'au lancement de Spring, le menu de démarrage soit illisible (les caractères sont remplacés par des motifs bizarres). Ce petit bogue (certes un peu gênant) se résout simplement en redémarrant (inutile d'aller trifouiller dans votre fichier de configuration :).

UTILITAIRES :

• Les Lobbys :
J'ai testé 2 lobbys (SpringLobby et celui fourni avec le jeu Evolution RTS) et ne suis pas parvenu à les faire fonctionner correctement, mais ne doute pas de leur intérêt.
Voir dans le Bottin : Spring Lobby for NOTA (not just only), Spring Web Lobby, SpringLobby

⌨️🖱️🎮️ CONTRÔLES :

• Pour quitter le jeu, appuyez sur Shift Esc (ou Esc, puis sélectionnez "Exit to Lobby", même si vous ne l'utilisez pas).
• Pour mettre le jeu en Pause et ainsi vous permettre d'examiner tranquillement les menus et les unités, appuyez sur Esc (vous aurez toujours accès aux menus mais l'IA ne continuera pas à construire et à prendre une avancez précieuse sur vous).
• La molette de la souris permet le zoom, le maintien de l'appui sur la touche Ctrl + la molette de la souris permet de changer l'angle vertical de la caméra.
• Le zoom éloigné se révèle également très utile pour différencier rapidement les unités et commander les mouvements de troupes par type d'unités.
• Les touches +/- (ou Alt +/-, pas activé dans tous les jeux Spring) permettent d'augmenter / diminuer le temps relatif du jeu.

ASTUCE: Pour trouver votre robot sur la carte, faites un Ctrl A (ce qui sélectionne toutes vos unités): votre robot sera alors sélectionné (le rendant plus visible et vous pourrez lui demander de se déplacer à un endroit donné) et le menu de contrôle de votre robot s'affichera.

Voir les liens ci-dessus : "Spring (Keyboard)" et "(Layout Image)".

Combinaisons particulières :

• Ctrl + Roulette de souris (merci à Louis qui – comme d'habitude – est le grand explorateur des jeux du Bottin ;): orientation de la caméra de visualisation (au démarrage la vue par défaut est une vue du dessus).
Le choix du mode de caméras s'effectue dans le menu de démarrage de Spring>Start SpringSettings>Mode Expert>UI options>"Default Camera Mode". Pour débuter prenez le mode Overhead qui est le plus intuitif.
Une fois bien rodé, vous pouvez tenter le mode "Rotatable overhead" qui est assez déroutant (voir pénible) mais permet de nombreuses prises de vues différentes.
Voir la description des types de caméras (lien ci-dessus).

• Pour sélectionner un type d'unité particulier au sein d'un groupe : sélectionnez toutes vos unités ce qui affiche les icônes de chaque type d'unité disponible, il suffit ensuite de cliquer sur cet icône pour ne sélectionner que ce type d'unité. Merci à Louis.

• Pour demander à vos unités d'effectuer un certain parcours ou une certaine trajectoire, sélectionnez-les, puis tout en maintenant le clic droit enfoncé, sélectionnez leur trajectoire sur le terrain.
Certains mods ne permettent qu'une trajectoire rectiligne, dans ce cas une seule grosse flèche droite apparaît. D'autres mods permettent de dessiner la trajectoire ce qui est nettement plus pratique et plus précis. Merci à Louis.

• Pour piloter un avion/hélicoptère (en vue cockpit), sélectionnez l'avion et appuyez sur la touche "C" : l'avion se pilote avec les touches fléchées et le tir s'effectue avec le clic gauche de la souris.

🔍️ Test [fr]

🕵️ Test (104.0) par goupildb (config. : Debian Sid 64-bit):

🎯️ Objectif de ce test: rédiger/mettre à jour/valider sa notice d'installation, tester son fonctionnement et partager mes premières impressions.

Configuration utilisée:
Debian Sid 64-bit
CPU : Intel Core I7
Carte graphique : ~~GeForce GTX 275~~ GeForce GTX 260
RAM : 6Go
Joystick : Logitech Rumblepad (2 pads analogiques et un pad numérique, plus vibration avec certains jeux).

👎️🕹️ Facilité d'installation

Différentes alternatives sont disponibles :
(✔ v. 104.0+dfsg-3+b2) • Le jeu est en dépôt, il suffit d'installer le paquet. Le jeu démarre et est même plus rapide à démarrer que la version statique, mais je ne suis pas parvenu à jouer. Au mieux le jeu démarre mais les unités restent figéées, impossible de les déplacer.
(✔ v. 104.0) • Un binaire statique est disponible, il suffisait de le décompresser, et de cliquer sur son exécutable. Il met près d'1 min à démarrer après un écran noir, ensuite il fonctionne bien.
(✘ v. 104.0.1) • Compiler son source
La compilation est assez longue, et le résultat n'est pas garantie.

Avec cette version 104.0.1, la compilation se termine sur ma Debian en :
(...)
[ 33%] Built target sound
[ 33%] Built target engineaGui
[ 33%] Building CXX object rts/builds/legacy/CMakeFiles/engine-legacy.dir/__/__/Rendering/GL/myGL.cpp.o
/mnt/DDprc/Download/spring/rts/Rendering/GL/myGL.cpp: In function ‘bool GetVideoMemInfoMESA(GLint*)’:
/mnt/DDprc/Download/spring/rts/Rendering/GL/myGL.cpp:149:49: error: a reinterpret_cast is not a constant expression
static constexpr const GLubyte* qcriProcName = (const GLubyte*) "glXQueryCurrentRendererIntegerMESA";
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
make[3]: *** [rts/builds/legacy/CMakeFiles/engine-legacy.dir/build.make:2780: rts/builds/legacy/CMakeFiles/engine-legacy.dir/__/__/Rendering/GL/myGL.cpp.o] Error 1
make[2]: *** [CMakeFiles/Makefile2:4222: rts/builds/legacy/CMakeFiles/engine-legacy.dir/all] Error 2
make[1]: *** [CMakeFiles/Makefile2:4107: rts/builds/CMakeFiles/spring.dir/rule] Error 2
make: *** [Makefile:1137: spring] Error 2

Quelque-soit le choix retenu (installation du binaire ou compilation du source), l'installation nécessite quelques téléchargements complémentaires (voir la section "Installation") :
- le pack "Spring Features" (il devient difficile à trouver, et je ne suis pas sur qu'il soit encore indispensable),
- quelques cartes et jeux,
- et initialisations des répertoires.

Et si vous parvenez à compiler le moteur, et installez ses données, il vous faudra aussi une IA fonctionnelle pour jouer en solo (à télécharger sur le site "SpringFiles"). Il vous faudra effectuer différents tests avec des cartes (si l'IA ne fonctionne pas, le jeu démarre mais aucune IA ne spawn ou elle spawn mais ne se développe pas), chercher éventuellement d'autres IAs sur les sites de contenu (SpringFiles est en pleine réorganisation début 2022, pas facile de s'y retrouver).

Donc pour une expérience optimum et éviter les frustrations, je vous suggère fortement d'utiliser des jeux clef en mains (libres ou gratuits) qui utilisent le moteur Spring (voir le paragraphe "Conclusion" plus bas).

• 🏗️ Réalisation :

• Consommation de ressources : Spring est assez gourmand en ressources, mes 6Go de mémoire semblent un peu justes. J'ai dû désactiver la surveillance de la mémoire disponible par Gkrellm (car il n'arrêtait pas de se mettre en alarme), néanmoins Spring fonctionne bien avec simultanément mon navigateur internet et tous ses onglets ouverts et Tellico avec la base du Bottin, donc ça laisse encore un peu de marge.

• 🏜️ Graphisme & interface :
C'est de la vraie 3D avec du rendu dans tous les coins, des ombres, des effets de fumées et de transparence, des explosions, ... et des jeux de grande qualité (pour les principaux) avec des tonnes d'unités terrestres, navales et aériennes finement modélisées.

L'interface est assez simple :
⚬ un menu (en bas à droite) avec 3 boutons pour (dans l'ordre d'apparition) choisir votre jeu, une carte et l'IA
⚬ un menu (en haut à gauche) avec 4 boutons pour (dans l'ordre d'apparition) lancer le jeu (Test the Game), modifier en directe les paramètres du moteur (modifie le fichier springsettings.cfg, voir la rubrique "Installation ci-avant), se connecter à une adresse IP pour jouer en multijoueur (Direct connect), ou Quitter le jeu (Quit).

• 🎧️ Son : en fonction des jeux une ou plusieurs bandes sonores se font entendre au démarrage du jeu. Dans le jeu lui-même on n'entend que les tirs et parfois les voix de certaines unités lorsqu'on leur donne des ordres.

• 🐞️ Fiabilité / Robustesse :
- en jeu solo il faut être vigilant sur les IA sélectionnées (voir les fiches des jeux pour les tests) car elles sont nombreuses à ne pas fonctionner correctement (elles sont parfois adaptées à un jeu donné et pour une version de Spring et n'évoluent probablement pas toujours aussi vite que ce dernier). Le mieux est de faire un test préalable du couple IA / Jeu sur une petite carte. Les IAs peuvent faire planter le jeu dès le démarrage.
- il faut également être vigilant sur le paramétrage du fichier springsettings.cfg, car il peut aussi faire planter le jeu. Pour démarrer il vaut mieux ne pas y toucher. Je vous indique le contenu du mien dans la section "Installation". on peut certainement faire mieux (en fonction de la puissance de votre PC aussi :).

• Cartes testées :
Comme d'habitude, j'utilise pour mes tests la minitabula-beta car elle est toute petite, idéale pour des tests rapides, le robot constructeur du joueur spawn la plupart du temps dans les jeux en haut à gauche de la carte (plus rarement complètement à droite près du rocher du milieu dans les arbres).
Lorsqu'un jeu ne fonctionne pas, le robot ne spawn pas, et la plupart du temps un message "Failed to initialize AAI!" est affiché brièvement en début de partie.

ASTUCE: Pour trouver votre robot sur la carte, faites un Ctrl A (ce qui sélectionne toutes vos unités): votre robot sera alors sélectionné (le rendant plus visible et vous pourrez lui demander de se déplacer à un endroit donné) et le menu de contrôle de votre robot s'affichera.

• 🎮️ Support des périphériques : l'essentiel est commandé à la souris avec des combinaisons de touches clavier. Très bien, adapté.

• 🎲️ Gameplay :
Voir les fiches spécifiques dans cette base. Les jeux sont nommés "Spring - Nom_du_Jeu".
Les jeux sont d'une manière générale d'une qualité exceptionnelle.

👍️ 🕹️ Longévité

Personnellement je ne m'en lasse pas :)

👍️ Pour :
• Une réalisation (graphisme, son, interface) d'une qualité rare / exceptionnelle pour du libre. C'est de la vraie 3D avec du rendu dans tous les coins, des ombres, des effets de fumées et de transparence, des explosions, ...
• Spring tolère l'installation de plusieurs versions du moteurs (elles partagent les même données), autorisant le fonctionnement (et le packaging de jeux avec une version spécifique du moteur) d'anciens jeux non compatibles avec la dernière version du moteur.
• Le gameplay de ces jeux est fantastique. J'adore.

👎️ Contre :
• Non testé depuis (car j'avais réinstallé mon système à l'occasion de mon passage en 64bit, et à présent mon HOME n'est plus sur une partition séparée): Spring nécessite d'être installé dans le répertoire utilisateur (HOME). Ses jeux et cartes occupent plusieurs Go. Ne comptez pas jouer à Spring avec un HOME <=10Go, c'est trop juste. Évitez donc d'utiliser Spring avec un HOME sur une petite partition car il va vous la remplir. Dommage qu'il ne puisse être installé dans le répertoire de votre choix.
• Spring est beau et puissant, en contre-partie il est gourmand en mémoire (6 Go ne sont pas de trop).
• (Très nette amélioration depuis mes derniers tests) Fiabilité des IAs. Les IA sont peu nombreuses et leur fonctionnement n'est pas assuré d'un jeu à l'autre, voir même d'une version de Spring à l'autre. Il manque peut-être un cahier des charges et/ou un autre système de qualité permettant de clarifier (pour les développeurs de jeux), améliorer, faciliter et fiabiliser le fonctionnement des IAs.
• (à confirmer à nouveau car à l'écriture de ces lignes je n'ai testé que Spring:1944) Certains jeux de Spring peuvent s'avérer compliqués à installer, et/ou d'un accès difficile sans passer par un lobby (voir les tests sur les fiches).

• 🕹️ Conclusion :
Impression globale : 👍️
Un moteur et des jeux d'une qualité rare / exceptionnelle pour du libre. Personnellement c'est mon jeu/moteur préféré car j'adore ce type de jeux.

Je n'ai que peu testé son client lobby attitré (Springlobby) et je ne suis pas toujours parvenu à le faire fonctionner. Le jeu sans client lobby permet de bien maîtriser l'installation du contenu pour le sauvegarder et pouvoir y jouer plus tard en solo. Mais tous les goûts sont dans la nature :) Si vous aimez jouer en multijoueur un client lobby est quasi indispensable.

Si les tests ne vous font pas peur (le plus difficile étant peut-être de trouver une IA qui fonctionne à la fois avec la version du moteur et le contenu téléchargé, d'autant que le site SpringFiles est en pleine réorganisation début 2022), vous pouvez donc tenter de le faire fonctionner manuellement (téléchargement de contenu et installation).

Néanmoins je vous recommande des jeux comme Zero-K ou Beyon All Reason qui proposent des solutions simples, clef en main, très évoluées, se mettant à jour toutes seules, et avec tout le nécessaire (téléchargement de contenu depuis l'interface, client pour le jeu solo et multi, classement des joueurs, ...). Superbes et très efficaces.

👏️ ❤️ Un grand bravo et merci à ses auteurs !

🗃️ Specifications

📖️ Summary

🎥️ Videos

🕸️ Links

📕 Description [en]

📕 Description [fr]

🚧️ Installation [fr]

🔍️ Test [fr]