Blitze mit Linien zeichnen

A

abfl

Gast
Hallo Leute,
ich habe ein kleines Problem: Ich möchte bei meiner TD einen Blitz von einem Tower zu einem Creep zeichnen. Über google hab ich auch schon einen ersten Ansatz gefunden, wie man so einen Blitz zeichnen kann.
Java:
                Vector poly = new Vector();
                int dx, dy, i, polysize;
                int x = tower.pos_x+16;
                int y = tower.pos_y+16;
          
                //Blitzpolygon berechnen
                poly.addElement(new Point(x,y));
                polysize = 1;
                while (y > 20) {
                    dx = 10 - (int)(Math.floor(Math.random()*20));
                    dy = - (int)(Math.floor(Math.random()*20));
                    x += dx;
                    y += dy;
                    poly.addElement(new Point(x,y));
                    ++polysize;
                }
                //Blitzvector in Koordinaten-Arrays umwandeln
                int xpoints[] = new int[poly.size()];
                int ypoints[] = new int[poly.size()];
                for (i = 0; i < polysize; ++i) {
                    Point p = (Point)poly.elementAt(i);
                    xpoints[i] = p.x;
                    ypoints[i] = p.y;
                }
                //Blitz zeichnen
                g.setColor(Color.white);
                for (i = 0; i <= 1; ++i) 
                {
                    g.drawPolyline(xpoints, ypoints, polysize);
                }
Nur zeigt der Blitz leider immer nach oben und nicht, wie gewünscht, auf den Creep. Außerdem stimmt auch die Reichweite nicht ganz.
So stelle ich mir das ganze dann in etwa vor:

Der Kreis ist zB der Tower und der schießt dann Blitze auf den Creep, also das Rechteck.

Und so sieht es jetzt aus:


Wär echt super, wenn mir jemand helfen könnte. lg abfl
 

Michael...

Top Contributor
Über google hab ich auch schon einen ersten Ansatz gefunden, wie man so einen Blitz zeichnen kann.
Wobei dieser ja nicht gerade optimal ist. Es macht nicht unbedingt Sinn ein Vector mit Point Objekten zu füllen, um dann anschliessend die Koordinaten in int-Arrays zu überführen. Man könnte genauso gut die Arrays direkt befüllen. Und die for-Schleife zum Zeichnen ist überflüssig.

Die Orientierung und Grenze des Blitzes wird ja mit der Grenze der while Schleife y>20 und den x und y Berechnungen in dieser festgelegt. (Zeile 9 bis 16). Und die ist so ausgelegt, dass sich der Blitz in -y Richtung bis y>20 bewegt.
 
A

abfl

Gast
Danke soweit, das mit der Reichweite habe ich auch hinbekommen, nur mit der Richtung klappt es noch nicht so ganz.
[JASS]
dx = (int)Math.cos(angle) * (int)(Math.floor(Math.random()*20));
dy = (int)Math.sin(angle) * (int)(Math.floor(Math.random()*20));
[/JASS]
Außerdem wäre es auch ziemlich cool, wenn die Blitze am Schluss nicht irgendwie auseinandergehen, sondern wieder auf einen Punkt zulaufen, also auf den Creep. Wie geht das dann?
 

bERt0r

Top Contributor
Math.cos(angle) Liefert dir den Kosinus von deinem Winkel. Der liegt soweit ich mich noch erinnern kann zwischen -1 und 1 und ist eine Kommazahl. Wenn du die mittels (int) auf eine Ganzzahl zwangsumwandelst wird daraus so gut wie immer 0. Versuchs mal so:
Java:
(int)(Math.cos(angle) * Math.floor(Math.random()*20))
 

Fu3L

Top Contributor
Außerdem wäre es auch ziemlich cool, wenn die Blitze am Schluss nicht irgendwie auseinandergehen, sondern wieder auf einen Punkt zulaufen, also auf den Creep. Wie geht das dann?

Wenn du ein Array mit Punkten hast für jeden Blitz, dann mach doch den letzten Eintrag in den Arrays einheitlich ;)
 

Fu3L

Top Contributor
Das passiert ja mittels drawPolyline. Weder die Schleife, wo ers in die Punkte füllt, noch die Schleife (die nur einen Durchlauf macht) beim Zeichnen ist nötig. Letztere wird erst bei mehreren Linien nötig.
 

Michael...

Top Contributor
arcuscosinus statt cosinus

Ich würde die Blitze in eigene Objekt auslagen in einer Richtung berechnen und beim Zeichnen einfach das Graphics Objekt verschieben und rotieren

Ist länger geworden als gedacht:
Java:
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.RenderingHints;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JFrame;
import javax.swing.JPanel;
public class LightningBall extends JFrame {
	public LightningBall() {
		this.add(new LightningField());
	}
	
	class LightningField extends JPanel implements Runnable {
		private Ball ball;
		private Lightning[] light;
		private volatile boolean active = false;
		private volatile int index = 0;
		
		public LightningField() {
			ball = new Ball(new Point(20, 20), 50);
			light = new Lightning[5];
			for (int i=0; i<light.length; i++)
				light[i] = new Lightning();
			
			this.addMouseListener(new MouseAdapter() {
				public void mouseClicked(MouseEvent evt) {
					if (evt.getButton()==MouseEvent.BUTTON3) {
						ball.setCenter(evt.getPoint());
						repaint();
					}
				}

				public void mousePressed(MouseEvent evt) {
					if (evt.getButton()==MouseEvent.BUTTON1) {
						for (Lightning l : light)
							l.calculateLightning(ball, evt.getPoint());
						active = true;
						new Thread(LightningField.this).start();
					}
				}

				public void mouseReleased(MouseEvent evt) {
					if (evt.getButton()==MouseEvent.BUTTON1) {
						active = false;
						repaint();
					}
				}
			});
		}
		
		public void run() {
			while(active) {
				index++;
				index %=light.length;
				repaint();
				try {
					Thread.sleep(20);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
		
		public void paintComponent(Graphics g) {
			super.paintComponent(g);
			ball.paint(g);
			if (active) {
				light[index].drawLightning(g);
			}
		}
	}
	
	class Ball {
		private Point center;
		private int dia;
		
		public Ball(Point center, int dia) {
			this.center = new Point(center);
			this.dia = dia;
		}
		
		public void setCenter(Point p) {
			center.x = p.x;
			center.y = p.y;
		}
		
		public Point getCenterPoint() {
			return new Point(center);
		}
		
		public int getDiameter() {
			return dia;
		}
		
		public void paint(Graphics g) {
			int d2 = dia/2;
			g.drawOval(center.x-d2, center.y-d2, dia, dia);
		}
	}
	
	class Lightning {
		private Ball origin;
		private List<Integer> x, y;
		private double orientation;
		
		public Lightning() {
			x = new ArrayList<Integer>();
			y = new ArrayList<Integer>();
		}
		
		public void calculateLightning(Ball ball, Point end) {
			this.origin = ball;
			x.clear();
			y.clear();
			Point p = origin.getCenterPoint();
			int oX = p.x;
			int oY = p.y;
			int dia = origin.getDiameter();
			
			double dx = end.x - oX;
			double dy = end.y - oY;
			int limit = (int)Math.sqrt(dx*dx + dy*dy); 
			orientation = Math.acos(dx/Math.sqrt(dx*dx + dy*dy));
			if (dy<0)
				orientation *=-1;
			
			x.add(dia/2);
			y.add(0);
			int cX = dia/2;
			int cY = 0;
			while(cX< limit-20) {
				cX += (int)(Math.floor(Math.random()*20));
				cY += 10 - (int)(Math.floor(Math.random()*20));
				x.add(cX);
				cY = cY>dia/2?dia/2:cY;
				cY = -cY>dia/2?-dia/2:cY;
				y.add(cY);
			}
			x.add(limit);
			y.add(0);
		}
		
		public void drawLightning(Graphics g) {
			if (origin==null)
				return;
			Graphics2D g2 = (Graphics2D)g.create();
			g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
			g2.translate(origin.center.x, origin.center.y);
			g2.rotate(orientation);
			for (int i=1; i<x.size(); i++)
				g2.drawLine(x.get(i-1), y.get(i-1), x.get(i), y.get(i));
			g2.dispose();
		}
	}
	
	public static void main(String[] args) {
		JFrame frame = new LightningBall();
		frame.setBounds(0, 0, 500, 300);
		frame.setLocationRelativeTo(null);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setVisible(true);
	}
}
 

0x7F800000

Top Contributor
Hab mal vor hundert jahren Spaßeshalber kleine "Blitz-Animation" programmiert, vielleicht hilft's was...

Java:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Lightning extends JPanel implements MouseMotionListener{
	
	//ScreenCoords (Point2D cannot be instantiated blah blah blah=no idea=wtf?)
	private static class ScreenCoords{
		public int x,y;
		public ScreenCoords(int _x, int _y){
			x=_x; y=_y;
		}
		public ScreenCoords add(ScreenCoords a){ return new ScreenCoords(x+a.x,y+a.y); }
		public ScreenCoords sub(ScreenCoords a){ return new ScreenCoords(x-a.x,y-a.y); }
		public ScreenCoords mul(int a){ return new ScreenCoords(x*a,y*a); }
		public ScreenCoords div(int a){ return new ScreenCoords(x/a,y/a); }
		public int getLength(){ return (int)Math.sqrt(x*x+y*y); }
		public ScreenCoords getOrtho(){ return new ScreenCoords(-y,x); }
	}
	
	//Node-struct
	private static class Node{
		//member vars
		private boolean isLeaf;
		private Node[] childNodes;
		private ScreenCoords[] vertices;
		
		//final static
		private final static int MIN_CHILDNODES=3, MAX_ADDITIONAL_CHILDNODES=3;
		private final static int MIN_BIFURCATION=1, MAX_ADDITIONAL_BIFURCATION=1;
		
		//constructor
		public Node(ScreenCoords start, ScreenCoords end, int level, boolean isBifurcation){
			if(level==0){
				//end of recursion, creating leaf node
				isLeaf=true;
				vertices=new ScreenCoords[2];
				vertices[0]=start; vertices[1]=end;
			}else{
				isLeaf=false;
				//decide how many child nodes to create
				int numberOfChildNodes=
					MIN_CHILDNODES+(int)(Math.random()*MAX_ADDITIONAL_CHILDNODES+1);
				
				
				int numberOfBifurcationNodes=(isBifurcation)?(0):
					(MIN_BIFURCATION+(int)(Math.random()*(MAX_ADDITIONAL_BIFURCATION+1)));
				
				//allocate space for all the nodes
				childNodes=new Node[numberOfChildNodes+numberOfBifurcationNodes];
				
				//create vertices for child nodes
				ScreenCoords[] childVertices=new ScreenCoords[numberOfChildNodes+1];
				
				
				
				//first and last vertices already exist: its start and end of parent node
				childVertices[0]=start; childVertices[childVertices.length-1]=end;
				
				//creating vertices for the child nodes
				ScreenCoords connection=end.sub(start);
				ScreenCoords ortho=connection.getOrtho().div(12);
				double randomConnectionDistance;
				for(int i=1; i<numberOfChildNodes; i++){
					randomConnectionDistance=3*(Math.random()-0.5);
					childVertices[i]=
					start.add(connection.mul(i).div(numberOfChildNodes)
						 .add(new ScreenCoords((int)(ortho.x*randomConnectionDistance),
								 				(int)(ortho.y*randomConnectionDistance))));
				}
				
				//adding the child nodes to the list
				for(int i=0; i<numberOfChildNodes; i++){
					childNodes[i]=new Node(childVertices[i], childVertices[i+1], level-1, false);
				}
				
				//bifurcations: the first vertex is always "start"
				//and the second vertex is always random
				double randomRadius, randomAngle, baseAngle=Math.atan2(connection.y, connection.x);
				int radius=connection.getLength()*3/numberOfChildNodes;
				for(int i=0; i<numberOfBifurcationNodes; i++){
					randomRadius = radius*(1+Math.random())/1.5;
					randomAngle = baseAngle + Math.random()*Math.PI/3-Math.PI/6;
					childNodes[i+numberOfChildNodes]=
						new Node(start,start.add(new ScreenCoords((int)(randomRadius*Math.cos(randomAngle)),
														(int)(randomRadius*Math.sin(randomAngle)))),
														level-1,true);
				}
			}
		}//end of constructor
		
		public void paint(Graphics g){
			if(isLeaf){
				g.drawLine(vertices[0].x, vertices[0].y, vertices[1].x, vertices[1].y);
			}else{
				for(int i=0; i<childNodes.length; i++){
					childNodes[i].paint(g);
				}
			}
		}
	}//end of Node-class definition
	
	//auto-repaint thread
	private static class RepaintThread extends Thread{
		private Lightning lightningPanel;
		public RepaintThread(Lightning _lightningPanel){
			lightningPanel=_lightningPanel;
		}
		public void run(){
			while(true){
				
				
				if(Math.random()>0){
					lightningPanel.lightningOn=true;
				}
				lightningPanel.repaint();
				
				try{
					sleep(100);
				}catch(InterruptedException e){}
			}
		}
	}
	
	//member vars
	//root Node
	private Node root;
	private int mouseX,mouseY;
	public boolean lightningOn;
	
	//constructor
	public Lightning(){
		super();
		mouseX=mouseY=100;
		addMouseMotionListener(this);
		lightningOn=false;
		
		RepaintThread repaintThread=new RepaintThread(this);
		repaintThread.start();
	}
	
	//paint
	public void paint(Graphics g){
		
		if(lightningOn){
			g.setColor(new Color(0,150,200,80));
			g.fillRect(0, 0, getWidth(), getHeight());
			g.setColor(new Color(0,255,255,255));
			root=new Node(new ScreenCoords(50,50), 
							new ScreenCoords(mouseX, mouseY), 5, false);
			root.paint(g);
		}else{
			g.setColor(new Color(0,0,0,20));
			g.fillRect(0, 0, getWidth(), getHeight());
		}
		lightningOn=false;
	}
	
	//mouse motion listener
	public void mouseMoved(MouseEvent e){
		mouseX=e.getX(); mouseY=e.getY();
	}
	public void mouseDragged(MouseEvent e){}
	//main
	public static void main(String[] args){
		JFrame f=new JFrame("Lightning hits the cursor");
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setSize(500,500);
		f.getContentPane().add(new Lightning());
		f.setVisible(true);
	}
}
 

Marco13

Top Contributor
Als ich den Letzten Autor gesehen habe, hab' ich mir schon gedacht: Ah, da kommt jetzt wieder so was ... :eek: (Und ich hatte Recht... :D )

Den "LightningTest", den ich für http://www.java-forum.org/allgemeine-java-themen/105065-blitz-zeichnen-2-a-2.html mal zusammengestümpert hatte, erspare ich euch, und mir damit die Schmach :oops:

Aber noch ein Klug-Häufchen hinterher, für's Ego:
Point2D point = new Point2D.Float(x,y);
bzw
Point2D point = new Point2D.Double(x,y);
 

0x7F800000

Top Contributor
Als ich den Letzten Autor gesehen habe, hab' ich mir schon gedacht: Ah, da kommt jetzt wieder so was ... :eek: (Und ich hatte Recht... :D )
Nja, sorry, das ist wirklich schon ziemlich alt, so würde ich das heute natürlich nicht schreiben, aber ich find' es sieht trotzdem ein bisschen natrlicher aus, als im ersten Screenshot... Eine ordentliche Simulation von solchen fraktalen distributionswertigen Strömen würde mich übrigens mal sehr interessieren, da kann man bestimmt dicke Bücher drüber schreiben.
 
A

abfl

Gast
Hey Leute,
ich hab mir eure Posts jetzt paar mal durchgelesen und auch bei Google gesucht, aber ich komme einfach nicht weiter.
Java:
                double max_range = Math.sqrt(Math.pow(creep.pos_x-tower.pos_x, 2)+Math.pow(creep.pos_y-tower.pos_y, 2));
                double cur_range = 0;
                double angle = Math.atan2(creep.pos_y - tower.pos_y, creep.pos_x - tower.pos_x);
                
                Vector poly = new Vector();
                int dx, dy, i, polysize;
                int x = tower.pos_x+16;
                int y = tower.pos_y+16;
          
                //Blitzpolygon berechnen
                poly.addElement(new Point(x,y));
                polysize = 1;
                while(cur_range < max_range) {
                    dx = (int)(Math.cos(angle) * Math.floor(Math.random()*10));
                    dy = (int)(Math.sin(angle) * Math.floor(Math.random()*10));
                    x += dx;
                    y += dy;
                    poly.addElement(new Point(x,y));
                    ++polysize;
                    cur_range = cur_range + Math.floor(Math.random()*10);
                }
                //Blitzvector in Koordinaten-Arrays umwandeln
                int xpoints[] = new int[poly.size()];
                int ypoints[] = new int[poly.size()];
                for(i = 0; i < polysize; ++i) {
                    Point p = (Point)poly.elementAt(i);
                    xpoints[i] = p.x;
                    ypoints[i] = p.y;
                }
                //Blitz zeichnen
                g.setColor(Color.white);
                g.drawPolyline(xpoints, ypoints, polysize);
So habe ich es jetzt, funktioniert auch schon ganz gut, aber es gibt folgende Probleme:
- Wenn der Winkel 0, 90, 180 oder 270 Grad ist dann ist der Blitz nurnoch ein Strich... Bei 45, 135... Grad ist er am "größten" und wird gegen 0, 90, 180... Grad immer kleiner.
- Ich weiß nicht, wie ich es machen muss, damit der Blitz am Ende auf einen Punkt zuläuft. Wenn ich am Ende xpoints[polysize] = creep.pos_x mache, bekomm ich einen Fehler.

Ich hoffe es kann mir jemand weiterhelfen! lg abfl :)
 

Cola_Colin

Top Contributor
Hier wurden mehrere Codebeispiele gepostet oder verlinkt, teils mit komplett fertigen Methoden, die du nur noch aufrufen musst.
Hatte noch ein Beispiel mit meinem Blitzcode gebastelt, hier ist es:

Java:
import java.awt.Point;
import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Stroke;
import java.awt.geom.Point2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
import static java.lang.Math.*;

/**
 *
 * @author Colin Clausen
 */
public class Lightning extends JFrame {

    /**
     * Erzeugt einen Blitzeffekt zwischen den Punkten (x/y) und (x2/y2)
     * @param g Der Graphics Kontext, auf dem gezeichnet wird.
     * @param x x-Koordinate von Startpunkt
     * @param y y-Koordinate von Startpunkt
     * @param x2 x-Koordinate von Endpunkt
     * @param y2 y-Koordinate von Endpunkt
     * @param factor Angabe zum Verhältnis von Knickpunkten zu Länge.
     * Kleine Werte führen zu sehr vielen Knickpunkten und teils MASSIVER Rechenlast.
     * @param straightness Angabe, wie stark die Abweichung pro Punkte max werden kann.
     * @param thickness Dicke des Blitzes.
     */
    public static void flash(Graphics2D g, int x, int y, int x2, int y2, float factor, int straightness, int thickness) {
	// Erzeuge das Polygon
	int points = (int) round(Point2D.distance(x, y, x2, y2) / factor);
	int xpoints[] = new int[points + 1];
	int ypoints[] = new int[points + 1];
	float dX = x2 - x;
	float dY = y2 - y;
	dX /= points;
	dY /= points;
	xpoints[0] = x;
	ypoints[0] = y;
	for (int i = 1; i < points; i++) {
	    xpoints[i] = (int) round(x + (dX * i + straightness * 2 * Math.random() - straightness));
	    ypoints[i] = (int) round(y + (dY * i + straightness * 2 * Math.random() - straightness));
	}
	xpoints[points] = x2;
	ypoints[points] = y2;

	// Zeichne Blitz
	int dR = 255 / thickness;
	g.setColor(Color.WHITE);
	Composite aC = g.getComposite();
	Stroke stroke = g.getStroke();
	for (int i = thickness; i > 0; i -= 3) {
	    g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
		    0.75f - (0.5f / thickness * i)));
	    g.setStroke(new BasicStroke(i, BasicStroke.CAP_ROUND,
		    BasicStroke.JOIN_ROUND));
	    g.drawPolyline(xpoints, ypoints, xpoints.length);
	    g.setColor(new Color(dR * i, 255, 255));
	}
	g.setComposite(aC);
	g.setStroke(stroke);
    }

    private static class LightningPanel extends JPanel {

	int x;
	int y;

	public LightningPanel() {
	    this.setBackground(Color.BLACK);
	}

	@Override
	protected void paintComponent(Graphics g) {
	    super.paintComponent(g);

	    Point p;
	    if ((p = this.getMousePosition()) != null) {
		x = p.x;
		y = p.y;
	    }

	    flash((Graphics2D) g, this.getWidth() / 2, this.getHeight() / 2, x, y, 2f, 10, 5);
	}
    }

    public Lightning() {
	add(new LightningPanel());
    }

    public static void main(String[] args) throws InterruptedException {
	Lightning l = new Lightning();
	l.setSize(400, 400);
	l.setLocationRelativeTo(null);
	l.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	l.setVisible(true);

	while (true) {
	    Thread.sleep(100);
	    l.repaint();
	}
    }
}

Die Arbeitsweise ist simpel:
Es werden zwischen dem Start und dem Ziel eine Reihe von Punkten verteilt und diese dann zufällig ein wenig verschoben, danach dann mit einer Linie verbunden.
Volia ein "Blitz".

Kein Bedarf für Winkelrechnung.

Realistischere und aufwendiger zu berechnende Blitze gibt es bei 0x7F800000
 

Fu3L

Top Contributor
Noch ein kleiner Hinweis:

xpoints[polysize] = creep.pos_x mache, bekomm ich einen Fehler.

Hier wäre ein Posten des Fehlers gut gewesen, nehme aber an, das es eine ArrayIndexOutOfBoundsException war. xpoints[polysize-1] = creep.pos_x hätte wahrhscinelich funktioniert.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
J Auf einem JLabel Linien Malen Java Basics - Anfänger-Themen 1
milan123 das ist meine aufgabe ich hab das problem das bei mir Wenn ich die Richtung der Linien verändern will und drei davon sind richtig, verändere ich die 4 Java Basics - Anfänger-Themen 3
P JFrame, Linien zeichnen, MouseListener Java Basics - Anfänger-Themen 2
R Warum werden hier nur die grün und orangen Linien ausgegeben und der Rest unten nicht? Java Basics - Anfänger-Themen 5
B Wie kann ich Linien rekursiv zeichnen? Java Basics - Anfänger-Themen 4
F Linien und Kurven erkennen Java Basics - Anfänger-Themen 2
H Grafikaufgabe mit Linien und Kreisen Java Basics - Anfänger-Themen 5
P Per Button, Linien Hinzufügen und bearbeiten Java Basics - Anfänger-Themen 30
P Linien in 2.5D Java Basics - Anfänger-Themen 8
C Graphics2D - DrawRect - Warum Linien teilweise gefüllt? Java Basics - Anfänger-Themen 12
R Kurze Linien alle x-Pixel Java Basics - Anfänger-Themen 2
B systemausgelöstes Uebermalen von Linien Java Basics - Anfänger-Themen 7
S linien Java Basics - Anfänger-Themen 3
N Linien zeichnen Java Basics - Anfänger-Themen 4
J SWING UI Designer und zeichnen Java Basics - Anfänger-Themen 4
luggas89 Mit Jframe live zeichnen Java Basics - Anfänger-Themen 4
K 3D Fläche Zeichnen Java Basics - Anfänger-Themen 2
J Bild auf Hintergrundbild zeichnen Java Basics - Anfänger-Themen 5
R Iterativ zeichnen Java Basics - Anfänger-Themen 1
T Java Swing - Dreieck zeichnen mit verschiedenen Variablen Java Basics - Anfänger-Themen 8
KogoroMori21 Mit einer Schleife eine Treppe zeichnen Java Basics - Anfänger-Themen 29
V Speicherzustand zeichnen Java Basics - Anfänger-Themen 0
O Klappt nicht: Ein Panel neu zeichnen Java Basics - Anfänger-Themen 3
CptK Interface Bilder mit Graphics g zeichnen Java Basics - Anfänger-Themen 7
B Java JFrame zeichnen Java Basics - Anfänger-Themen 4
Mosquera f(x)=x² zeichnen Java Basics - Anfänger-Themen 5
J Graphen in Java zeichnen Java Basics - Anfänger-Themen 11
L Anfängerin möchte Linie zeichnen Java Basics - Anfänger-Themen 8
D JPanel mehrere Formen zeichnen Java Basics - Anfänger-Themen 5
S Zeichnen mit Wiederholungen Java Basics - Anfänger-Themen 12
P Einen String mittig zeichnen? Java Basics - Anfänger-Themen 1
T Koordinatensystem zeichnen - Variablen merken? Quadratische Funktion zeichnen? Java Basics - Anfänger-Themen 5
M Ein Bild durch Objekterzeugung zeichnen Java Basics - Anfänger-Themen 5
W Wie kann ich in Java eine Kurve aus Punkten zeichnen? Java Basics - Anfänger-Themen 25
snipesss Linie zeichnen ohne extra Klasse? Java Basics - Anfänger-Themen 3
C Umrisse von Bilddateien mithilfe Polygonen zeichnen Java Basics - Anfänger-Themen 5
G Aus einem Code ein Sequenzdiagramm zeichnen? Java Basics - Anfänger-Themen 1
K Rechtecke rekursiv zeichnen Java Basics - Anfänger-Themen 20
V Quadrate rekursiv zeichnen Java Basics - Anfänger-Themen 7
B Java Graphen zeichnen - Brauche Hilfe Java Basics - Anfänger-Themen 9
C Schleifenaufgabe - Molekül zeichnen Java Basics - Anfänger-Themen 6
K Ungenauigkeit beim Zeichnen von Funktionen Java Basics - Anfänger-Themen 6
H Linie zeichnen... Java Basics - Anfänger-Themen 16
N Treppe zeichnen Java Basics - Anfänger-Themen 1
M Quadrat zeichnen einfach bitte! Java Basics - Anfänger-Themen 2
P Shape Zeichnen klappt nicht - einlesen der Breite/Höhe schon Java Basics - Anfänger-Themen 1
M in Java zeichnen Java Basics - Anfänger-Themen 2
J JLabel Icon neu zeichnen Java Basics - Anfänger-Themen 2
J Rechteck zeichnen mit Canvas Java Basics - Anfänger-Themen 7
D Zeichnen, Schleifen Java Basics - Anfänger-Themen 7
S Zeichnen , Schleifen Java Basics - Anfänger-Themen 4
S Rechteck zeichnen Java Basics - Anfänger-Themen 2
S Ein Graphics Obejct mehrmals mit denselben Eigenschaften zeichnen lassen?!?!? Java Basics - Anfänger-Themen 4
S Wo beginnt ein Draw String zu zeichnen. Java Basics - Anfänger-Themen 4
S Paint Anwendung: Freihandlinien zeichnen Java Basics - Anfänger-Themen 4
llabusch Layout neu zeichnen lassen Java Basics - Anfänger-Themen 2
A Histogramm zeichnen Java Basics - Anfänger-Themen 2
S Punkt in Java zeichnen Java Basics - Anfänger-Themen 14
E Dreieck zeichnen Java Basics - Anfänger-Themen 3
gamebreiti Methoden JPanel nach clearAll() und add neu zeichnen Java Basics - Anfänger-Themen 1
T Baum mit Turtle zeichnen Java Basics - Anfänger-Themen 2
C Hilfe beim Zeichnen Java Basics - Anfänger-Themen 8
D Haus zeichnen Java Basics - Anfänger-Themen 4
K Methoden Objekt auf JFrame zeichnen Java Basics - Anfänger-Themen 16
H 27 Kreise Zeichnen Java Applet Java Basics - Anfänger-Themen 2
S Problem mit "Zeichnen auf Kommando" Java Basics - Anfänger-Themen 2
M Double Punkte Zeichnen Java Basics - Anfänger-Themen 7
S Funktionen zeichnen Java Basics - Anfänger-Themen 2
2 Bild auf JApplet zeichnen Java Basics - Anfänger-Themen 18
R 2D Grafik zeichnen Java Basics - Anfänger-Themen 4
F Line zeichnen und Werte ändern Java Basics - Anfänger-Themen 6
B Grafik zeichnen Java Basics - Anfänger-Themen 25
B Erste Schritte Weihnachtsbaum zeichnen Java Basics - Anfänger-Themen 6
N Per Button Kreis zeichnen Java Basics - Anfänger-Themen 8
T mehrere Punkte zeichnen ohne löschung Java Basics - Anfänger-Themen 4
J Für 3 Sekunden etwas bestimmtes zeichnen Java Basics - Anfänger-Themen 8
C Kreis nach Mausklick zeichnen Java Basics - Anfänger-Themen 5
C Auf Button-Druck zeichnen Java Basics - Anfänger-Themen 2
R Methoden Zeichnen auf Button-Druck durch Paint-Methode Java Basics - Anfänger-Themen 2
D Klassen Zeichnen von Figuren mittels vorgegebener Klasse Java Basics - Anfänger-Themen 3
J Schachbrett zeichnen Java Basics - Anfänger-Themen 9
J Innerhalb der Border zeichnen Java Basics - Anfänger-Themen 9
J Hoher Speicherverbrauch beim Zeichnen von Images aus einer ArrayList Java Basics - Anfänger-Themen 10
U Kreis um Textfelder zeichnen Java Basics - Anfänger-Themen 4
R Balkendiagramm zeichnen Java Basics - Anfänger-Themen 14
J Bild anhand von Koordinaten zeichnen Java Basics - Anfänger-Themen 10
B GUI Parkplatz zeichnen Java Basics - Anfänger-Themen 10
S Mehrere Zeichnungen zeichnen Java Basics - Anfänger-Themen 16
A Linie Zeichnen Applet mit Double Wert Java Basics - Anfänger-Themen 3
F Image übertragen und zeichnen Java Basics - Anfänger-Themen 8
P Funktion zeichnen Java Basics - Anfänger-Themen 6
Q Zeichnen außerhalb der paint-methode Java Basics - Anfänger-Themen 7
F zeichnen in JPanel Java Basics - Anfänger-Themen 7
T Transparente Bilder mit Graphics zeichnen Java Basics - Anfänger-Themen 17
T Sterne zeichnen Java Basics - Anfänger-Themen 4
M Bilder laden und zeichnen Java Basics - Anfänger-Themen 3
G Polygon in Frame zeichnen Java Basics - Anfänger-Themen 3
S X Zeichnen als Muster ausgeben Java Basics - Anfänger-Themen 5
P Kurven zeichnen Java Basics - Anfänger-Themen 5
I dauerhaftes zeichnen Java Basics - Anfänger-Themen 3

Ähnliche Java Themen

Neue Themen


Oben