need some help with this engine

This is a discussion on need some help with this engine within the A Brief History of Cprogramming.com forums, part of the Community Boards category; Okay, I have just been doing a little work in 13h lately, and I am having trouble with a little ...

  1. #1
    l'Anziano DavidP's Avatar
    Join Date
    Aug 2001
    Location
    Plano, Texas, United States
    Posts
    2,738

    Question need some help with this engine

    Okay, I have just been doing a little work in 13h lately, and I am having trouble with a little engine I am working on. It is a simple class I am making to load into my program some picture files that I have made up (they are my own format, not BMPs or JPGs or anything like that, just a very simple format i made up), and I am having some trouble with some of the functions.

    It loads them perfectly. But I also have some functions in the class that take input from the keyboard (the arrow keys), and move the bitmap arround the screen according to what the user input is, and I am having some trouble with that. At first it kind of worked, but then I tried to implement a better way to do it and now it does not work at all. It compiles and loads the bitmap fine, but it wont move correctly, it just disappears.

    I am going to try this new attach file option on this board and attach my source code.

    Meanwhile, here is the text contained in the data file. Copy and paste this into a file called "default.pic" I have given the extension .pic to my homemade bitmaps:

    0 0 0 31 31 0 0 0
    0 0 31 31 31 31 0 0
    0 31 31 31 31 31 31 0
    31 31 0 31 31 0 31 31
    31 0 0 31 31 0 0 31
    0 0 0 31 31 0 0 0
    0 0 0 31 31 0 0 0
    0 0 0 31 31 0 0 0
    Attached Files Attached Files
    My Website

    "Circular logic is good because it is."

  2. #2
    Disagreeably Disagreeable
    Join Date
    Aug 2001
    Posts
    711
    Uh, maybe it's cuz my computer's been acting up, but the source file is empty....

  3. #3
    Registered User
    Join Date
    Aug 2001
    Posts
    106
    yeah its empty for me as well.

  4. #4
    Banned master5001's Avatar
    Join Date
    Aug 2001
    Location
    Visalia, CA, USA
    Posts
    3,685
    Maybe that is another glitch in the new boards or maybe--even more likely--your code isn't working because nothing is there

  5. #5
    l'Anziano DavidP's Avatar
    Join Date
    Aug 2001
    Location
    Plano, Texas, United States
    Posts
    2,738
    Okay, since the link to my source does not work, here the code:

    Code:
    #include <iostream.h>
    #include <conio.h>
    #include <fstream.h>
    #include <iomanip.h>
    #include <stdlib.h>
    
    //Up = 72
    //Down = 80
    //Left = 75
    //Right = 77
    
    //enum containing the ASCII values for the arrow keys
    
    enum DIRECTION {
    	UP = 72,
       DOWN = 80,
       LEFT = 75,
       RIGHT = 77
    };
    
    //my two buffers
    
    unsigned char *Screen = (unsigned char *)0xA0000000l;
    unsigned char *BackBuffer = new unsigned char[64000];
    
    typedef unsigned char byte;
    
    const int TRANSPARENT = 0; //the value I am using for transparancy
    
    //function to initialize 13h mode
    
    void initGraph ( void )
    {
    	asm {
       	mov ax, 13h
          int 10h
       }
    }
    
    //function to close 13h mode
    
    void finishGraph ( void )
    {
    	asm {
       	mov ax, 03h
          int 10h
       }
    }
    
    //this function clears any 64k buffer - like the screen of back buffer
    
    void ClearBuffer ( byte *Buffer )
    {
    	memset(Buffer, 0, 64000);
    }
    
    //this function clears any buffer, size must be inputed
    //it is mainly used for clearing surfaces
    
    void ClearBuffer ( byte *Buffer, int xLen, int yLen )
    {
    	memset(Buffer, 0, yLen*xLen);
    }
    
    //standard function to plot a pixel
    
    void Plot ( int x, int y, byte color, byte *Buffer )
    {
    	Buffer[(y<<8)+(y<<6)+x]=color;
    }
    
    //my struct for bitmapped graphics
    
    struct GRAPHIC {
    
    	GRAPHIC(){    //standard constructor
       	Surface = new byte[64];   //creates a linear 8x8 bitmap
          Offset = 8; Ylen = 8;	//dimensions of bitmap
          CurrentDirection = UP;	//beginning direction bitmap is facing
          LoadGraphic("default.pic"); //loads the default bitmap - an arrow
       }
       GRAPHIC(char *filename)
       {
       	Surface = new byte[64];
          Offset = 8; Ylen = 8;
          CurrentDirection = UP;
          LoadGraphic(filename);  //loads a bitmap selected by the user
       }
       GRAPHIC(int x, int y){
       	Surface = new byte[y*x]; //creates a blank graphic, custom size
          Offset = x;
          Ylen = y;
          CurrentDirection = UP;
       }
       GRAPHIC(int x, int y, char *filename)
       {
       	Surface = new byte[y*x];
          Offset = x;
          Ylen = y;
          CurrentDirection = UP;
          LoadGraphic(filename);
       }
       ~GRAPHIC(){	delete [] Surface; } //destructor
    
       LoadGraphic(char *filename) //LoadGraphic function, loads a bitmap
       {
       	char *temp = "";
       	ifstream load;
          load.open(filename);
       	for(int y = 0; y < Ylen*Offset; y++) {
             	load >> temp;
                Surface[y] = atoi(temp);
          }
          load.close();
       }
    
       //DisplayGraphic function, displays the graphic at point (x,y).
       void DisplayGraphic ( int x, int y, byte *Buffer )
       {
       	CurScreenX = x;
          CurScreenY = y;
       	int x1 = x;
          int n = 0;
          for(int j = 0; j < Ylen*Offset; j++, n++, x++) {
          	if(n >= Offset)
             {
             	n = 0;
                y++;
                x = x1;
             }
             Plot(x, y, Surface[j], Buffer);
          }
       }
    
       //overloaded DisplayGraphic function, displays at current (x,y)
       void DisplayGraphic ( byte *Buffer )
       {
       	DisplayGraphic(CurScreenX, CurScreenY, Buffer);
       }
    
       //Takes input from arrow keys, changes current (x,y) coordinates accordingly
       void Move ( DIRECTION Direction )
       {
       	byte *tempSurface = new byte[Ylen*Offset];
          ClearBuffer(tempSurface, Offset, Ylen);
          if(CurrentDirection == UP && Direction == DOWN) //back up
          	CurScreenY += 2;
          else if (CurrentDirection == DOWN && Direction == UP) //back up
          	CurScreenY -= 2;
    		else if(Direction == CurrentDirection) //move
          {
          	if(Direction == UP) CurScreenY -= 2;
             else if(Direction == DOWN) CurScreenY += 2;
             else if(Direction == LEFT) CurScreenX -= 2;
             else if(Direction == RIGHT) CurScreenX += 2;
          }
          else {	//turn
          	if(Direction == LEFT)
             {
             	int x = 0, y = 0;
                int tx = 0, ty = Ylen;
                for(int ctr = 0; ctr < Ylen*Offset; ctr++) {
                	tempSurface[ty*Offset+tx] = Surface[y*Offset+x];
                   if(tx >= Offset) {
                   	tx = 0;
                      ty--;
                   }
                   if(y >= Ylen) {
                   	y = 0;
                      x++;
                   }
                   y++;
                   tx++;
                }
                if(CurrentDirection == UP) CurrentDirection = LEFT;
                else if(CurrentDirection == LEFT) CurrentDirection = DOWN;
                else if(CurrentDirection == DOWN) CurrentDirection = LEFT;
                else if(CurrentDirection == RIGHT) CurrentDirection = UP;
             }
    			else if(Direction == RIGHT)
             {
             	int x = Offset, y = 0;
                int tx = Offset, ty = Ylen;
                for(int ctr = 0; ctr < Ylen*Offset; ctr++) {
                	tempSurface[ty*Offset+tx] = Surface[y*Offset+x];
                   if(tx <= 0) {
                   	tx = Offset;
                      ty--;
                   }
                   if(y >= Ylen) {
                   	y = 0;
                      x--;
                   }
                   y++;
                   tx--;
                }
                if(CurrentDirection == UP) CurrentDirection = RIGHT;
    	         else if(CurrentDirection == RIGHT) CurrentDirection = DOWN;
       	      else if(CurrentDirection == DOWN) CurrentDirection = RIGHT;
          	   else if(CurrentDirection == LEFT) CurrentDirection = UP;
             }
             delete [] Surface;
          	Surface = new byte[Ylen*Offset];
          	_fmemcpy(Surface, tempSurface, Ylen*Offset);
          	tempSurface = NULL;
          }
       }
    
       //my variables
    	byte *Surface;		//Surface buffer for loaded bitmap
       int Offset, Ylen;	//dimensions for loaded bitmap
       int CurScreenX, CurScreenY;	//current (x,y) coord. on screen
       DIRECTION CurrentDirection;	//current direction its facing
    
    };
    
    //main function
    
    int main (void)
    {
    	initGraph();
       ClearBuffer(BackBuffer);		//clear the back buffer
       GRAPHIC Arrow, Player2;       //declare some graphics
       										//both are set to the default arrow graphic
    
       char input = 0;
    
       Arrow.DisplayGraphic(50, 50, BackBuffer);	//display on back buffer
       _fmemcpy(Screen, BackBuffer, 64000);	//move back buffer to screen
       ClearBuffer(BackBuffer);			//clear back buffer
    
       while(input != 27) {
    
       	getch();
       	input = getch();           //input direction user wants to move
          Arrow.Move(input);			//move graphic accordingly
          Arrow.DisplayGraphic(BackBuffer);	//display graphic on back buffer
       	_fmemcpy(Screen, BackBuffer, 64000);	//copy back buffer to screen
       	ClearBuffer(BackBuffer);	//clear back buffer
    
    	}
    
       getch();				//finish up
       finishGraph();
       return 0;
    }
    My Website

    "Circular logic is good because it is."

  6. #6
    Registered User
    Join Date
    Aug 2001
    Posts
    72
    the problem is in the LoadGraphic method:

    LoadGraphic(char *filename) //LoadGraphic function, loads a
    {
    >>> char *temp = ""; <<<

    allocate enought space before e.g.\
    >>> char temp[100]; <<<

  7. #7
    Registered User
    Join Date
    Aug 2001
    Posts
    13
    Yepp, that's probably it.. but:

    >allocate enought space before e.g.\
    >>> char temp[100]; <<<

    might not be the best fix.. (what if the files are >100byte) .. bye, bye..

    First rule of array use: Never assume an array is large enough..

    It might be beter to first determine the filesize and then try:
    char* temp = new char[ filesize ];

    but don't forget the: delete [] temp if you do it like this..

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. In a game Engine...
    By Shamino in forum Game Programming
    Replies: 28
    Last Post: 02-19-2006, 10:30 AM
  2. Game Engine Link Prob
    By swgh in forum Game Programming
    Replies: 2
    Last Post: 01-25-2006, 11:14 PM
  3. Ultra chess engine contest
    By yodacpp in forum Projects and Job Recruitment
    Replies: 8
    Last Post: 11-21-2004, 06:58 AM
  4. Updated sound engine code
    By VirtualAce in forum Game Programming
    Replies: 8
    Last Post: 11-18-2004, 11:38 AM
  5. Game structure, any thoughts?
    By Vorok in forum Game Programming
    Replies: 2
    Last Post: 06-07-2003, 01:47 PM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21