Bonjour, je suis en train de réaliser un projet personnel en JAVA...Et j'ai besoin de vos conseils et intelligences pour savoir comment faire car je n'ai trouvé ça nulle part, aussdi détaillé que je l'aimerais.

Voila en fait mon sujet c'est une simulation du systeme solaire.
J'aimerais dans ma frame de simulation mettre une Terre importée depuis les images web: celle qui est ici:
http://www.cosmovisions.com/TerreWorldWind.jpg
La Terre bougeant autour du soleil (qui sera aussi une image importé) j'aimerais savoir comment la charger la mettre dans le code et la faire bouger:
Je vous explique mon code en gros.

Sur ma frame, j'ai créé un panel, avec la Terre à une certaine distance du Soleil (sa distance moyenne). Quand je clique sur ce panel, le mécanisme se déclenche à l'aide d'un Timer qui recalcule et repeint toutes les millisecondes, en incrémentant le temps d'une journée par ms. (La Terre aura fait un tour en officiellement 365 ms. Officieusement c'est un peu plus long car mon programme n'est pas optimisé.)

Voila pour les méthodes de la classe Frame

public class MaFenetre extends JFrame{

	public MaFenetre(String s){
          //Toutes les définitions d'une frame sur lequel j'ajoute (sur l'ensemble de la Frame) un Panneau p
	}
	Panneau p;

class Panneau extends JPanel implements MouseListener{

	//La je créé ma planete Terre à l'aide d'une autre classe Planete.java
        //Et mon Soleil à l'aide d'une autre classe Etoile.java
        //Puis mon Timer
	Timer timer;

	//Là les différentes méthodes de MouseListener
	@Override
	public void mouseClicked(MouseEvent e) {
		// TODO Auto-generated method stub
		
                // Si t=0 (le timer ne s'est pas déclenché), 
                // J'incrémente t 
                // alors je fait bouger la Terre selon une méthode physique de déplacement
                // dans la classe Planete.java
                // Je fais un repaint()
                // je lance le timer
			timer= createTimer();
			timer.start();
		// Si t <> 0 et si le timer est en train de défiler je le stoppe sinon je le  
                //relance pour la poursuite du mouvement
				if (timer.isRunning()){
					timer.stop();
				}
				else{
					timer.start();
				}
				
		}
	}
        // Pour les autres méthodes de Mouse je ne fais rien
	@Override
	public void mouseEntered(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void mouseExited(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void mousePressed(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void mouseReleased(MouseEvent e) {
		// TODO Auto-generated method stub
		
	}
        //La méthode du qui crée le timer
	private Timer createTimer ()
	  {
	    ActionListener action = new ActionListener ()
	      {
	    	public void actionPerformed (ActionEvent event) //appelé à chaque tic
	        {
//J'incrémente t				
//Je fais évolué la Terre d'après la méthode physique de tout à l'heure dans Planete.java
//Je repaint()
	        }
	    	
	      };
// avec le temps entre chaque tic de 1 ms
	      return new Timer (1, action);
	    }  


		
	
       // Voila enfin la méthode de dessin
	public void paintComponent(Graphics g){
		super.paintComponent(g);
		
                //Je dessine la Terre et le Soleil en faisant des //DrawOval en fonction de leurs x_centres et y_centres qui évoluent (pour //la Terre) avec la méthode physique 
			
		
		
	}


	
	
}
}

Voila je pense que c'est assez clair... J'aimerais à la place du drawOval de la Terre, pouvoir utiliser l'image du site. Partout ou j'ai regardé je n'ai pas compris comment faire ou alors c'est une image fixe. Quelqu'un peut il me répondre?

Merci beaucoup.

Salut,
pour charger l'image :

BufferedImage img = ImageIO.read(new URL("http://www.cosmovisions.com/TerreWorldWind.jpg"));

Ensuite, tu stockes l'image dans ton objet, tu calcules ton x et ton y avec ta méthode de déplacement (attention, x et y ne représenteront plus le centre de ton image, mais le coin supérieur gauche), et dans ta méthode paintComponent :

public void paintComponent(Graphics g){
	super.paintComponent(g);
	g.drawImage(img, x, y, null);	
}

Tu peux aussi utiliser g.drawImage(img, x, y, width, height, null); pour redimensionner ton image à la vollée (même s'il vaut mieux la redimensionner une fois pour toute en créant une autre image, mais c'est un peu plus compliqué), ou t'aider des méthodes img.getWidth(null); et img.getHeight(null); pour trouver le centre de ton image.

Salut et merci de ta réponse...Je comprends ce que tu dis à part cela:
"Ensuite, tu stockes l'image dans ton objet"
Comment je fais cela?
Je crée un champ Image dans ma classe Planete, et quand j'instancie la Terre,je mets le nom de l'image qui est ici "img"?

En ce qui concerne le redimensionnement de l'image, je fais un frame avec des zooms possibles sur les planetes donc il n'y a pas qu'un dimensionnement pour chaque planete... j'utiliserai le width et height so...

Citation : fabdu92

Salut et merci de ta réponse...Je comprends ce que tu dis à part cela:
"Ensuite, tu stockes l'image dans ton objet"
Comment je fais cela?
Je crée un champ Image dans ma classe Planete, et quand j'instancie la Terre,je mets le nom de l'image qui est ici "img"?

Oui, dans ta classe Planete, tu fais ton champ Image img, et à la création de ton objet, tu charges l'image et tu l'affectes à ce champ. Je suis de bonne humeur, donc je te donne aussi un example pour redimensionner ton image uniquement à la création de l'objet, pour éviter d'avoir à faire un redimensionnement à chaque fois que tu redessines l'image :

new Planete(ImageIO.read(new URL("http://tonurl")), width, height); // width et height sont la taille que tu souhaites donner à l'image

public class Planete extends JPanel { // Je n'écris pas tout ce qui est MouseListener
	private int x; // Le centre en x de la planète, que tu calcules à l'aide de ta méthode de déplacement
	private int y; // Pareil en y
	private final int xCentre;
	private final int yCentre;
	private final Image img;

	public Planete(Image img, int width, int height) {
		BufferedImage bufImg = 
			GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice()
				.getDefaultConfiguration().createCompatibleImage(width, height); // Ça te crée une image compatible
			// L'image compatible est plus rapide à afficher, mais tu peux te contenter d'un new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); si tu préfères
		Graphics g = bufImg.createGraphics();
		g.drawImage(img, 0, 0, width, height); // Tu recopies ton image dans la nouvelle image en la redimensionnant
		g.dispose();
		this.img = bufImg; // Là, tu stoques l'image dans ton objet
		this.xCentre = width / 2; // Tu calcules le centre de ta planête dans l'image, ici je suppose qu'il se situe au milieu de l'image
		this.yCentre = height / 2;
	}

	protected void paintComponent(Graphics g) {
		g.drawImage(img, x - xCentre, y - yCentre, null); // Tu dessines l'image aux coordonnées calculées.
		// Tu soustrais xCentre et yCentre si tu gardes tes anciens calculs, vu que tu calculais par rapport au centre de la planête, et que maintenant tu dois indiquer le coin supérieur gauche de l'image
	}
}

Bon, par contre je suis un peu fatigué et j'ai pas testé, donc je garantis pas qu'il n'y ait pas de faute, mais en tout cas l'idée est là.

J'ai de sérieux doutes sur le consentement de ton processeur à faire un repaint toutes les millisecondes...