Bearbeitung eines vorhandenen Spiels!!!

[threis]

Guten Abend,

ich bin ein Neuling auf dem Gebiet der Programmierung und möchte nun ein bereits vorhandenes Spiel ein wenig bearbeiten. Und zwar gehts um ein recht simples Spiel, in dem ein 2D-Weltraum mit beliebig vielen Planeten dargestellt ist und 2 "Raumschiffe"(nichts weiter als 2kleine Kästchen) sich gegenseitig abschießen sollen.

Die Aufgabe ist es nun, dass ein visueller Effekt erzeugt wird, sobald ein Planet oder eins der Raumschiffe getroffen wird, was gleichzeitg die Abbruchbedingung des Spiels ist.

Der ganze Prozess der Abbruchbedingung und der Berechnung der Schusskoordinaten befindet sich in der "integrator.cpp", von wo aus ich diesen Effekt initialisieren wollte, allerdings fehlt mir dazu das nötige handwerk.

Ich würde mich über den einen oder anderen Tipp freuen und ich weiß natürlich, das die Angaben hier bei weitem nicht ausreichen, deshalb habe ich einfach das ganze Spiel mal hochgeladen:

[url=http://dateihoster.de/de/file/15963/Space-zip.html]

Und wenns noch Fragen gibt, fragt einfach nach...

Mfg, threis

[flashpixx]

Der ganze Prozess der Abbruchbedingung und der Berechnung der Schusskoordinaten befindet sich in der "integrator.cpp", von wo aus ich diesen Effekt initialisieren wollte, allerdings fehlt mir dazu das nötige handwerk.

Und was ist nun die Frage?

Phil

[threis]

Moin!

Meine Frage ist, wie ich es mittels einer brush-Funktion realisiert bekomme, das im Moment des Abschusses irgendwas passiert. Es würde mir schon reichen, wenn dort einfach ein lila Punkt aufblinkt, oder irgendwas in dieser Art.

Gruß

[flashpixx]

Ohne den 5 MB undokumentierten Quellcode anzuschauen. Stell den Punkt fest, wenn ein Abschuss statt findet, an dem Du zeichnen willst, zeichne irgendetwas und nach einer gewissen Zeit kannst Du das gezeichnete wieder entfernen, oder lässt usw.

Wo ist das konkrete Problem !?

Phil

[threis]

Sorry, wenn ich mich bis hierhin undeutlich ausgedrückt habe...und jetzt wahrscheinlich mit diesem Quellcode die Regeln des Forums untergrabe.

Auuf jeden Fall möchte ich in diesem Abschnitt diesen kleinen graphischn Effekt erzeugen, wenn das Raumschiff oder ein Planet getroffen wird. Mir ist ber nicht so wirklich klar, wo ich es wie am besten mache. Ich hatte die Idee sich die Koordinaten des Schussvektors zunehmen und in dem Moment des Abschuss was erzeugen lasse. Nur fehlt mir dazu die Programmierfertigkeiten...

Ich hoffe man kann damit jetzt anfangen.

Vielen Dank und einen schönen Tag

#include "stdafx.h"

#include "Integrator.h"

#include <math.h>

#include "Raumschiff.h"


#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif


#define PI 3.141592654



void errbreak(char* message)

{

	AfxMessageBox(message);

	AfxAbort();

};


CIntegrator::CIntegrator(void)

{

	pSz=NULL;

	nistep=10;

	steplen=5.0;

	count=0;

	maxcount=1500;

}


CIntegrator::~CIntegrator(void)

{

}


void CIntegrator::ComputeScalingData(void)

{

	int i;

	double gesmasse,ri,fmax;


	if(!pSz) errbreak("CIntegrator::Initialize: scenario-pointer not yet present");


	gesmasse=0;

	for(i=0;i<pSz->np;i++) {

		ri=pSz->PlanetenArray[i].radius;

		gesmasse+=ri*ri*ri;

	};

	fmax=pow(gesmasse,1.0/3.0);

	dt=sqrt(steplen/(nistep*nistep*fmax));//steplen of internal time-steps

	vmax=0.5*sqrt(2.0/fmax);//fmax==radges

};


void CIntegrator::Initialize(CSzenario *pnSz, double v0, double alpha,int RSindex)

{

	pSz=pnSz;

	ComputeScalingData();

	//start-coordinates

	x=pSz->Raumschiffe[RSindex].x;

	y=pSz->Raumschiffe[RSindex].y;

	//start velocity

	xalt=x-dt*v0*cos(alpha*PI/180.0)/vmax;

	yalt=y-dt*v0*sin(-alpha*PI/180.0)/vmax;

	count=0;

	ImRohr=1;

}


int CIntegrator::Step(int& nxalt, int& nyalt, int &nx, int &ny)

/*

Rueckgabewerte:

				0 = Raumschiff 0 getroffen

				1 = Raumschiff 1 getroffen

				-1 = nichts getroffen

				2 = Planet getroffen oder außerhalb des Spielbereiches

*/

{

	int i;

	int result;


	count++;

	nxalt=(int)(x+0.5);

	nyalt=(int)(y+0.5);

	for(i=0;i<nistep;i++) {

		result=InnerStep(nx,ny);

		if(result!=-1) break;

	};

	return result;

}



int CIntegrator::InnerStep(int &nx, int &ny)

/*rueckgabewerte: wie step*/

{

	double fx,fy;

	double xneu,yneu;

	int result;


	GetForceVector(fx,fy);

	xneu=2.0*x-xalt+dt*dt*fx;

	yneu=2.0*y-yalt+dt*dt*fy;


	xalt=x;

	x=xneu;

	yalt=y;

	y=yneu;


	nx=(int)(x+0.5);//runden

	ny=(int)(y+0.5);


	//abfrage des Abbruchkriteriums

	result=RaumschiffGetroffen();

	if(result!=-1) return result;

	if(PlanetGetroffen()) return 2;

	if(OutOfLimit()) return 2;

	if(count>maxcount) return 2;


	return -1;

}



void CIntegrator::GetForceVector(double& fx, double& fy)              //Erzeugung des Schussvektors

{

	int i;

	double masse,r,vx,vy,abstand;


	fx=0.0;

	fy=0.0;

	for(i=0;i<pSz->np;i++) {

		r=pSz->PlanetenArray[i].radius;

		masse=r*r*r;

		vx=pSz->PlanetenArray[i].x-x;

		vy=pSz->PlanetenArray[i].y-y;

		abstand=sqrt(vx*vx+vy*vy);

		fx+=masse*vx/(abstand*abstand*abstand);

		fy+=masse*vy/(abstand*abstand*abstand);

	};



	void CspecialFX::Anzeigen(CDC *pDC)

{


	if

		abstand<0,65*kantenlänge;

	{

	CBrush mybrush(farbe),*pOld;

	farbe=RGB(256,0,128)

	pOld=pDC->SelectObject(&mybrush);

	pDC->Rectangle((int)(&fx-5),(int)(&fy-5),(int)(&fx+5),(int)(&fy+5));

	pDC->SelectObject(pOld);


	}

	else




	return -1;

}



}





int CIntegrator::RaumschiffGetroffen(void)

/*prueft of geschoss noch im rohr des abschiessenden raumschiffes

  prueft ob raumschiff getroffen 

  rueckgabewert: nr. des Raumschiffes 0 oder 1 falls getroffen

                 -1  sonst*/

{

	int i;

	double dx,dy,abstand;

	double xr,yr,kl;

	int drin[2];


	for(i=0;i<2;i++) {

		pSz->Raumschiffe[i].GetData(&xr,&yr,&kl);

		dx=x-xr;

		dy=y-yr;

		abstand=sqrt(dx*dx+dy*dy);

		if(abstand<0.65*kl) {

			drin[i]=1;

		} else {

			drin[i]=0;

		};

		if(!ImRohr && drin[i]) return i;

	};

	if(!drin[0] && !drin[1]) ImRohr=0;






int CIntegrator::OutOfLimit(void)

/* rueckgabewert: 0 falls koordinaten innerhalb des limits

                  1 falls ausserhalb*/

{

	double rand=0.5;


	if(x<-pSz->xpix*rand || x>pSz->xpix*(1.0+rand) ||

	   y<-pSz->ypix*rand || y>pSz->ypix*(1.0+rand))


	   return 1;


	return 0;

}




int CIntegrator::PlanetGetroffen(void)

/*reuckgabewert: 1 falls ein planet getroffen

                 0 falls nicht*/

{

	int i;

	double r,vx,vy,abstand;


	for(i=0;i<pSz->np;i++) {

		r=pSz->PlanetenArray[i].radius;

		vx=pSz->PlanetenArray[i].x-x;

		vy=pSz->PlanetenArray[i].y-y;

		abstand=sqrt(vx*vx+vy*vy);

		if(abstand<r) return 1;

	};


	return 0;

}

[Klotzkopp]

Ich fürchte, der "eine oder andere Tipp" wird dich bei deinem erkennbaren Kenntnisstand nicht weit bringen.

Der gezeigte Code sollte sich übrigens nicht mal kompilieren lassen. Jemand hat anscheinend die gesamte Methode void CspecialFX::Anzeigen in die Methode CIntegrator::GetForceVector hineinkopiert. Wenn du das warst, solltest du wirklich die Finger davon lassen, und dir eine Aufgabe suchen, die besser zu deinen Fähigkeiten passt.

Der gezeigte Code enthält mMn auch nicht die Stelle, an der du ansetzen müsstest. Du musst dich in die Architektur des Programms einarbeiten. Die interessanten Stellen sind vermutlich die, an denen die gezeigten Methoden aufgerufen werden.

Es reicht vermutlich auch nicht aus, nur einmal etwas anzuzeigen, weil das beim nächsten Neuzeichnen wieder weg ist. Und Spiele versuchen üblicherweise, sich so schnell wie möglich zu zeichnen.

[threis]

Das mit dem CspecialFX stimmt natürlich...da ist mir wohl ein kleiner Fauxpas unterlaufen. Ich habe die ganze Archtiektur durchfiorstet und werde einfach nicht glücklich und ein einmaliges aufblinken würde mir persönlich schon genügen.

Ich werde mich mal weiter reinstürzen und hoffe, dass ich noch einen Ansatz finde...

Gruß

[Padde85]

ein Ansatzpunkt wäre die Funktion Step.

Allerdings rufst du die meines Erachtens nirgends auf.

Das Ding hat ja Rückgabewerte.

Und da musst du nach dem Aufruf der Funktion nur den Parameter untersuchen und bei 0 oder 1 per draw-Methode des Canvas, oder worauf auch immer du ausgibst, einen lila Punkt oder so zeichnen.

Am besten machst du das noch über einen Timer, dann kannst du auch steuern, wie lange der angezeigt werden soll

[flashpixx]

Am besten machst du das noch über einen Timer, dann kannst du auch steuern, wie lange der angezeigt werden soll

Je nach Performance würde ich direkt zu den Zielobjekten je einen "Explosionsthread" im Hintergrund erzeugen und schlafen legen. Wenn getroffen, dann den Thread nur wecken, damit er zeichnet

Phil