# Pinball Abprall an einer schrägen Bande



## Endos (22. Mrz 2009)

Hallo,

ich versuche grad Pinball zu programmieren und komm beim Abprall an einer schrägen Bande nicht weiter!
(der Abprall an den senkrechten und horizontalen Begrenzungen ist kein Problem)

(Winkel zu y=0)
geg:
Winkel der schrägen Bande (alpha)
Winkel der Richtung des Balles (betha)

ges: Winkel des Abpralls (gamma)

ich hab mal rumgerechnet und bin auf das gekommen:

gamma = 2*betha + alpha

das stimmt manchmal und manchmal nicht xD

ich rechne das dann auf die Geschwindigkeit des ball hoch:

double x = Math.sin(gamma);
double y = Math.cos(gamma);

double l = Math.sqrt(vy*vy+vx*vx);
vx = x*l;
vy = y*l;

Was ist da falsch?? Hab das Gefühl, dass es iwas mit den vorzeichen zu tun hat...


----------



## 0x7F800000 (22. Mrz 2009)

*Tipp 1:* Ausrichtung der Wände sollte keinerlei auswirkungen auf die Berechnungsvorschrift haben
*Tipp 2:* Schmeiß um Himmels Willen alle diese merkwürdigen Winkeln aus deinem Programm raus, das ist ineffizient und fehleranfällig.

Stattdessen musst du lediglich
1) Kollisionen mit beliebig gedrehten wänden feststellen können. Das ist recht billig wenn du lediglich den Abstand zwischen geraden und Punkten berechnen kannst.
2) Bei einer kollision zerlegst du die geschwindigkeit in einer zur Wand orthogonale und parallele Komponente. Die parallele lässt du einfach sein wie sie ist, die orthogonale multiplizierst du mit -1: fertig. Addieren, Subtrahieren, Multiplizieren, alles bekannt aus der Grundschule, keine Winkeln und Kosinüsse weit und breit.


----------



## HannsW (22. Mrz 2009)

Rechnest Du denn mit Winkeln, oder mit den Steigungen der Bahngeraden?
Och würde letzteres vorziehen, denn selbst bei "Kurven" kannst Du im Moment des Aufpralles mit Steigungen rechnen.
Und das beim Aufprall gilt 
Einfall == Ausfallswinkel und Steigung = Steigung * -1
Kannst Du doch dei Steigung "des Balles" ( Winkel zur x-Achse ) und der der schrägen Wand zur x-Achse erhalten, und addieren.
Das nur mal so ins Unreine gedacht


----------



## 0x7F800000 (22. Mrz 2009)

nichts für ungut, aber:


HannsW hat gesagt.:


> Das nur mal so ins Unreine gedacht


das trifft's ziemlich gut


----------



## HannsW (22. Mrz 2009)

0x7F800000 hat gesagt.:


> das trifft's ziemlich gut



???:LWie meinste das denn?


----------



## Marco13 (22. Mrz 2009)

"Steigung" ist so eine Sache... bei senkrechten Linien...


----------



## 0x7F800000 (22. Mrz 2009)

Wörter aus der Menge {"Steigung","Winkel"} sollte man mit Wörtern "Spieleprogrammierung" und "Kollisionserkennung" nicht in einem Satz verwenden 

Was für theoretische Herleitungen toll ist, muss nicht gut zum implementieren sein. Du bist hier nicht in Physikunterricht. Das ist ein Spiel das auf einem dummen Computer läuft. Dem kannst du nicht einfach sagen _*"O.b.d.A. sei die Wand entlang der X-Achse ausgerichtet, und die Kollision finde im Punkt (0,0) statt"*_. Alle diese Ansätze mit Steigungen und sonstigen Krempel sind für Spieleprogrammierung unbrauchbar. Da verreckt man dreimal, bis man alle singulären Ausnahmefälle verarztet hat.

Oh man... Muss ich jetzt ein beispiel basteln damit die mir glauben? ;( 
Ja, ich mach's mal^^
Edit: ne, ich geh erstma Tee trinken, danach mach ich's vielleicht^^


----------



## Endos (22. Mrz 2009)

0x7F800000 hat gesagt.:


> *Tipp 1:* Ausrichtung der Wände sollte keinerlei auswirkungen auf die Berechnungsvorschrift haben
> *Tipp 2:* Schmeiß um Himmels Willen alle diese merkwürdigen Winkeln aus deinem Programm raus, das ist ineffizient und fehleranfällig.
> 
> Stattdessen musst du lediglich
> ...



Hät ich die Idee nur auch gehabt xD
Das klingt viel logischer als mein Code^^

zu 1)
Ich hab die Kollision mittels einer Linie von Punkt(vorher) zu Punkt(nachher) und dazwischen jeden einzelnen Pixel auf der Linie abgefragt, ob er auf einer bande liegt 
Wahrscheinlich geht das viel einfacher, gell? 

Ich versuch das 2) jetzt mal hinzukriegen =)


----------



## 0x7F800000 (22. Mrz 2009)

Endos hat gesagt.:


> Ich hab die Kollision mittels einer Linie von Punkt(vorher) zu Punkt(nachher) und dazwischen jeden einzelnen Pixel auf der Linie abgefragt, ob er auf einer bande liegt
> Wahrscheinlich geht das viel einfacher, gell?


Einfacher?! :noe:
1) es muss (und wird wohl auch nicht) bei schrägen geraden Funktionieren, weil diese sehr selten exakt einen Pixel treffen
2) es ist O(n) wo nur O(1) nötig ist
3) wie stellst du denn die geometrischen Objekte dar? Sogar in der Standard API gibt's schon irgendwo eine Methode zum berechnen eines Schnittpunktes zweier geradenabschnitte.

edit:
ach egal, jetzt hast du mich auf die idee gebracht, jetzt will ich das umsetzen, sonst zappele ich nur rum und mach eh nichts sinnvolles^^


----------



## Endos (22. Mrz 2009)

0x7F800000 hat gesagt.:


> Einfacher?! :noe:
> 1) es muss (und wird wohl auch nicht) bei schrägen geraden Funktionieren, weil diese sehr selten exakt einen Pixel treffen
> 2) es ist O(n) wo nur O(1) nötig ist
> 3) wie stellst du denn die geometrischen Objekte dar? Sogar in der Standard API gibt's schon irgendwo eine Methode zum berechnen eines Schnittpunktes zweier geradenabschnitte.
> ...



3) Ich mach n Bild in photoshop, machs in schwarz weiß, mein programm liest das ein und jeder Schwarze Punkt ist ne bande und jeder weiße nicht  So kann jeder sein eigenes Feld machen 
2) was meinst du damit?

Noch was, wie zerleg ich die geschwindigkeit(vx und vy) in ne parallel und senkrecht zur Bande stehende Geschwindigkeit? Mit Skalarprodukt?


----------



## 0x7F800000 (22. Mrz 2009)

Endos hat gesagt.:


> Noch was, wie zerleg ich die geschwindigkeit(vx und vy) in ne parallel und senkrecht zur Bande stehende Geschwindigkeit? Mit Skalarprodukt?


Ja, normalen- und orthogonalen vektor am besten einfach abspeichern, und bei ejder kollision zwei skalarprodukte ausrechnen...

Das mit schwarzweiß-Bild usw ist imho eine echt üble idee...


----------



## Endos (22. Mrz 2009)

0x7F800000 hat gesagt.:


> Ja, normalen- und orthogonalen vektor am besten einfach abspeichern, und bei ejder kollision zwei skalarprodukte ausrechnen...
> 
> Das mit schwarzweiß-Bild usw ist imho eine echt üble idee...



"üble Idee"? gut oder schlecht? 

ehm, könntest mir des vllt erklären mit m skalarprodukt?
hab damit noch nie gearbeitet, ist mein erstes Spiel^^
hab gelesen, dass das skalarprodukt null sein muss, aber kapier nicht wie ich da anfangen soll...sry


----------



## 0x7F800000 (22. Mrz 2009)

Endos hat gesagt.:


> gut oder schlecht?


schlecht^^ 



> ehm, könntest mir des vllt erklären mit m skalarprodukt?
> hab damit noch nie gearbeitet, ist mein erstes Spiel^^
> hab gelesen, dass das skalarprodukt null sein muss, aber kapier nicht wie ich da anfangen soll...sry


Hat nix mit Spielen zu tun: lern lineare Algebra  

Idee ist recht simpel (sowohl zu verstehen als auch zu beweisen): Wenn du eine Orthonormalbasis {e1,e2} hast (d.h. eine basis aus vektoren, die orthogonal aufeinander stehen und länge 1 haben) dann kannst du für einen Vektor x ganz schnell die darstellung
x=a*e1+ b*e2
d.h. die koordinaten (a,b) [a,b reelle Zahlen] von x bzgl der basis {e1,e2} finden, indem du einfach nur ausrechnest:
a=x*e1
b=x*e2  
wobei hier das skalarprodukt gemeint ist.

Konkreter: wenn du einen Strich hast, und willst davon den ball abprallen lassen, dann stellst du diese linie erstmal so dar, dass du den normalenvektor ("ortho") und einen zur geraden "parallelen" vektor hast, wobei beide normiert sind.
Dann ist die orthogonale komponente der geschwindigkeit einfach nur
vOrtho=v*ortho (reelle zahl)
wobei hier wieder das skalarprodukt gemeint ist. 
Diese komponente ziehst du einfach ab, und addierst nochmal das negative druf.
Dasselbe wie 
vNeu= v-ortho*2*vOrtho 
zu rechnen.

Hab dazu ein kleines minimalbeispiel gebastelt, kannst dir das Paket hier runterladen:
RapidShare: Easy Filehosting

An der name der Klasse "GameAndCanvas" siehst du ja teilweise schon, dass es übler hack ist, alles in eins gestopft^^

Sollte beim ausführen etwa so aussehen:





...wobei die kleine Kugel da rumdotzt. Brauchst dir im prinzip nur die interaktionsmethoden der Obstacle-Implementierunegn anzuschauen, alles andere ist Projektdesign, und darauf habe ich hier nicht sonderlich geachtet.

edit: hab eine kleine unschönheit bei der Kollision mit Polygonen abgeändert, und nebenbei eine "schönere" Beispielform gebastelt.


----------



## Endos (23. Mrz 2009)

wow, cool =)
jetzt kapier ich des 
und jetzt komm ich mir dumm vor xD

danke, für die ganze Arbeit!!!


----------



## 0x7F800000 (23. Mrz 2009)

Endos hat gesagt.:


> wow, cool =)
> jetzt kapier ich des


Wie? Echt jetzt? :shock: War eigentlich nicht so geplant, hab da kaum drei zeilen Kommentar reingeschrieben... 

Das einzige was du aus diesem code entnehmen solltest waren eigentlich folgende zwei Tatsachen:
1) es funktioniert
2) es funktioniert ohne winkeln oder ähnlichen Schrott 
(erzeugung der sternförmigen figuren zählt nicht, ich meine Kollisionen)

den Rest kannst du dir womöglich selber ausdenken (wo du jetzt ja auf dem "richtigen" Pfad bist ) Falls nicht: weiterfragen.


----------



## 0x7F800000 (24. Apr 2009)

Rapid Share hat alles weggeschmissen... Hier nochmal der code, falls den noch einer sehen will:

Klasse für Pfeilchenrechnung in R²:

```
package pinball;
/**
 * 
 * @author 0x7F800000
 */
//2D-Vector that represents a point in cartesian coords

public class Vector2D {
	 
	 //xy
	 public double x,y;
	 
	 //constructors
	 public Vector2D(){
	    x=y=0.0;
	 }
	 
	 public Vector2D(double _x,double _y){
	    x=_x; y=_y;
	 }
	 
	 public Vector2D(Vector2D v){
	    x=v.x; y=v.y;
	 }
	 
	 //getLength, getSqrLength
	 public double getLength(){
	    return Math.sqrt(x*x+y*y);
	 }
	 
	 public double getSqLength(){
	    return x*x+y*y;
	 }
	 
	 // v+v v-v
	 public Vector2D add(Vector2D v){
	    return new Vector2D(x+v.x, y+v.y);
	 }
	 
	 public Vector2D sub(Vector2D v){
	    return new Vector2D(x-v.x, y-v.y);
	 }
	 
	 //v*d v/d
	 public Vector2D mul(double d){
	    return new Vector2D(x*d, y*d);
	 }
	 
	 public Vector2D div(double d){
	    return new Vector2D(x/d, y/d);
	 }
	 
	 //scalar and cross products
	 public double dot(Vector2D v){
	    return x*v.x+y*v.y;
	 }
	 
	 public double cross(Vector2D v){
	    return x*v.y-y*v.x;
	 }
	 
	 public Vector2D getOrtho(){
		 return new Vector2D(-y,x);
	 }
	 
	 //normalize
	 public Vector2D normalize(){
	    return this.div(getLength());
	 }
	 
	 //getCos getSin getAngle
	 public double getCos(Vector2D v){
	    return this.dot(v)/Math.sqrt(this.getSqLength()*v.getSqLength());
	 }
	 
	 public double getSin(Vector2D v){
	    return Math.sqrt(this.cross(v)/(this.getSqLength()*v.getSqLength()));
	 }
	 
	 public double getAngle(Vector2D v){
	    return Math.acos(this.getCos(v));
	 }
	 
	 //some useful static constants and functions
	 public static final Vector2D zero=new Vector2D(0,0);
	 public static final Vector2D eX=new Vector2D(1,0);
	 public static final Vector2D eY=new Vector2D(0,1);
	 
	 @Override
	 public String toString(){
		   return "("+x+","+y+")";
	 }
	 
	 @Override
	 public boolean equals(Object other){
		   return (other!= null 
				   && other instanceof Vector2D 
				   && x==((Vector2D)other).x 
				   && y==((Vector2D)other).y);
	 }
}
```

Ganz simples Interface für objekte die sich selbst irgendwie graphisch darstellen können

```
package pinball;

import java.awt.*;

public interface Paintable{
	void paint(Graphics2D g);
}
```

Klasse die einen beweglichen Ball repräsentiert, der zudem abgebremst und "nach unten" beschleunigt werden kann:

```
package pinball;

import java.awt.*;
import java.awt.geom.*;

public class Ball implements Paintable{
	
	public static final double GRAVITY=-0.05;
	public static final double FRICTION=0;//0.05;
	
	private Vector2D position,velocity;
	private double radius,mass;
	
	public Ball(Vector2D position, Vector2D velocity, double radius,double mass) {
		this.mass = mass;
		this.position = position;
		this.radius = radius;
		this.velocity = velocity;
	}

	public Vector2D getPosition() {	return position;	}
	public Vector2D getVelocity() {	return velocity;	}
	public double getRadius() {	return radius;	}
	public double getMass() {	return mass;	}
	public void setPosition(Vector2D position) {	this.position = position;	}
	public void setVelocity(Vector2D velocity) {	this.velocity = velocity;	}

	public void move(double dt) {
		//ganz billig nach unten beschleunigen...
		velocity.y+=GRAVITY*dt;
		//abbremsen
		velocity=velocity.mul(1-FRICTION*velocity.getSqLength());
		//verschieben
		position=position.add(velocity.mul(dt));
	}
	
	public void paint(Graphics2D g){
		g.setColor(Color.MAGENTA);
		g.fill(new Ellipse2D.Double(position.x-radius,position.y-radius,2*radius,2*radius));
	}
}
```

Hier wird's interessanter: ein Interface für ein Hindernis, das mit dem ball interagieren kann:

```
package pinball;

public interface Obstacle extends Paintable {
	void interact(Ball b);
}
```

Es folgen drei Implementierungen des Hindernis-Interfaces:
-Kugeln (bzw Punkte für r=0)
-Strecken, die an enden keine Kollision erkennen
-Polygonzüge, die aus Strecken und Punkten zusammengebaut sind, und so ziemlich jede beliebig schräge form approximieren können


```
package pinball;

import java.awt.*;
import java.awt.geom.*;

public class Circle implements Obstacle{

	private Vector2D position;
	private double radius, bouncyFactor;
	
	public Circle(Vector2D position, double radius,double bouncyFactor) {
		super();
		this.bouncyFactor = bouncyFactor;
		this.position = position;
		this.radius = radius;
	}

	@Override
	public void interact(Ball ball) {
		Vector2D relativePosition=ball.getPosition().sub(position);
		double radiusSumSq=radius+ball.getRadius();
		radiusSumSq*=radiusSumSq;
		double lengthSq=relativePosition.getSqLength();
		if(lengthSq<radiusSumSq){
			//intersection
			relativePosition=relativePosition.div(Math.sqrt(lengthSq));	//normalize
			double orthoVelocity=relativePosition.dot(ball.getVelocity());
			if(orthoVelocity<0){
				//collision
				ball.setPosition(position.add(relativePosition.mul(radius+ball.getRadius())));
				ball.setVelocity(ball.getVelocity().sub(relativePosition.mul(2*orthoVelocity*bouncyFactor)));
			}
		}
	}
	
	public void paint(Graphics2D g){
		g.setColor(bouncyFactor>=1?Color.GREEN:Color.RED);
		g.draw(new Ellipse2D.Double(position.x-radius,position.y-radius,2*radius,2*radius));
	}
}
```


```
package pinball;

import java.awt.*;
import java.awt.geom.*;

public class LineSegment implements Obstacle{

	private Vector2D start,end, parallel, ortho;
	double length;
	double bouncyFactor;
	
	public LineSegment(Vector2D start, Vector2D end, double bouncyFactor){
		this.start=start;
		this.end=end;
		this.parallel=end.sub(start);
		this.length=parallel.getLength();
		this.parallel=this.parallel.div(this.length);
		this.ortho=parallel.getOrtho();
		
		this.bouncyFactor=bouncyFactor;
	}
	
	@Override
	public void interact(Ball ball) {
		Vector2D relativePosition=ball.getPosition().sub(start);
		double orthoDistance=ortho.dot(relativePosition);
		if(Math.abs(orthoDistance)<ball.getRadius()){
			double parallelDistance=parallel.dot(relativePosition);
			if(0<=parallelDistance && parallelDistance<=length){
				//the primitives intersect
				double orthoVelocity=ball.getVelocity().dot(ortho);
				if(orthoVelocity*orthoDistance<0){
					//collision
					//correct position
					ball.setPosition(start.add(parallel.mul(parallelDistance)).add(ortho.mul(ball.getRadius()*Math.signum(orthoDistance))));
					//reverse orthogonal component of the velocity
					ball.setVelocity(ball.getVelocity().add(ortho.mul(-orthoVelocity*2*bouncyFactor)));
				}
			}
		}
	}
	
	public void paint(Graphics2D g){
		g.setColor(bouncyFactor>=1?Color.GREEN:Color.RED);
		g.draw(new Line2D.Double(start.x,start.y,end.x,end.y));
	}
}
```


```
package pinball;

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

public class Polygon implements Obstacle{

	LinkedList<Obstacle> obstacles;
	
	public Polygon(double bouncyFactor, boolean close, Vector2D... points){
		this.obstacles=new LinkedList<Obstacle>();
		
		Vector2D prev=points[0];
		obstacles.addLast(new Circle(prev,0,bouncyFactor));
		
		for(int i=1; i<points.length; i++){
			obstacles.addFirst(new LineSegment(prev,points[i],bouncyFactor));
			obstacles.addLast(new Circle(points[i],0,bouncyFactor));
			prev=points[i];
		}
		
		if(close){
			obstacles.addFirst(new LineSegment(points[0],points[points.length-1],bouncyFactor));
		}
	}
	
	@Override
	public void interact(Ball b) {
		for(Obstacle o:obstacles) o.interact(b);
	}

	@Override
	public void paint(Graphics2D g) {
		for(Obstacle o:obstacles) o.paint(g);
	}

}
```

Zu guter letzt ist hier eine Main-klasse, in die zugleich der gameloop-thread und der aufbau der Map reingequetscht wurde. Der meiste code ist dazu da, diese merkwürdige Figur auf dem Screenshot zu erzeugen:

```
package pinball;


import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import javax.swing.*;
import java.util.*;

@SuppressWarnings("serial")
public class GameAndCanvas extends JComponent implements Runnable{
	
	java.util.List<Ball> balls;
	java.util.List<Obstacle> obstacles;
	BufferedImage img=new BufferedImage(500,500,BufferedImage.TYPE_INT_ARGB);
	
	public GameAndCanvas(){
		balls=new LinkedList<Ball>();
		balls.add(new Ball(new Vector2D(0.1,0.9),new Vector2D(0.1,0.8), 0.03, 1));
		balls.add(new Ball(new Vector2D(0.1,0.7),new Vector2D(0.1,0.8), 0.03, 1));
		
		obstacles=new LinkedList<Obstacle>();
		
		for(int i=0; i<7; i++){
			obstacles.add(new Circle(new Vector2D(0.4*Math.cos(2*Math.PI*i/7),0.4*Math.sin(2*Math.PI*i/7)),0.1,1));
		}
		
		int numberOfOuterVertices=7;
		double outerRadius=1.1;
		Vector2D[] outerVertices=new Vector2D[numberOfOuterVertices];
		for(int i=0; i<numberOfOuterVertices; i++){
			outerVertices[i]=new Vector2D(
					outerRadius*Math.cos(2*Math.PI*i/numberOfOuterVertices),
					outerRadius*Math.sin(2*Math.PI*i/numberOfOuterVertices));
		}
		obstacles.add(new Polygon(1,true,outerVertices));
		
		int numberOfInnerVertices=22;
		double innerRadius=0.8;
		Vector2D[] innerVertices=new Vector2D[numberOfInnerVertices];
		for(int i=0; i<numberOfInnerVertices; i++){
			innerVertices[i]=new Vector2D(
					innerRadius*(1+0.05*(i%2==0?1:-1))*Math.cos(2*Math.PI*i/numberOfInnerVertices),
					innerRadius*(1+0.05*(i%2==0?1:-1))*Math.sin(2*Math.PI*i/numberOfInnerVertices));
		}
		obstacles.add(new Polygon(1,true,innerVertices));
		
		
	}
	
	public void paintComponent(Graphics graphics){
		Graphics2D g=(Graphics2D)img.getGraphics();
		
		g.setColor(new Color(0,0,0,5));
		g.fillRect(0,0,getWidth(),getHeight());
		
		g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
		g.setTransform(new AffineTransform(200,0,0,-200,250,230));
		g.setStroke(new BasicStroke(0.02f,BasicStroke.CAP_ROUND,BasicStroke.JOIN_ROUND));
		for(Ball b:balls){
			b.paint(g);
		}
		for(Obstacle obstacle:obstacles){
			obstacle.paint(g);
		}
		
		graphics.drawImage(img,0,0,getWidth(),getHeight(),this);
	}
	
	public void run(){
		while(true){
			for(Ball ball:balls){
				ball.move(0.03);
			}
			for(Obstacle obstacle:obstacles){
				for(Ball ball:balls){
					obstacle.interact(ball);
				}
			}
			repaint();
			try{
				Thread.sleep(10);
			}catch(Exception e){
				e.printStackTrace();
			}
			
		}
	}
	
	public static void main(String..._){
		JFrame f=new JFrame();
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setSize(500,500);
		
		GameAndCanvas x=new GameAndCanvas();
		f.getContentPane().add(x);
		f.setVisible(true);
		
		(new Thread(x)).start();
	}
}
```

Das ganze ist keineswegs sauber implementiert, es ist einfach eine kurze Skizze, die minimale Funktionalität für Spielchen mit einem Ball und schrägen Polygonen bereitstellt.


----------



## spyboot (24. Apr 2009)

Weis nicht ob du dass Problem mittlerweile gelöst hast aber ich hab mir mal nen Befehl geschrieben Um zu prüfen ob ein Punkt auf einer Linie liegt (funktioniert ohne schleife nur berechnungen)  sag mir ob du es noch brachst denn such ich mal danach in meinem Datenmüll


----------



## 0x7F800000 (24. Apr 2009)

Sorry dass der Thread wieder hochgekommen ist, der ist eingentlich schon bisschen älter, aber in einem anderen Thread geht's grad um dasselbe, und da dachte ich, dass ich vielleicht mal wenigstens ein kompilierbares funktionierendes beispiel in dem thread hier lasse, falls später jemand ähnliche probleme hat. RapidShare hat sich als keine langfristige lösung erwiesen, deshalb habe ich einfach den ganzen code hier nochmal gepostet.


spyboot hat gesagt.:


> Weis nicht ob du dass Problem mittlerweile gelöst hast


der hat schon alle seine probleme gelöst, der schreibt seit nem monat jedenfalls nichts mehr...


> ich hab mir mal nen Befehl geschrieben Um zu prüfen ob ein Punkt auf einer Linie liegt


wüsste nicht wozu das hier gut sein soll. Für irgendwelche exakten mathematischen-/CAD-/Zeichenprogramme kann das nützlich sein, aber bei spielen ist das selten nötig (jedenfalls für kollisionserkennung unbrauchbar)


> (funktioniert ohne schleife nur berechnungen)


gut so, wo soll man denn da auch eine schleife reinpacken... ???:L


----------



## spyboot (24. Apr 2009)

Endos hat gesagt.:


> Ich hab die Kollision mittels einer Linie von Punkt(vorher) zu Punkt(nachher) und dazwischen jeden einzelnen Pixel auf der Linie abgefragt, ob er auf einer bande liegt
> Wahrscheinlich geht das viel einfacher, gell?



^^Das heist er hatt ne schleife verwendet


----------



## 0x7F800000 (24. Apr 2009)

spyboot hat gesagt.:


> ^^Das heist er hatt ne schleife verwendet


als ob's irgendwie sinnvoller wäre, als einzelne punkte zu prüfen, oder einfach gar nichts zu prüfen...:noe:


----------

