eBonjour.
 
Je ne sais pas encore comment je vais faire mais je souhaiterais implémenter un petit système d'objets en mouvement dans l'espace.
 
je cherche les operation fondamentale pour maintenir un tel système ainsi que l'astice ou procédé pour faire en sorte que ça bouge tout seul.
 
Pour étalé un peu ma pauvreté voici mon code avec Ada.
 
la bibliotyhèque s'appel mach.
 

package Mach is
   pragma Pure (Mach);
 
   Spec_Error : exception;
   Impl_Limit : exception;
end Mach;

package Mach.abstracts is
   pragma Pure (Mach.Abstracts);
end Mach.Abstracts;

package Mach.Abstracts.OS is
 
   -- OS is operating system.                                                   
   -- Operating system is virtual modelization of real object.                  
   subtype Distance_Range is Float;
   type Orthonormal_record is tagged
      record
         X : Distance_Range := 0.0;
         Y : Distance_Range := 0.0;
         Z : Distance_Range := 0.0;
      end record;
 
   subtype Kilogramme_Range is Float;
 
   type Space_Record is abstract tagged record
      O : Orthonormal_Record;
      Masse : Kilogramme_Range;
   end record;
 
   subtype Speed_Range is Float;
 
   type Abstract_Object is abstract tagged limited null record;
end Mach.Abstracts.OS;

package Mach.Abstracts.OS.Objects is
 
   type Space_Name_record is new Space_Record with
      record
         Name : access Wide_String;
      end record;
 
   type Object_record is abstract new Abstract_Object with
      record
         Space_Name : Space_Name_Record;
         Position   : Orthonormal_Record;
         Masse      : Kilogramme_Range := 0.0;
      end record;
end Mach.Abstracts.OS.Objects;

package Mach.Abstracts.OS.Objects.Mobiles is
 
 
 
   type Mobile_Record is new Object_Record with
      record
         Immobilized : Boolean := False;
      end record;
 
   type Inertic_Record;
 
   task type Inertic_Task(Inertic : access Inertic_Record) is
      entry Move(Position    : in Orthonormal_Record;
                 Speed       : in Speed_Range;
                 Immobilized : in Boolean);
      entry Set_Speed(Speed : in Speed_Range);
      entry Get_Speed(Speed : out Speed_Range);
      entry Set_Immobilized(Immobilized : in Boolean);
      entry Get_Immobilized(Immobilized : out Boolean);
      entry Set_Space_Name(Space_Name : in Space_Name_Record);
      entry Get_Space_Name(Space_Name : in Space_Name_Record);
      entry Set_Masse(Masse : in Kilogramme_Range);
      entry Get_Masse(Masse : out Kilogramme_Range);
      entry Set_Position(Position : in Orthonormal_Record);
      entry Get_Position(Position : out Orthonormal_Record);
   end Inertic_Task;
 
   type Inertic_Record is tagged limited record
      Mobile  : Mobile_Record;
      Speed   : Speed_Range := 0.0;
      Inertie : Inertic_Task(Inertic_Record'Access);
   end record;
 
private
   procedure Move (Mobile      : in out Mobile_Record;
                   Position    : in Orthonormal_Record;
                   Speed       : in Speed_Range;
                   Immobilized : in Boolean := False);
 
 
end Mach.Abstracts.OS.Objects.Mobiles;

package body Mach.Abstracts.OS.Objects.Mobiles is
 
   procedure Move (Mobile      : in out Mobile_Record;
                   Position    : in Orthonormal_Record;
                   Speed       : in Speed_Range;
                   Immobilized : in Boolean := False) is
   begin
      if Speed /= 0.0 and Immobilized /= False then
         raise Spec_Error;
      end if;
   end Move;
 
 
 
 
   task body Inertic_Task is
   begin
      loop
         select
            accept Move(Position    : in Orthonormal_Record;
                        Speed       : in Speed_Range;
                        Immobilized : in Boolean) do
               Inertic.Mobile.Move(Position, Speed, Immobilized);
            end Move;
         or
            accept Set_Speed(Speed : in Speed_Range);
         or
            accept Get_Speed(Speed : out Speed_Range) do
               Speed := Inertic.Speed;
            end Get_Speed;
         or
 
            accept Set_Immobilized(Immobilized : in Boolean);
         or
            accept Get_Immobilized(Immobilized : out Boolean) do
               Immobilized := Inertic.Mobile.Immobilized;
            end Get_Immobilized;
         or
 
            accept Set_Space_Name(Space_Name : in Space_Name_Record);
         or
            accept Get_Space_Name(Space_Name : in Space_Name_Record);
         or
 
            accept Set_Masse(Masse : in Kilogramme_Range);
 
 
         or
            accept Get_Masse(Masse : out Kilogramme_Range) do
               Masse := Inertic.Mobile.Masse;
            end Get_Masse;
         or
 
            accept Set_Position(Position : in Orthonormal_Record);
         or
            accept Get_Position(Position : out Orthonormal_Record) do
               Position := Inertic.Mobile.Position;
            end Get_Position;
         end select;
      end loop;
   end Inertic_Task;
 
end Mach.Abstracts.OS.Objects.Mobiles;

 
 
Enfin le programme principal :

with Mach.Abstracts.Os;
use Mach.Abstracts.Os;
with Mach.Abstracts.Os.Objects;
use Mach.Abstracts.Os.Objects;
with Mach.Abstracts.Os.Objects.Mobiles;
use Mach.Abstracts.Os.Objects.Mobiles;
with Ada.Float_Text_Io;
use Ada;
with Ada.Wide_Text_Io;
use Ada.Wide_Text_Io;
procedure Machine is
 
 
   Moi : Inertic_Record;
   Position : Orthonormal_Record := (0.0, 0.0, 0.0);
   Speed    : Speed_Range := 0.0;
   Immobilized : Boolean := True;
 
begin
   for I in 1..1 loop
      Moi.Inertie.Move(Position, Speed, Immobilized);
      Moi.Inertie.Get_Position(Position);
      Put("x:" );
      Float_Text_Io.Put(Position.X);
      New_Line;
      Put("y:" );
      Float_Text_Io.Put(Position.X);
      New_Line;
      Put("z:" );
      Float_Text_Io.Put(Position.X);
      New_Line;
      Moi.Inertie.Get_Speed(Speed);
      Put("speed:" );
      Float_Text_Io.Put(speed);
      New_Line;
      Moi.Inertie.Get_Immobilized(Immobilized);
      Put("Immobilized: " );
      if Immobilized then
         Put("True" );
      else
         Put("False" );
      end if;
      New_Line;
   end loop;
   abort Moi.Inertie;
end Machine;

Et son résultat :
 

 
J'avais idée de créer un thread dans la tache intertic_task mais justement, je suis un poil paumé.
J'ai également l'idée de gérer le mouvement en fonction d'un délay établie selon la masse et la vitesse (l'accélération) et de déplacer l'objet à chaque pas de temps.
Merci pour votre aide.
 
 
J'oubliais...
 
 
Le principe que je voudrais implémenter, et basé sur deux ou trois axiome qui dirais que tout objet en movement à une masse et une position relativement à un autre objet qui a une vitesse.

 
 
WTF, jovalise qui réinvente le PFD    

Newton, ça peut être intéressant de regarder aussi
 
Après, y'a des moteurs 3D qui implémentent la physique. Développer ce genre de chose from scratch, c'est un peu hardcore

 
Ah parce que le PFD ça a rien à voir avec Newton ?
 
 

Je te propose de nous faire une implémentation du problème à N corps avec autant de corps qu'on veut.  
J'espère que tu aimes les équations différentielles.
 
Mais sinon il doit y avoir des modélisations approchantes dans les moteurs physiques. Evidemment si tu veux un moteur physique en Ada ça va être plus compliqué à trouver.

je connais pas les equation différentielle, pas formellement.
Et comme c'était pour m'amuser un peux, ben on peux oublier pour moi.
J'ai quand même fait tourner un point dans le sens des aiguilles d'une montre.
Avec l'orloge au mileu et un messssage "hello world!"
Ca jette.
Merci quand même.
Si vous vouler je vous fille mon code.

C'était inspiré par le sujet Abstract dans java.  

Tiens, lis ça. C'est une excellente ressource qui explique très clairement certains principes fondamentaux et leurs implémentations.
http://natureofcode.com/book/

Connaissais pas. Ça remet en mémoire des principes simples. Je sens que ça va m'être très utile !

C'est un excellent livre, écrit de façon très compréhensible et très progressive.

Merci Harkonnen,

Par contre il y a une question que tu ne t'es pas posée : est-ce que tu vas implémenter l'espace? Parce que pour l'instant ton ordinateur ne connait pas la mètre par exemple. Tu crées donc un objet qui se déplace dans quoi?
De plus la notion de temps que connait ton ordi reste très approximative puisqu'il faudrait la relier à l'espace, l'espace réel puisque ton ordi peut être à différentes positions de l'espace mais aussi l'espace recrée puisque la notion de temps pourra aussi changer en fonction de ton espace redéfinit.

il y a un jeu linux qui s'appelle koules :
https://www.youtube.com/watch?v=WtlunA1ClR8
 
normalement il devrait être bien fait, de ce que j'avais joué à l'époque c'était rapide

 
la question prend deux sens, d'un point de vue virtuel l'espace est peut-être représenter par quoi ?
 
une quantité d'énergie ?
une somme d'actions ?
le temps qui passe ?
 
D'un point de vue concret, c'szt de l'espace. + j'ajoute d'objet + ma mémoire diminue.
 
Les deux sont il lié ?
 
j'y réfléchie encore.

il se pose trop de questions visiblement
tu prends un repère en 3d et tu appliques des règles physiques
tu as regardé le code source du jeu koules ?
 
ah oui :

le mètre on s'en fout, y compris le pouce, la coudée ou le pixel etc ...
il faut juste une seule chose, c'est définir une unité
on prend n'importe laquelle, on s'y tient, on applique des règles qui fonctionnent et ça fonctionne
ya pas de secret

Dès lors où il veut faire de la représentation, on ne s'en fout plus de l'unité. D'ailleurs l'exemple le plus flagrant est celui du temps. Prenons le cas d'un point (un pixel), se déplaçant dans un espace 2D (un écran), doit-on simplement exécuter le code en faisant dépendre le temps du temps de traitement du CPU? Cela implique que le temps devient alors variable par rapport au temps "réel", plus le temps de traitement est long, moins le pixel se déplacera vite de notre point de vue. Mais d'un autre côté cela permet de déformer l'espace-temps tout comme le fait la gravité. Alors qu'on pourrait très bien se baser uniquement sur l'horloge CPU et se retrouver avec un espace-temps uniforme.
 
Mais ces problèmes s'appliquent aussi à l'espace, on parle de pixels, espace défini et discret alors qu'en réalité nos lois physiques s'appliquent sur un espace infini et ? (espace continu ou discret, telle est la question). Alors que fait-on de nos 2,337 pixels? Et de notre trajectoire de 28700 pixels?
 
Tout ça ne sont pas des petites questions anodines, ces questions sont même au cœur de toutes les représentations graphiques informatiques.

Bonjour,
 
Non, on s'en fou du pixel. et de l'horloge.
 
 
Nourmalement il existe au moin deux objets trois espace 2 temps.
 
Avec ça je doit donner des masses et des vitesse.
 
 
J'affiche rien rien ne bouges simplement un listing de valeur et de texte.

Dans ce cas là tu reviens en effet aux premières préoccupations qui sont celles de définir un espace-temps et qui plus est peut être dépendant du nôtre.

je ne comprend pas pourquoi on devrait définir un espace temps sachant que ce truc n'a jamais été prouvé
 
s'il veut calculer les positions respectives de sphères ou points évoluant les uns autour des autres (ce que je ne sais pas vraiment car il s'exprime un peu difficilement), il y a déjà des équations disponibles où l'on donne la masse des objets
 
il faudrait qu'il se rapproche des cours de 1ère année de fac de physique, ces équations sont dans le programme (équations concernant la gravitation qui sont approximatives mais donnent d'assez bons résultats sur la durée)
 
si je comprends ce qu'il veut faire, c'est tout simplement le problème à n corps où les étudiants doivent calculer les positions de chaque corps avec système à 2 corps, ensuite à 3, ensuite à 4 et ainsi de suite pour s'apercevoir ensuite qu'il n'est pas possible de fonctionner comme ça vu que personne n'a jamais encore été capable de modéliser un système à n corps
 
est-ce qu'il ne demanderait pas de résoudre à sa place un exercice qu'on lui a donné ?
"Avec ça je doit donner des masses et des vitesse. " (il est étonnant de constater que ça correspond effectivement aux équations de gravitation)
 
Et dans ce cas là, il n'y a pas besoin de chercher bien loin, les équations qu'il cherche sont ici :
https://fr.wikipedia.org/wiki/Loi_u [...] ravitation
 
ensuite s'il faut lui expliquer comment les utiliser il n'a qu'à regarder le code source du jeu "koules" disponible sur linux que j'ai déjà cité plus haut

[edit]enfin quoique, koules ne fonctionne pas seulement avec force d'attraction mais aussi avec répulsion, il risque d'être un peu perdu
[re-edit]eh merde, je viens de regarder une nouvelle fois la vidéo du jeu, et koules ne fonctionne pas avec de la gravitation visiblement, donc il ne sert normalement à rien pour lui d'étudier ce code source