Bild ändern

[feiste]

Hi,

gibt es einen Befehl womit ich ein Bild durch ein anderes ersetzen kann ?

danke.

 

[madboy]

mv neuesBild.jpg altesBild.jpg

?
Mehr Infos bitte. Was für ein Bild, geht es überhaupt um Java, hast du Code?

 

[feiste]

also ich programmier Doodle Jump,
wenn die Spielfigur(Bild1) den "Jetpack" aufsammelt (kollision)
soll die Spielfigur eben auf dem Rücken einen Jetpack haben (Bild2)

Importieren tu ich die Bilder so:

Spielfigur = new BILD("Spielfigur.gif");


Weiß nicht ob das wichtig ist,
aber ich arbeite mit BlueJ.

???:L

 

[madboy]

Ich habe zwar keine Ahnung, wie das mit BlueJ funktioniert, aber wenn du mehr Code postest kann dir evtl. geholfen werden. Wenn es weniger als 200 Zeilen sind, poste doch mal den kompletten Code. Verwende aber JAVA-Tags. Wie das geht, steht über dem Editor hier zum Text schreiben.

 

[feiste]

ich poste mal die klasse bild: (von meinem Lehrer)

import java.awt.Image;
import java.awt.image.*;
import java.awt.Graphics;
import java.net.URL;
import javax.imageio.ImageIO;
import java.io.IOException;
import javax.swing.*;
import java.awt.*;
import java.awt.geom.AffineTransform;

public class BILD
{
    public boolean IstSichtbar;
    private int Breite;
    private int Hoehe;
    private double X=0;
    private double Y=0;
    
    private String DateiName;
    private Image image;
    private AffineTransform tm = new AffineTransform();
    
    
    public BILD(String NeuerDateiName)
    {
        DateiName=NeuerDateiName;
        URL url = this.getClass().getClassLoader().getResource(DateiName);
        try
        {
            image = ImageIO.read(url);
        }
        catch(IOException e)
        {
            System.out.println("Bild " + NeuerDateiName + " konnte nicht geladen werden!");
        }
        GAMEWINDOW w = GAMEWINDOW.getInstance();
        w.AddSprite(this);  
        Breite = image.getWidth(null);
        Hoehe = image.getHeight(null);
        IstSichtbar = true;
        UpdateAffine();
    }
    
    public void Draw(Graphics2D graphics)
    {
        
        graphics.drawImage(image,tm,null);
       
    }
    
    private void UpdateAffine()
    {
        double b = (double)Breite / (double)image.getWidth(null);
        double h = (double)Hoehe / (double)image.getHeight(null);
        tm.setToIdentity();
        
        tm.translate(X,Y);
        tm.scale(b,h);
    }
    
    public void SetzeX(double neuX)
    {
        X = neuX;
        UpdateAffine();
    }
    
    public void SetzeY(double neuY)
    {
        Y = neuY;
        UpdateAffine();
    }
    
    public void SetzeBreite(int neueBreite)
    {
        Breite = neueBreite;
        UpdateAffine();
    }
    
    public void SetzeHoehe(int neueHoehe)
    {
        Hoehe = neueHoehe;
        UpdateAffine();
    }
    
    public double LeseX()
    {
        return X;   
    }
    
    public double LeseY()
    {
        return Y;   
    }
    
    public boolean LeseSichtbar()
    {
        return IstSichtbar;
    }
    
    public void SichtbarSetzen(boolean NeuIstSichtbar)
    {
        IstSichtbar = NeuIstSichtbar;   
    }
    
    public double Abstand(BILD bild)
    {
        double ax = X + Breite/2.0;
        double ay = Y + Hoehe/2.0;
        double bx = bild.X + bild.Breite/2.0;
        double by = bild.Y + bild.Hoehe/2.0;
        
        return Math.sqrt( (ax-bx)*(ax-bx) + (ay-by)*(ay-by) );
    }
    
    public void TransparenzSetzen(int red, int green, int blue)
    {
      final Color color = new Color(red,green,blue);
        
      ImageFilter filter = new RGBImageFilter() 
      {
        public int markerRGB = color.getRGB() | 0xFF000000;

        public final int filterRGB(int x, int y, int rgb) {
        if ( ( rgb | 0xFF000000 ) == markerRGB ) {
          // Mark the alpha bits as zero - transparent
          return 0x00FFFFFF & rgb;
          }
        else {
          // nothing to do
          return rgb;
          }
        }
      }; 

    ImageProducer ip = new FilteredImageSource(image.getSource(), filter);
    image = Toolkit.getDefaultToolkit().createImage(ip);
    
    }
}

 

[L-ectron-X]

Vielleicht kann man das Konzept etwas ändern.

Ich würde ein Objekt Spielfigur erzeugen und diesem dann über set()-Methoden Eigenschaften (wie dein Jetpack) hinzufügen. Die Eigenschaften, in diesem Fall hast du ja eine Sammlung von Werkzeugen, könnte man im Objekt in einer Liste verwalten.
Dann hat das Objekt einen inneren Zustand, den man auch nach außen jederzeit zeichnen kann.

 

[madboy]

Ich meinte nicht den Code deines Lehrers sondern deinen Code

 

[feiste]

und hier ein Beispiel wie es dann aussehen soll

public class Spiel
{
BILD Spielfigur;


public Spiel()
{
 Spielfigur = new BILD("figur1.gif");
}

public class Bildändern()
{
if(z.B Kollision)
{
// Hier soll "figur1.gif" durch "figur2.gif" ersetzt werden, wenn das geht !
}
}
}

 

[feiste]

Ich meinte nicht den Code deines Lehrers sondern deinen Code

ich hab die klasse genauso von meinem lehrer übernommen.

 

[feiste]

Vielleicht kann man das Konzept etwas ändern.

Ich würde ein Objekt Spielfigur erzeugen und diesem dann über set()-Methoden Eigenschaften (wie dein Jetpack) hinzufügen. Die Eigenschaften, in diesem Fall hast du ja eine Sammlung von Werkzeugen, könnte man im Objekt in einer Liste verwalten.
Dann hat das Objekt einen inneren Zustand, den man auch nach außen jederzeit zeichnen kann.

danke.
könntest du mal bitte ein Beispiel machen,
kann damit wenig anfangen.

 

[L-ectron-X]

Eine einfache Spielfigur kann so aussehen:

import java.util.*;
import java.awt.*;

public class Spielfigur {
  private Image skin;
  private String name;
  private java.util.List<Integer> tools;
  
  public Spielfigur(String name, Image skin) {
    this.name = name;
    this.skin = skin;
    tools = new ArrayList<Integer>();
  }
  
  /**
   * Wird bei Kollision mit einem Werkzeug aufgerufen.
   * Das Werkzeug wird von der Spielfigur "aufgesammelt".
   * @param tool ein Werkzeug
   */
  public void pickUpTool(final int tool) {
    tools.add(tool);
  }
  
  /**
   * Wird aufgerufen, wenn die Spielfigur ein Werkzeug wegwirft.
   * @param tool das Werkzeug, welches verbraucht oder weggeworfen wurde.
   */
  public void dropTool(final int tool) {
    tools.remove(tool);
  }
  
  /**
   * Setzt den Namen der Spielfigur / des Spielers.
   * @param name der Name des Spielers.
   */
  public void setName(String name) {
    this.name = name;
  }
  
  /**
   * Gibt den Namen der Spielfigur / des Spielers zurück.
   * @return der Name
   */
  public String getName() {
    return name;
  }
  
  /**
   * Setzt die "äußere Erscheinung" der Spielfigur / des Spielers.
   * @param skin das Aussehen des Spielers.
   */
  public void setSkin(Image skin) {
    this.skin = skin;
  }
  
  /**
   * Gibt die "äußere Erscheinung" der Spielfigur / des Spielers zurück.
   * @return das Aussehen des Spielers.
   */
  public Image getSkin() {
    return skin;
  }

}

Hier mal noch eine einfache Tool-Klasse, also die Werkzeuge, die der Spieler finden und benutzen kann.

public class Tool {
  public static final int JETPACK = 1; //JetPack
  public static final int HAMMER = 2;  //Hammer
  public static final int KNIFE = 3;   //Messer
}

 

[feiste]

geht das nicht auch bisschen leichter
so irgendwie:

public class Spiel
{
BILD Spielfigur;
 
 
public Spiel()
{
 Spielfigur = new BILD("figur1.gif");
}
 
public class Bildändern()
{
if(z.B Kollision)
{
// Hier soll "figur1.gif" durch "figur2.gif" ersetzt werden, wenn das geht !
}
}
}

 

[L-ectron-X]

Das wäre

[JAVA=48] /**
* Setzt die "äußere Erscheinung" der Spielfigur / des Spielers.
* @param skin das Aussehen des Spielers.
*/
public void setSkin(Image skin) {
this.skin = skin;
}[/code]

 

[feiste]

danke
ehm wie würde das dann bei meinem oberen Beispiel aussehen ?

 

[L-ectron-X]

"Bildändern" ist keine Klasse, kein Typ, sondern eine Funktion, eine Methode.

public void bildWechseln(Image bild)
{
  if(kollision)
  {
     this.bild = bild; 
  }
}

Die Klasse selbst sollte sich nicht um das Laden des Bildes kümmern, daher wird ihr hier das fertige Image übergeben.
Du kannst dich aber auch enger an die Klasse von deinem Lehrer halten.

 

[feiste]

aber da geb ich ja jetzt keinen Pfad für das neue bild an?

 

[L-ectron-X]

Du bekommst das fertig geladene Bild in einem Image-Objekt.
Welches Bild geladen werden soll, sollte an dieser Stelle nicht fix sein. Die Auswahl über die Art des Bildes und das Laden kann auch wo anders passieren.