im trying to do a spaces ship game, but cant figure out how to work the propulsion systems. like, i cant really explain, you could go to www.arcadetown.com and take a look at Real Space Two. thats the kind of propulsion system i want to do. so...any help...appreciated. MUCHAS GRACIAS

Ok, so what are you trying to accomplish? Do you want to simulate the physics of propulsion or are you trying to create a particle system like the one in that game? More info please.

alrighty, if by particle engine you mean detecting the angle that the ship is facing and thrusting in that direction when the user hits a key, then yes. if you mean the fire particles that come out the back of the little ship then no. all i want to do is basicall simulate the way a car steers in one direction and then accelerates in that direction. MUCHAS GRACIAS

quote:Original post by PyroniaWatches
...all i want to do is basicall simulate the way a car steers in one direction and then accelerates in that direction. MUCHAS GRACIAS

Maybe you should use a 2d vector. When the user presses a direction key you just rotate the vector. For going forward add the vector to the ships position to get the new position

well....here is the code i put into my pre-game. im trying it with a block first. i know how to do rotating animation. i did the things you said to do (except for the friction/drag thing). yet it still doesn''t work. the red block comes up, u press up and it accelerates downwards but if you hold it it goes at a crazy angle, sort of like spinning of. thanks for all your help so far...here it comes:

#include <windows.h>
#include <math.h>
#include "trythis.h"

#define WIN_WID 1024
#define WIN_HGT 768

bool started = FALSE;

#define KEYDOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEYUP(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

#define IMG_WID 64 // Width of our image
#define IMG_HGT 64 // Height of our image

#define class_name "Carlos can do it"

#define DOUBLE_BUFFER 1 // Change this to zero to view the app without double buffering

// This is the struct that will hold all of our double buffering info
struct SDBuffer
{
HWND win_hwnd; // A copy of the window handle

HDC win_dc; // This is the window''s HDC
HDC back_dc; // This is the HDC to the back buffer we''re gonna make

RECT rect; // This will hold the client RECT of our window

HBITMAP back_bmp; // This is the HBITMAP that we''ll fill with an exact copy of
// our window''s HBITMAP (pixels)

HBITMAP old_bmp; // We need this guy around so we can totally free up memory when it''s
// all said and done
};

// Globals ***

int xPos = 0; // This will hold the upper left hand x-coord of the mouse
int yPos = 0; // This will hold the upper left hand y-ccord of the mouse

// *** End of Globals

// This will set up our double buffering. We return true on success, false on failure
bool InitDoubleBuffer(SDBuffer &doubleBuff);

// This funciton will free up all the memory associated with our double buffer
void FreeDoubleBuffer(SDBuffer &doubleBuff);

// Locks the frame rate at the passed in frame rate (60 FPS by default)
bool LockFrameRate(int frame_rate = 60);

// Standard callback function
LRESULT CALLBACK WinProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);

int WINAPI WinMain(HINSTANCE hinstance, HINSTANCE hprev, PSTR cmdline, int ishow)
{
HWND hwnd;
MSG msg;
WNDCLASSEX wndclassex = {0};

SDBuffer doubleBuff = {0}; // This is our "double buffer" struct

// Fill the fields we care about
wndclassex.cbSize = sizeof(WNDCLASSEX);
wndclassex.style = CS_HREDRAW | CS_VREDRAW;
wndclassex.lpfnWndProc = WinProc;
wndclassex.hInstance = hinstance;
wndclassex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wndclassex.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wndclassex.lpszClassName = class_name;

RegisterClassEx(&wndclassex); // Register the window

hwnd = CreateWindowEx(NULL, // No extra window attributes
class_name,
"attempt at huge map",
WS_VISIBLE | WS_POPUP,
0, // Window will receive a default x pos on screen
0, // Window will receive a default y pos on screen
WIN_WID,
WIN_HGT,
NULL,
NULL,
hinstance,
NULL);

// Error check
if(!hwnd)
{
UnregisterClass(class_name,hinstance);
return EXIT_FAILURE; // Something really bad happened!
}


doubleBuff.win_hwnd = hwnd; // Set the HWND of our double buffer struct

// Attempt to initialize our double buffering
if(!InitDoubleBuffer(doubleBuff))
{
UnregisterClass(class_name,hinstance);
return EXIT_FAILURE; // Couldn''t set up double buffering
}

// Here we''ll load up our bitmap
// Create a compatible HDC so that we can draw our "img_bmp"
HDC img_dc = CreateCompatibleDC(doubleBuff.win_dc);

if(!img_dc)
{
UnregisterClass(class_name,hinstance);
return EXIT_FAILURE;
}

// Select our "img_bmp" into the "img_dc"
ShowWindow(hwnd, ishow);
UpdateWindow(hwnd);

HBITMAP old_bmp = NULL;

while(1)
{
// Check message(s) if there are any
if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
if(msg.message == WM_QUIT)
break;

TranslateMessage(&msg);
DispatchMessage(&msg);
}
else if(LockFrameRate())
{
player.x += player.x_vel;
player.y += player.y_vel;

if(started == FALSE)
{
game_init();
started = TRUE;
}

#if DOUBLE_BUFFER // If we are using double buffering

// First we fill our back buffer to solid white (the same color as the
// background color of our window)
FillRect(doubleBuff.back_dc,&doubleBuff.rect,(HBRUSH)GetStockObject(WHITE_BRUSH));

// Next we''ll draw the bitmap to our back buffer
old_bmp = (HBITMAP)SelectObject(img_dc,player_bmp);

BitBlt(doubleBuff.back_dc,player.x,player.y,64,64,img_dc,0,0,SRCCOPY);
// Then we draw the back buffer to the front buffer (our window)
BitBlt(doubleBuff.win_dc,0,0,doubleBuff.rect.right,
doubleBuff.rect.bottom,doubleBuff.back_dc,0,0,SRCCOPY);

#else // No double buffering in use

// We fill our window with solid white so we can clear away the "old"
// position of the image
FillRect(doubleBuff.win_dc,&doubleBuff.rect,(HBRUSH)GetStockObject(WHITE_BRUSH));

// Blit the image to the window
BitBlt(doubleBuff.win_dc,xPos,yPos,xPos + IMG_WID,
yPos + IMG_HGT,img_dc,0,0,SRCCOPY);

// **NOTE** Do not be mislead by the use of the "doubleBuff" variable.
// We are ONLY using this to access the window''s HDC. Absolutely
// no double buffering goes on in the between the #else and the
// #endif. Be sure to look at how worse it looks without double
// buffering.

#endif
}

}

// Free up our image memory
SelectObject(img_dc,old_bmp);
DeleteDC(img_dc);

// Free up all the memory associated with our back buffer
FreeDoubleBuffer(doubleBuff);

UnregisterClass(class_name,hinstance); // Free up WNDCLASSEX
return msg.wParam;
}

// The WinProc
LRESULT CALLBACK WinProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
key();

PAINTSTRUCT ps;

// Depending on the message -- we''ll do different stuff
switch(message)
{
case WM_PAINT:

BeginPaint(hwnd,&ps);
EndPaint(hwnd,&ps);
return 0;

// Message we get when the mouse moves
case WM_MOUSEMOVE:

xPos = LOWORD(lparam); // X position of cursor
yPos = HIWORD(lparam); // Y position of cursor
return 0;

case WM_DESTROY:
case WM_CLOSE:

PostQuitMessage(0);
return 0;

} // end of switch(message)

return DefWindowProc(hwnd, message, wparam, lparam);
}

// Here will create/initialize our double buffer
// Return true on success, false on failure
bool InitDoubleBuffer(SDBuffer &doubleBuff)
{
// Error Check
if(!doubleBuff.win_hwnd)
return false; // Not a valid window HWND

// First and foremost we are going to get and store off the CLIENT RECT of our
// window. The client area (client rect) is the portion of a window where the
// application displays output, such as text, graphics, etc, etc
GetClientRect(doubleBuff.win_hwnd,&doubleBuff.rect); // Get the client RECT

// The next thing we are going to do is store off the window''s
// HDC. Remember you can think of the HDC as a way to "talk to" all of the
// pixels that make up the window.
doubleBuff.win_dc = GetDC(doubleBuff.win_hwnd); // Get the window''s HDC

// Error Check
if(doubleBuff.win_dc == NULL)
return false;

// Okay we have the window''s HDC. What we want to do is create a replicable
// in memory of the window''s pixels that we are able to draw to. So that
// means we''ll need a HDC that can interface (is compatible to) the window''s
// HDC. Thus we create a compatible HDC
doubleBuff.back_dc = CreateCompatibleDC(doubleBuff.win_dc);

// Error Check
if(doubleBuff.back_dc == NULL)
return false;

// So now we have a means to talk to our back buffer, but we DO NOT have
// the buffer (the set aside memory that will hold the pixel information).
// No worries, we''ll just create a compatible bitmap the SAME size as
// our window''s client area
doubleBuff.back_bmp = CreateCompatibleBitmap(doubleBuff.win_dc,
doubleBuff.rect.right,
doubleBuff.rect.bottom);

// Error Check
if(doubleBuff.back_bmp == NULL)
return false;

// If we get here that means we were successful in creating a "buffer" that
// mimics the windows front buffer. But before we can draw to our newly
// created buffer, we have to tell the "back buffer''s HDC" that it is
// associated with (or in charge of) the "back buffer''s HBITMAP -- Thus we
// select the created back buffer into our back buffer''s device context
doubleBuff.old_bmp = (HBITMAP)SelectObject(doubleBuff.back_dc,doubleBuff.back_bmp);

// **NOTE** remember we save off the return from SelectObject() so we can FULLY
// free up memory before we close the application

return true; // We be buff
}

// This function will free up all the memory we allocated
void FreeDoubleBuffer(SDBuffer &doubleBuff)
{
// Error Check
if(!doubleBuff.win_hwnd)
return;

if(doubleBuff.old_bmp) // If we have a double buffer
{
// Select back the original "bitmap"
SelectObject(doubleBuff.back_dc,doubleBuff.old_bmp);

// Free up memory
DeleteObject(doubleBuff.back_bmp);
DeleteDC(doubleBuff.back_dc);
}

if(doubleBuff.win_dc) // If we have the window''s device context
{
// Relese the device context
ReleaseDC(doubleBuff.win_hwnd,doubleBuff.win_dc);
}

// Set everything to zero
memset(&doubleBuff,0,sizeof(SDBuffer));
}

// Locks the frame rate at "frame_rate"
// Returns true when it''s okay to draw, false otherwise
bool LockFrameRate(int frame_rate)
{
static float lastTime = 0.0f;

// Get current time in seconds (milliseconds * .001 = seconds)
float currentTime = GetTickCount() * 0.001f;

// Get the elapsed time by subtracting the current time from the last time
// If the desired frame rate amount of seconds has passed -- return true (ie Blit())
if((currentTime - lastTime) > (1.0f / frame_rate))
{
// Reset the last time
lastTime = currentTime;
return true;
}

return false;
}

void game_init()
{
player.x = 200;
player.y = 200;
player.shipAngle = 360;
player.x_acc = 0;
player.y_acc = 0;
player.y_vel = 0;
player.x_vel = 0;
}

void key()
{
if(KEYDOWN(VK_ESCAPE))
{
PostQuitMessage(0);
}

if(KEYDOWN(VK_LEFT))
{
player.shipAngle += .75;
}

if(KEYDOWN(VK_RIGHT))
{
player.shipAngle -= .75;
}

if(KEYDOWN(VK_UP))
{
float radianAngle;

radianAngle = player.shipAngle * (180/3.14159);

player.x_acc = cos(radianAngle);
player.y_acc = sin(radianAngle);

player.x_vel += player.x_acc;
player.y_vel += player.y_acc;
}

if(player.x_vel > 0) player.x_vel -= 5;
if(player.x_vel < 0) player.x_vel += 5;

if(player.y_vel > 0) player.y_vel -= 5;
if(player.y_vel < 0) player.y_vel += 5;
}