erdeansicht.java

java 开源游戏源码 RISK 联机对战 战棋类

// source: http://n.ethz.ch/student/simonbr/mathinfo_applets_erde.html

package risk.engine.guishared;

import java.awt.event.*;
import java.awt.*;
import java.awt.image.*;
import javax.swing.JPanel;

//////////////////////////////////////////////////////////////
//
// Class Erde: 3d-Darstellung der Erde mit Texture Mapping
//
//////////////////////////////////////////////////////////////

public class ErdeAnsicht extends JPanel implements ImageProducer {

double xs=5.0;
double xp=0.0;
double q=1.0; // zoom
double phi=0;
double phigrad=0;
double psi=0;
double psigrad=0;
double cosphi=1;
double sinphi=0;
double cospsi=1;
double sinpsi=0;
double alpha=0;

boolean zeichnetex=true; // texture
boolean wireframe=false;
boolean showinfo=false;

Image puffer;
Graphics pufferg;

double[][][] KugelNetz=new double[36][19][3];
double[][][] RotKugelNetz=new double[36][19][3];

double[][] punkte=new double[3000][3];
Color[] farbe=new Color[1500];
int anzlinie=0;

int[] text;
int textwidth=0;
int textheight=0;

double[][] mark=new double[4][3];
boolean ismark=false;

int addmxy=0;
int dux=0;
int duy=0;
int dvx=0;
int dvy=0;
int dudvdet=0;
double mdux=0;
double mduy=0;
double mdvx=0;
double mdvy=0;

//////////////////////////////////////////////////////////////
//
// Abschnitt Initialisieren
//
//////////////////////////////////////////////////////////////

public ErdeAnsicht(){
	super();	
	for(int b=0;b<=18;b++){
	 	double ps=toradians(b*10);
		double cosps=Math.cos(ps);
		double sinps=Math.sin(ps);		
		for(int l=0;l<36;l++){
			double ph=toradians(l*10);			
			double cosph=Math.cos(ph);
			double sinph=Math.sin(ph);
			KugelNetz[l][b][0]=sinps*cosph;
			KugelNetz[l][b][1]=sinps*sinph;
			KugelNetz[l][b][2]=cosps;
		}
	}

}

public void init(){
	setviewp(xs,q);	
	setrot(phigrad,psigrad);
	
	puffer=createImage(getSize().width,getSize().height);
	pufferg=puffer.getGraphics();
	//box();
	//kords();
	//kegel();
	//zylinder();
	//tangent(1);
	zeichnen();
}

public void setviewp(double setXs,double setQ){
	q=setQ;
	xs=setXs;
	double a=1/(Math.sqrt(xs*xs-1));
	double b=a*xs;
	double max=(double)getSize().height;
	if(puffer!=null) max=(double)puffer.getHeight(this); 
	xp=(q*max-2*b)/(2*a);
	alpha=1/(xs*xs-1);		
}

public void setmark(double l,double b,boolean setze){
	double[] p1={-1,0.05,0.05}; 	
	double[] p2={-1,-0.05,-0.05};
	double[] p3={-1,-0.05,0.05};
	double[] p4={-1,0.05,-0.05};
	ismark=setze;
	p1=rotonepoint(p1,0,l);p1=rotonepoint(p1,b,0);
	p2=rotonepoint(p2,0,l);p2=rotonepoint(p2,b,0);
	p3=rotonepoint(p3,0,l);p3=rotonepoint(p3,b,0);
	p4=rotonepoint(p4,0,l);p4=rotonepoint(p4,b,0);		 
	for(int i=0;i<3;i++){
		mark[0][i]=p1[i]; mark[1][i]=p2[i];
		mark[2][i]=p3[i]; mark[3][i]=p4[i];		
	}
}

//////////////////////////////////////////////////////////////
//
// Abschnitt Punkte drehen
//
//////////////////////////////////////////////////////////////

public double[] rotonepoint(double[] P,double rotphi,double rotpsi){
	double radrotphi=toradians(rotphi);
	double radrotpsi=toradians(rotpsi);
	double cosrotphi=Math.cos(radrotphi);
	double sinrotphi=Math.sin(radrotphi);	
	double cosrotpsi=Math.cos(radrotpsi);
	double sinrotpsi=Math.sin(radrotpsi);		
	double[] V=new double[3];
	V[0]=cosrotpsi*cosrotphi*P[0]-cosrotpsi*sinrotphi*P[1]-sinrotpsi*P[2];
	V[1]=sinrotphi*P[0]+cosrotphi*P[1];
	V[2]=sinrotpsi*cosrotphi*P[0]-sinrotpsi*sinrotphi*P[1]+cosrotpsi*P[2];	
	return V;
}

public void rotpoints(double rotphi,double rotpsi){
	double radrotphi=toradians(rotphi);
	double radrotpsi=toradians(rotpsi);
	double cosrotphi=Math.cos(radrotphi);
	double sinrotphi=Math.sin(radrotphi);	
	double cosrotpsi=Math.cos(radrotpsi);
	double sinrotpsi=Math.sin(radrotpsi);		
	for(int i=0;i<anzlinie*2+1;i++){
		double[] V=new double[3];
		V[0]=cosrotpsi*cosrotphi*punkte[i][0]-cosrotpsi*sinrotphi*punkte[i][1]-sinrotpsi*punkte[i][2];
		V[1]=sinrotphi*punkte[i][0]+cosrotphi*punkte[i][1];
		V[2]=sinrotpsi*cosrotphi*punkte[i][0]-sinrotpsi*sinrotphi*punkte[i][1]+cosrotpsi*punkte[i][2];	
		punkte[i]=V;		
	}		
}

public double toradians(double w){
	return((w*Math.PI)/180);
}

public void setrot(double setphi,double setpsi){
	setphi=setphi%360;
	if(setphi<-180) setphi=setphi+360;	
	if(setphi>180) setphi=setphi-360;	
	if(setpsi>90) setpsi=90;
	if(setpsi<-90) setpsi=-90;
	phigrad=setphi;
	psigrad=setpsi;
	phi=toradians(setphi);
	psi=toradians(setpsi);
	cosphi=Math.cos(phi);
	sinphi=Math.sin(phi);
	cospsi=Math.cos(psi);
	sinpsi=Math.sin(psi);	
}

public double[] rot(double[] V){
	double[] Vrot=new double[3];
	Vrot[0]=cospsi*cosphi*V[0]-cospsi*sinphi*V[1]-sinpsi*V[2];
	Vrot[1]=sinphi*V[0]+cosphi*V[1];
	Vrot[2]=sinpsi*cosphi*V[0]-sinpsi*sinphi*V[1]+cospsi*V[2];	
	return Vrot;
}

public void rotkugel(){
	for(int l=0;l<36;l++){
		for(int b=0;b<=18;b++){
			RotKugelNetz[l][b]=rot(KugelNetz[l][b]);
		}
	}		
}

//////////////////////////////////////////////////////////////
//
// Abschnitt Linien zeichnen
//
//////////////////////////////////////////////////////////////

public int[] proj(double[] V){
	int[] projvect={(int)(V[1]*(xs+xp)/(V[0]+xs)),-(int)(V[2]*(xs+xp)/(V[0]+xs))};
	return projvect;	
}

public void setline(double[] V1,double[] V2,Color C){
	for(int i=0;i<3;i++){
		punkte[anzlinie*2][i]=V1[i];
		punkte[anzlinie*2+1][i]=V2[i];
	}
	farbe[anzlinie]=C;	
	anzlinie++;
}

public void zeichneline(double[] V1,double[] V2,Color C){
	int[] P1=proj(V1);
	int[] P2=proj(V2);
	int transl=puffer.getHeight(this)/2;
	pufferg.setColor(C);	
	pufferg.drawLine(P1[0]+transl,P1[1]+transl,P2[0]+transl,P2[1]+transl);
	pufferg.drawLine(P2[0]+transl,P2[1]+transl,P1[0]+transl,P1[1]+transl);
}

public boolean inkegel(double[] V){
	return ((V[1]*V[1]+V[2]*V[2])<alpha*(V[0]+xs)*(V[0]+xs));
}

public void line3d(double[] V1,double[] V2,Color C){	
	double[] Vrot1=rot(V1);	
	double[] Vrot2=rot(V2);		
	if(Vrot1[0]<0 && Vrot2[0]<0){
		zeichneline(Vrot1,Vrot2,C);
	}
	else if(inkegel(Vrot1) && Vrot1[0]<0) zeichneline(Vrot1,Vrot2,C);		
	else if(inkegel(Vrot2) && Vrot2[0]<0) zeichneline(Vrot1,Vrot2,C);
	else{		
	
		double[] a=Vrot1;
		double[] r={Vrot2[0]-Vrot1[0],Vrot2[1]-Vrot1[1],Vrot2[2]-Vrot1[2]};	
		// Schnitt: Gerade-Kegel (Quadratische Gleichung agl*x^2+bgl*x+cgl=0)
		double agl=r[1]*r[1]+r[2]*r[2]-alpha*r[0]*r[0];
		double bgl=2*a[1]*r[1]+2*a[2]*r[2]-2*alpha*r[0]*a[0]-2*alpha*xs*r[0];
		double cgl=a[1]*a[1]+a[2]*a[2]-alpha*a[0]*a[0]-2*alpha*xs*a[0]-alpha*xs*xs;	
		double diskr=bgl*bgl-4*agl*cgl;
		if(diskr<=0){	
			zeichneline(Vrot1,Vrot2,C);				
		}
		else{
			double t1=(-bgl-Math.sqrt(diskr))/(2*agl);			
			double[] Ps1={a[0]+t1*r[0],a[1]+t1*r[1],a[2]+t1*r[2]};
			double t2=(-bgl+Math.sqrt(diskr))/(2*agl);			
			double[] Ps2={a[0]+t2*r[0],a[1]+t2*r[1],a[2]+t2*r[2]};										
			
			if(t1>0 && t1<1) zeichneline(Vrot1,Ps1,C);
			if(t2>0 && t2<1) zeichneline(Vrot2,Ps2,C);				
			if((t1<0 || t1>1) && (t2<0 || t2>1) && !(inkegel(Vrot1) && inkegel(Vrot2))) 
				zeichneline(Vrot1,Vrot2,C);								
		}
	}
}

public void line3dkugel(double[] V1,double[] V2,Color C){	
	if(V1[0]<0 && V2[0]<0){
		zeichneline(V1,V2,C);
	}
}

//////////////////////////////////////////////////////////////
//
// Abschnitt Texture Mapping
//
//////////////////////////////////////////////////////////////

public void addConsumer(ImageConsumer imageconsumer) { }
public boolean isConsumer(ImageConsumer imageconsumer) { return false; }
public void removeConsumer(ImageConsumer imageconsumer) { }
public void requestTopDownLeftRightResend(ImageConsumer imageconsumer) { }
public void startProduction(ImageConsumer imageconsumer)
     {
		int texttmpgr=(int)(puffer.getHeight(this)*q)+4;
		consumer=imageconsumer;		
		consumer.setDimensions(texttmpgr, texttmpgr);
		consumer.setColorModel(directCM);
		consumer.setHints(2);
     }

private ImageConsumer consumer;
private DirectColorModel directCM = new DirectColorModel(24, 0xff0000, 0xff00, 0xff);

public void settext(Image img){
	textheight=img.getHeight(this);
	textwidth=img.getWidth(this);	
	textsize=textheight*textwidth;
	text=new int[textsize];
	PixelGrabber pg = new PixelGrabber(img,0,0,textwidth,textheight,text,0,textwidth);	
	try{ 
		pg.grabPixels(); 
	}catch(Exception e){

		e.printStackTrace();

	}		    
	prepareImage(textproj, null);		
}

public int[] mappoint(int l,int b){
	int[] p={textwidth-(l*textwidth)/36,(b*textheight)/18};	
	return p;
}

int textsize;
int[] texttmp;
int texttmpgr;
int texttmpsize;
int weiss=Color.BLACK.getRGB();
Image textproj=createImage(this);

public void gettext(){	
	if(text!=null){
	texttmpgr=(int)(puffer.getHeight(this)*q)+4;