Logik verloren gegangen...

[JossBoss]

if (keystate[SDLK_LEFT] || mousex < 16)
   scrollx -= (400*frametime)/1000;

scrollx & frametime = int

auf meinem pc läuft das nicht. ich weiss auch warum, denn meine frametime ist 1, das heisst 400/1000 ist 0 da es ja ints sind. schön ud gut, da war ich stolz das problem gefunden zu haben
dann bin ich davon ausgegangen, dass der ausdruck erst verschieden von 0 wird wenn man anstat 400 minimum 1000 einsetzt.
hab ich auch mal 500 probiert einfach so, und siehe da scrollx wird verändert sich, obwohl 500/1000 ja auch 0 sein müsste, was das programm mir ja auch anzeigt in der konsole (ist eine SDL anwendung)

wieso gibt es nun eine veränderung bei dem ausdruck?

if (keystate[SDLK_LEFT] || mousex < 16)
   scrollx -= (500*frametime)/1000;

thx & mfg!!!

[rapso]

mehr source noetig, sonst kann man nur die kristalkugel befragen.

[JossBoss]

mmh... das hier ist eher so ein beispiel, wo zusätzlicher code eigentlich höchstens nur alles verkomplizieren würde, aer hier ist die funktion wo scroll benutzt wird
(gibt noch befelhle für SDL_UP, SDL_DOWN, SDL_RIGHT, sind fast genau aufgebauit, wie der codefetzen davor)

void DrawBackground(int scrollx, int scrolly)
{
	int i;

	for(i = NUM_GALAXIES-1; i >= 0; i--) {
		SDL_Rect src;
		SDL_Rect dest;

	/* Berechne die Position des Galaxientypbilds im Quellbitmap */
		src.x = g_Galaxies[i].type * 16;
		src.y = 0;
		src.w = 16;
		src.h = 16;

	/* Die Zielkoordinaten werden eingefüllt */
		dest.x = ((unsigned int)(g_Galaxies[i].x - (4*scrollx / g_Galaxies[i].depth)) % 1024) - 16;
		dest.y = ((unsigned int)(g_Galaxies[i].y - (4*scrolly / g_Galaxies[i].depth)) % 512) - 16;

		SDL_BlitSurface(g_pSurfGalaxies, &src, g_pSurfScreen, &dest);
	}
}

g_galaxies ist ein array in dem informationen zu den galaxien gespeichert sind, spielen aber hier keine rolle

thx & m fg!!!!

[lolz]

Die Funktion hat mit deinem Problem doch gar nichts zu tun. Da der falsche scrollx wert an sie übergeben wird, kann sie doch dafür gar nicht verantwortlich sein.
Du musst schon den Code posten der scrollx manipuliert.

[JossBoss]

ja in dem kleinen abschnitt oben wird scroll ja manipuliert , na ja stell mal den ganzen code rein:

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <iostream.h>

#include <SDL.h>

SDL_Surface *g_pSurfScreen; /* Der Bildschirminhalt */
SDL_Surface *g_pSurfGalaxies; /* galaxien.bmp */
SDL_Surface *g_pSurfShip; /* ship.bmp */

Uint32 g_Black; /* Farbwert schwarz */

struct { /* Zustand des Raumschiffs in der Bildschirmmitte */
	int rotation;
	Uint32 nextturn;
} ship;

/* Wieviele Millisekunden liegen zwischen den einzelnen Drehschritten? */
#define TURN_DELAY			60

/* Wie viele Galaxien sind auf dem Bildschirm? */
#define NUM_GALAXIES		100

struct galaxy {
	int x, y;	/* Koordinaten der Galaxie */
	int depth;	/* "Tiefe" der Galaxie */
	int type; 	/* Welches Bild wird für die Galaxien verwendet? */
};

static int g_DepthCount[] = {
	0,
	0,
	0,
	0,
	20,	/* volle Geschwindigkeit */
	34,
	45,
	55,
	64,	/* 1/2 */
	72,
	79,
	85,
	90,	/* 1/3 */
	94,
	97,
	99,
	100	/* 1/4 */
};

struct galaxy g_Galaxies[NUM_GALAXIES];

/* Erstelle ein Array aus zufällig gewählten Galaxienpositionen */
void RandBackground()
{
	int i;
	int num_types; /* Anzahl Galaxientypen im Bitmap "galaxien.bmp" */
	int depth;

	num_types = g_pSurfGalaxies->w / 16;

/* Fülle das Galaxien-Array mit zufällig gewählten Werten */
	depth = 0;
	for(i = 0; i < NUM_GALAXIES; i++) {
		g_Galaxies[i].x = rand() % 1024;
		g_Galaxies[i].y = rand() % 512;
		g_Galaxies[i].type = rand() % num_types;

		while(i >= g_DepthCount[depth])
			depth++;
		g_Galaxies[i].depth = depth;
	}
}

/* Zeichne einen Sternenhintergrund auf den Bildschirm */
void DrawBackground(int scrollx, int scrolly)
{
	int i;

	for(i = NUM_GALAXIES-1; i >= 0; i--) {
		SDL_Rect src;
		SDL_Rect dest;

	/* Berechne die Position des Galaxientypbilds im Quellbitmap */
		src.x = g_Galaxies[i].type * 16;
		src.y = 0;
		src.w = 16;
		src.h = 16;

	/* Die Zielkoordinaten werden eingefüllt */
		dest.x = ((unsigned int)(g_Galaxies[i].x - (4*scrollx / g_Galaxies[i].depth)) % 1024) - 16;
		dest.y = ((unsigned int)(g_Galaxies[i].y - (4*scrolly / g_Galaxies[i].depth)) % 512) - 16;

		SDL_BlitSurface(g_pSurfGalaxies, &src, g_pSurfScreen, &dest);
	}
}

/* Zeichne ein normales Sprite mit 36 Drehschritten */
void DrawSprite(SDL_Surface *pSurf, int dx, int dy, int frame, int rotation)
{
	SDL_Rect src;
	SDL_Rect dest;
//36 Sprites starten bei 0 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 0-35!!!!!!!!

	src.x = (rotation % 9) * 49;
	src.y = ((rotation / 9) + (4 * frame)) * 49;
	src.w = 48;
	src.h = 48;

	dest.x = dx - 24;
	dest.y = dy - 24;

	SDL_BlitSurface(pSurf, &src, g_pSurfScreen, &dest);
}

/* Eine einfache Wrapperfunktion zum Laden von Bitmaps */
SDL_Surface *LoadBMP(const char *szFile)
{
	SDL_Surface *orig, *convert;

/* Lade das Bitmap */
	orig = SDL_LoadBMP(szFile);
	if (!orig) {
		fprintf(stderr, "%s konnte nicht geladen werden: %s\n", szFile, SDL_GetError());
		exit(1);
	}

/* Konvertiere ins Bildschirmformat für bessere Performance */
	convert = SDL_ConvertSurface(orig, g_pSurfScreen->format, g_pSurfScreen->flags);
	SDL_FreeSurface(orig); /* alte Surface wird freigegeben */
	if (!convert) {
		fprintf(stderr, "%s konnte nicht ins Bildschirmformat konvertiert werden: %s\n",
			szFile, SDL_GetError());
		exit(1);
	}

	return convert;
}

#ifdef _WIN32
#undef main
#endif
int main()
{
	int running;
	int scrollx, scrolly;
	Uint32 lastframe, curframe, frametime;

/* Initialisiere den Zufallszahlengenerator */
	srand(time(0));

/* SDL initialisieren */
	if (SDL_Init(SDL_INIT_VIDEO) < 0) {
		fprintf(stderr, "SDL konnte nicht initialisiert werden: %s\n",
			SDL_GetError());
		exit(1);
	}
	atexit(SDL_Quit);

/* Bildschirmmodus setzen */
	g_pSurfScreen = SDL_SetVideoMode(640, 480, 0, SDL_DOUBLEBUF);
	if (!g_pSurfScreen) {
		fprintf(stderr, "Konnte Bildschirmmodus nicht setzen: %s\n",
			SDL_GetError());
		exit(1);
	}

/* Farbwerte bestimmen */
	g_Black = SDL_MapRGB(g_pSurfScreen->format, 0, 0, 0);

/* galaxien.bmp laden */
	g_pSurfGalaxies = LoadBMP("galaxien.bmp");
	SDL_SetColorKey(g_pSurfGalaxies, SDL_SRCCOLORKEY, g_Black);

/* ship.bmp laden */
	g_pSurfShip = LoadBMP("ship.bmp");
	SDL_SetColorKey(g_pSurfShip, SDL_SRCCOLORKEY, g_Black);

/* Galaxienpositionen vorprogrammieren */
	RandBackground();

/* Der Timer muß initialisiert werden */
	curframe = SDL_GetTicks();

/* Programmschleife */
	running = 1;
	scrollx = scrolly = 0;
	ship.rotation = 0;
	ship.nextturn = curframe + TURN_DELAY;
	while(running) {
		SDL_Event event;
		Uint8 *keystate;
		int mousex, mousey;

		while(SDL_PollEvent(&event)) {
			switch(event.type) {
			case SDL_KEYDOWN:
				switch(event.key.keysym.sym) {
				/* Beim Druck von ESC beendet sich das Programm */
				case SDLK_ESCAPE:
					running = 0;
					break;

				/* Alle anderen Tasten werden ignoriert */
				default:
					break;
				}
				break;

			/* Wenn die Maus bewegt wird während der rechte Maustaste
			   gedrückt ist scrollt der Bildschirm mit */
			case SDL_MOUSEMOTION:
				if (event.motion.state & SDL_BUTTON(SDL_BUTTON_RIGHT)) {
					scrollx -= event.motion.xrel;
					scrolly -= event.motion.yrel;
				}
				break;

			/* Bei einem Druck auf die linke Maustaste zentriert der
			   Bildschirm auf der momentanen Mausposition */
			case SDL_MOUSEBUTTONDOWN:
				if (event.button.button == SDL_BUTTON_LEFT) {
					scrollx += event.button.x - 320;
					scrolly += event.button.y - 240;
				}
				break;

			case SDL_QUIT:
				running = 0;
				break;
			}
		}

	/* Frametime wird berechnet */
		lastframe = curframe;
		curframe = SDL_GetTicks();
		frametime = curframe - lastframe;

	/* Momentanen Tastaturzustand und Mausposition holen und entsprechend
	   scrollen */
		keystate = SDL_GetKeyState(0);
		SDL_GetMouseState(&mousex, &mousey);

		if (keystate[SDLK_LEFT] || mousex < 16)
			scrollx -= (400 * frametime)/1000;
		if (keystate[SDLK_RIGHT] || mousex > 640-16)
			scrollx += (400 * frametime)/1000;
		if (keystate[SDLK_UP] || mousey < 16)
			scrolly -= (400 * frametime)/1000;
		if (keystate[SDLK_DOWN] || mousey > 480-16)
			scrolly += (400 * frametime)/1000;

    /* Zustand des Raumschiffes updaten */

		while(ship.nextturn < curframe) {
			if (++ship.rotation == 36)
				ship.rotation = 0;
			ship.nextturn += TURN_DELAY;
      }

std::cout<<ship.nextturn<<"          "<<curframe<<endl;
	/* Bildschirmhintergrund löschen */
		SDL_FillRect(g_pSurfScreen, 0, g_Black);

	/* Sternenhintergrund darstellen */
		DrawBackground(scrollx, scrolly);

	/* Raumschiff darstellen */
		DrawSprite(g_pSurfShip, 320, 240, keystate[SDLK_SPACE] ? 1 : 0, ship.rotation);

	/* Die Änderung müssen wirksam gemacht werden */
		SDL_Flip(g_pSurfScreen);
	}

/* Unsere Bitmaps müssen freigegeben werden */
	SDL_FreeSurface(g_pSurfShip);
	SDL_FreeSurface(g_pSurfGalaxies);

	return 0;
}

thx & mfg!!!

[vista]

JossBoss schrieb:

if (keystate[SDLK_LEFT] || mousex < 16)
   scrollx -= (400*frametime)/1000;

vielleicht ein überlauf?
probier mal: scrollx -= (4*frametime)/10;

[Maxi]

was ist denn eigentlich genau dein problem?

Warum (500*frametime)/1000 > 0 ist?
sicher dass frametime == 1?
eigentlich müssts dann 0 sein, aber das ist doch vollkommen egal, oder?
und das hat doch absolut gar njichts mit spiele oder grafikprogrammierung zu tun...
nur weils ne sdl-app ist, heißt das doch noch lange nicht dass es ein grafikproblem ist

[JossBoss]

na ja welche art von problem soll es denn deiner meinung nach genau sein?
es ist ja ein problem, das in dem anfangsstadium eines spiels auftritt...

und ja ich bin mir sicher, ich geb frametime mit cout in die konsole aus, k es ist ja eigentlich kein problem, das das ganze programm so furchtbar behindert, aber ich will einfach verstehen, wieso das so ist. der sinn von tutorials ist ja auch zu verstehen was man macht, und nicht nur einfach abzuschreiben

thx & mfg!!!

[hustbaer]

Nö, du gibst garnix aus, hast ja oben den Code gepostet, da wird frametime nirgendshin ausgegeben.
Und 500/1000 ist in C++ 0, wenn du was anderes rausbekommst ist irgendwas an deiner Hardware oder C++ Toolchain kaputt.

Hat mit der Frage ob 500/1000 0 ist zwar nix zu tun, aber ein Tip: wenn du Geschwindigkeiten abhängig von der Framerate machen willst, dann rechne nicht 1:1 mit "int"s sondern entweder mit floats oder z.B. 1:1024 mit int. Dann klappt das besser