Salutation !

J'aimerais trouver un algo qui me permettrais de créer une galaxie peuplée d'environ 60.000 à 100.000 systèmes. Ce n'est pas vraiment complexe a la base, en fait le truc complexe est que j'aimerais avoir une distribution des systèmes équitable pour les joueurs. Pas qu'un joueur débutant se retrouve avec des systèmes trop lointains nécessitants un niveau excessif de développement pour les atteindre. De plus il faudrais (et c'est logique) que le nombre de système au centre de la galaxie soit bien plus élevé que sur les bords.

Ou alors je continue avec ma galaxie rectangulaire...
(Zut, je viens d'avoir une idée de génie... Elle doit être de mer...credi si je pense qu'elle est géniale....)

Si vous avez ce genre d'algo dans vos calepins, en tout cas, je suis preneur.

Merci et a peluche !

je sais pas si je vais avoir une solution, mais ton probleme m'interresse, j'y réflechi

L'idée de génie, qui est une véritable daube en fait, est de donner a ma galaxie la forme d'un anneau de moebius... C'est con, hein ?

Merci a toi Jerry Kan !

alors j'ai deux solutions qui peuvent se combiner :

la premiere :

tu découpe ta galaxie en cases, et tu fait un algo récursif de répartition a plat, ou tu prends a chaque fois 4 cases découpées dans la premiere :

donc tu part avec rempli_etoiles(S1,S2, nb_etoiles) // S1 et S2 sont les sommets de la case courante

et dedans tu relance ta fonction sur 4 sous carrés avec   nb_etoiles =nb_etoiles/4 et

et quand tu veux que la répartition soit plus homogène, tu ne respecte plus le /4 et/ou tu arrete de redécouper réccursivement ton espace, et tu fait un random des positions dans ta sous case

si tu veux moduler le fait que le centre est plus dense, tu module nb d'étoiles en multipliant par l'inverse de la distance au centre, (plus t'est proche, plus tu alloue d'étoiles)


pour passer d'une répartition plane a un espace 3d, tu fait une répartition gaussienne,  en pratique : tu prends une courbe de gauss, et tu l'utilise pour répartir tes positions horizontales

Comme moi tu pige pas trop comment on se sert efficacement d'une gaussienne, et tu veux coder ca a l'arrache ?
tu fait un tirage sur 100 valeurs, et tu dit que pour un résultat entre 0 et 25, ca te place au point 0,
entre 25 et 40 ca te place au point 1 (ou -1)
entre 40 55 ca te place au point 2 (ou -2)
etc en réduisant la fenetre a chaque fois,

comme ca la plupart de tes étoiles seront autour de -2 / 2 mais y'en aura d'autres éparpillées de facon aléatoire autour

tiens j'y pense, tu peux faire exactement la meme chose pour la position en x et la position en y, avec les fenetres que tu veux pour adapter le % d'étoiles dans chaque truc

c'est un peu brouillon tout ca, mais j'espere t'avoir donné une piste

Dernière modification par Jerry Kan (14-02-2007 18:41:16)

Bonjour à tous!

J'aurais une réponse "scientifique" à te proposer :

Pour générer une galaxie qui te semble crédible il te faut déjà fixer des objectifs de crédibilité.

Il existe plusieurs types de galaxies, identifiables par des caractéristiques géométriques et statistiques. Pour simplifier, les étoiles se regroupent en branches, qui s'étirent depuis un centre plus volumineux, théoriquement autour d'un trou noir (mais c'est un détail). Les branches sont courbées du fait de la rotation (force centrifuge vs gravité... orbite quoi).

Après tu peux considérer que modéliser les branches est trop détaillé et te simplifier la vie en faisant quelque chose de plus uniforme.
Mais le disque galactique ne serait pour autant pas strictement uniforme.
En gros tu considères 3 répartitions statistiques sur 3 plans: l'écliptique, et 2 axes de l'ellipse galactique.

Les 2 axes peuvent etre représentés par la meme loi statistique et ta galaxie sera donc circulaire.
L'ecliptique pourra te permettre entre autre de modéliser la bulle centrale.

donc pour les 2 axes x et y tu prends une répartition gaussienne.
pour l'axe z tu modélises l'épaisseur et là il faut faire une répartition qui dépend de la distance au centre, c'est plus délicat

il y a un peu de travail sur cette question encore

mais pour résumer ca dépend principalement du degré de vraissemblance du résultat que tu comptes obtenir

il faudra que je revienne avec des détails un peu plus tard

fred

Merci pour vos réponses.

Mon problème viens des points suivants :
  - je n'ai pas envie d'une galaxie carré ou cubique.
  - J'aimerais une distribution équitable des systèmes.
  - Plus on s'approche du centre, plus les systèmes sont nombreux et proches.
  - La navigation VISUELLE doit être simple et rapide.
  - Le système de repérage ne doit pas être une usine a gaz.

Actuellement, j'hésite entre 2 options :
  - 1 gros cube, mais dont les faces opposées sont connectées (Pas de limite, effet moebius).
  - Une galaxie spirale, fine sur les bords, épaisse au centre.

la deuxieme, la deuxieme ..

ne serait ce que parce que le joueur pourra se déplacer tout en aillant une idée de sa position 2d, nous avons toujours tendance a penser en 2d, meme si c'est dans une galaxie 3d

j'ai toujours révé de pouvoir dire "j'ai ma base dans la bordure extérieure, un peu a l'écart du plan de l'écliptique"

Dernière modification par Jerry Kan (18-02-2007 15:03:44)

d'ailleur c'est pour quel genre de jeu ? Rpg ou stratégie ?

Bonjour

- je n'ai pas envie d'une galaxie carré ou cubique.
  - J'aimerais une distribution équitable des systèmes.

il est assez aisé de générer un nuage de points qui ressemble à un disque : travailler en coordonnées cylindriques (r, théta, z),
avec r la distance entre la projection sur le plan de l'écliptique et le centre de la galaxie,
avec théta l'angle du point projeté sur le plan de l'écliptique,
avec z la distance au plan de l'écliptique (projection sur l'axe perpendiculaire au plan de l'écliptique),
faire l'hypothèse d'une galaxie sans branche, uniforme
méthode:
  - tirer une valeur de théta suivant une répartition uniforme entre 0 et 2*Pi
  - tirer une valeur de r selon la répartition de ton choix (là c'est un choix de modélisation, une repartition uniforme peut suffire entre 0 et R le rayon de ta galaxie)
  - tirer une valeur de z suivant une autre répartition, de préférence dépendant de la distance au centre.
  - boucler autant de fois que tu veux d'étoiles

- Plus on s'approche du centre, plus les systèmes sont nombreux et proches.

> voir juste au dessus : cela consiste à bien choisir la répartition pour r et z

- La navigation VISUELLE doit être simple et rapide.

j'avoue ne pas voir le rapport avec la génération de la galaxie, ce sont 2 problèmes différents

- Le système de repérage ne doit pas être une usine a gaz.

Tu as à ta disposition quelques systèmes de coordonnées classiques : cartésien, cylindrique, sphérique (peu pertinent ici) ou personnalisé : découper ta galaxie en secteurs, les nommer.... à toi de voir

Ce genre de problème est mathématiquement intéressant puisqu'il fait appel à la fois aux statistiques et à la géométrie.

Bon courage à toi

@Jerry Kan : A la question "Rpg ou stratégie" je répond : "Les deux ! "
L'idée m'est venue avec des jeux online :
- Ogame <http://www.ogame.fr>
- Exile <http://www.exile.fr>
Ainsi qu'avec le jeu Mankind.

Je vais faire une présentation de mon jeu, tiens. Mais pas dans ce topic.

La galaxie aura t'elle un mouvement de rotation ?
Sera t'elle elliptique, irrégulière, spirale, spirale-barrée ? (je l'ai mis par ordre de difficulté croissante, les 3 dernières étant très compliqué voire ingérable si la rotation doit être crédible)

Salut !
Merci de ton intéret !
Elle est Ronde et dispose de 2 bras. L'algo est fini et tout fonctionne a merveille !
Maintenant, il faut que j'exploite tout ça !

Je sais que c'est un peu moche de faire remonter un sujet, mais j'aimerais vraiment avoir une idée de ce que ça peut donner !

Tu aurais un petit screenshot de ta galaxie, genre une sorte de vue de dessus visualisant les étoiles pour vérifier la configuration en spirale à 2 bras ?

Pas de problèmes, voila :

Vue de dessus :


Vue de l'intérieur :


Partie du code qui génère le placement des soleils.

            Random rnd = new Random(1500);
            SceneNode sun = new SceneNode();

            // L'algorithme suivant provient d'un exemple de l'OpenSceneGraph
            // Pour ceux qui veulent voir l'original, c'est la Demo : osgpointsprite
            for (uint i = 0; i < nbetoiles/2; i++)
            {
                val = (i * 2.0f / (float)nbetoiles * 2.0f * 3.14159265359f);

                // Bras 1
                modx1 = rnd.Next(short.MaxValue) / (float)short.MaxValue*2;
                mody1 = rnd.Next(short.MaxValue) / (float)short.MaxValue*2;
                modz1 = ((rnd.Next(short.MaxValue) - (float)short.MaxValue / 2) / (float)(short.MaxValue)) * 3 / (val + 1);

                sunX = ((float)Math.Cos(val) * val + modx1) * etendue;
                sunZ = ((float)Math.Sin(val) * val + mody1) * etendue;
                sunY = modz1 * etendue;

                sun = smgr.AddBillboardSceneNode(smgr.RootSceneNode, new Dimension2Df(tailleDesSoleils, tailleDesSoleils), -1);
                sun.Position = new vector3d(sunX, sunY, sunZ);
                sun.SetMaterialType(MaterialType.TransparentAddColor);
                sun.SetMaterialTexture(0, textures_soleils[rnd.Next(NbTexturesSoleils)]);
                sun.SetMaterialFlag(MaterialFlag.Lighting, false);

                // Bras 2
                modx2 = rnd.Next(short.MaxValue) / (float)short.MaxValue * 2;
                mody2 = rnd.Next(short.MaxValue) / (float)short.MaxValue * 2;
                modz2 = ((rnd.Next(short.MaxValue) - (float)short.MaxValue / 2) / (float)(short.MaxValue)) * 3 / (val + 1);

                sunX = (-(float)Math.Cos(val) * val + modx2) * etendue;
                sunZ = (-(float)Math.Sin(val) * val + mody2) * etendue;
                sunY = modz2 * etendue;

                sun = smgr.AddBillboardSceneNode(smgr.RootSceneNode, new Dimension2Df(tailleDesSoleils, tailleDesSoleils), -1);
                sun.Position = new vector3d(sunX, sunY, sunZ);
                sun.SetMaterialType(MaterialType.TransparentAddColor);
                sun.SetMaterialTexture(0, textures_soleils[rnd.Next(NbTexturesSoleils)]);
                sun.SetMaterialFlag(MaterialFlag.Lighting, false);
            }

Dernière modification par diOxy (09-12-2007 21:49:11)

J'ai oublié de préciser.

Les soleils que vous voyez sont vraiment énormes parce que justement, avec une taille presque normale il aurait fallu que j'en mette 100 fois plus pour voir la galaxie. Et là, j'aurais atteint les limites de ma carte. Si j'affichais la totalité des soleils que j'ai prévu d'un seul coup, je saturerais la mémoire. Il y a donc un affichage en fonction de l'amplitude (taille, luminosité) des soleils.

Malheureusement, ce projet est également en stand by, because trop de boulot en ce moment.