Elysian Shadows

Code: Select all

//this is needed by KOS
#define _arch_dreamcast
#include <kos.h>
#include <stdlib.h>
#include <cmath>
#include "DCTile.h"

//screen dimensions
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;

//Create instance of class player
Player dude;

//how much an object gets pulled down per frame
float Gravity = 0.38;
//array holding map data (0 or 1 for now)
int map[20][15];
//Create 3 bullets that may be shot
Bullet bullet[3];

#include "gun.cpp"
#include "quad.cpp"
#include "vmu.cpp"

int main() {
    srand(time(NULL));
    vid_set_mode(DM_640x480, PM_RGB565); 
    pvr_init_defaults();
    
    cont_btn_callback(0, CONT_START | CONT_A | CONT_B | CONT_X | CONT_Y, (void (*)(unsigned char, long  unsigned int))arch_exit);
	
	//Init player
    dude.m_x = (3*32);
    dude.m_y = (10*32);
    dude.m_dir = 1;

	//clear map array
    for(int x=0; x<=19; x++)
    {
        for(int y=0; y<=14; y++)
        {
            map[x][y] = 0;
        }
    }

    //put some solids into the map array
    for(int x=0; x<=19; x++)
    {
        map[x][0] = 1;
        map[x][1] = 1;
        map[x][12] = 1;
        map[x][13] = 1;
        map[x][14] = 1;
    }
    //add some more solids yo
    map[0][9] = 1;
    map[0][10] = 1;
    map[0][11] = 1;
    map[12][6] = 1;
    map[13][6] = 1;
    map[14][6] = 1;
    map[15][6] = 1;
    map[16][6] = 1;
	
	/*map[5][6] = 1;
    map[6][6] = 1;
    map[7][6] = 1;
    map[8][6] = 1;*/
    
	map[16][6] = 1;
    map[17][11] = 1;
    map[18][11] = 1;
    for(int y=0; y<15; y++)
    {
        map[19][y] = 1;
    }
    //take out some tiles yo
    map[8][12] = 0;
    map[9][12] = 0;
    map[10][12] = 0;
    map[11][12] = 0;
    map[12][12] = 0;

    SetVMU();

	while(1) {
		//move dude in persective of velocities
        MoveHorizontal(dude.m_xvel,dude.m_x,dude.m_y,0,32,0,64);
        if(MoveVertical(dude.m_yvel,dude.m_x,dude.m_y,0,32,0,64) == 1)
        { dude.m_jump = false; }

        //simulate gravity (probably should be in jump function later)
        dude.m_yvel = (dude.m_yvel + Gravity);

        //simulate friction
        if(dude.m_xvel < 0) { dude.m_xvel = (dude.m_xvel + Gravity); }
        if(dude.m_xvel > 0) { dude.m_xvel = (dude.m_xvel - Gravity); } 

        //sorry, can't jump while falling :D
        if(dude.m_yvel > 1) { dude.m_jump = true; }
	
	    DrawFrame();
		GetInput();
	    Friction();
	}
	return 0;
}


void DrawFrame() {
	pvr_wait_ready(); 
    pvr_scene_begin();    
    pvr_list_begin(PVR_LIST_OP_POLY); // Non-transparent graphics 

    pvr_list_finish(); 
    pvr_list_begin(PVR_LIST_TR_POLY); // Transparent graphics

    DrawMap();
	DrawPlayer();
	UpdateBullets();

	pvr_list_finish(); 
    pvr_scene_finish(); 
}

void DrawMap() {
    //draw the map
    for(int x=0; x<=19; x++)
    {
        for(int y=0; y<=14; y++)
        {
            if(map[x][y] == 1)
            {
                //Draw dark box for tile
				draw_tr_quad(x*32 + 16, y*32, 1, 32, 32, 1, 256-1, 256-255, 256-1);

				//Draw lighter outline
				draw_tr_quad((x*32)+1 + 16, (y*32)+1, 2, 30, 30, 1, 256-1, 256-180, 256-1);
            
			}
        }
    }
}

void GetInput() {
    cont_cond_t cond; 
    cont_get_cond(maple_addr(0,0),&cond);

	 if(!(cond.buttons & CONT_A)){
         //if we are not currently jumping, and A wasn't held
         if((dude.m_jump == false) && (dude.m_letgo == true)) {
             //set some vars
             dude.m_letgo = false;
             dude.m_jump = true;

             //at this point, we could put in an if statement to see if dude
             //is moving fast enough to jump higer.. but not right now.
             dude.m_jumptimer = 8;

             //make dude bounce into action
             dude.m_yvel = -4.5;
         }
	 }
     else {
         //if dude isn't going up or down, reset letgo to true
         if(abs((int)dude.m_yvel) < 1) dude.m_letgo = true; 
         //reset the jumptimer to 0
         dude.m_jumptimer = 0;
    }

    //if we are currently jumping
    if((dude.m_jump == true) && (dude.m_jumptimer > 0)) {
        //adjust velocity for life
        dude.m_yvel = dude.m_yvel - 1;
        //decrease the jump timer
        dude.m_jumptimer--;
	}

    if(!(cond.buttons & CONT_DPAD_LEFT)) {
        dude.m_xvel = (dude.m_xvel - 1);
		dude.m_dir = 0;
	}
	if(cond.joyx < 40){
        dude.m_xvel = (dude.m_xvel - 1);
		dude.m_dir = 0;
	}
    if(!(cond.buttons & CONT_DPAD_RIGHT)) {
        dude.m_xvel = (dude.m_xvel + 1);
		dude.m_dir = 1;
	}
	if(cond.joyx > 215){
        dude.m_xvel = (dude.m_xvel + 1);
	    dude.m_dir = 1;
	}
	if(cond.rtrig > 100) {
        if(dude.m_canshoot == true) {
		    Shoot((int)dude.m_x, (int)dude.m_y, dude.m_dir);
            dude.m_canshoot = false;
		}
	}

	if(cond.rtrig < 100)
		dude.m_canshoot = true;

	if(cond.ltrig > 100) dude.LevelUp();

	if(!(cond.buttons & CONT_Y))
        vid_screen_shot("/pc/screenshot.ppm");
}

void Friction() {
    //keep dude from going left or right to fast
    if(abs((int)dude.m_xvel) > 3) {
        //if velocity less then 0
        if(dude.m_xvel < 0) {
            dude.m_xvel = (-3);
        }
        else {
            dude.m_xvel = (3);
        }
    }

    /*
    //keep dude from going up or down to fast
    if(abs((int)dude.m_yvel) > 6){
        //if velocity less then 0
        if(dude.m_yvel < 0) {
            dude.m_yvel = (-6);
        }

    }
        */
}

void DrawPlayer() {
	draw_tr_quad((int)dude.m_x + 16, (int)dude.m_y + 16, 1, 32, 64, 1, 256-1, 256-140, 256-255);
    draw_tr_quad((int)dude.m_x+1 + 16, (int)dude.m_y+1 + 16, 2, 30, 62, 1, 256-1, 256-1, 256-255);
}

int MoveHorizontal(float& p_xvel, float& p_x, float& p_y, int p_left, int p_right, int p_top, int p_bottom)
{
    for(int i=1; i<=abs( (int)p_xvel ); i++ )
    {
        //temporarily define the object's bounderies
        int BoundLeft   = ((int)p_x + p_left);
        int BoundRight  = ((int)p_x + p_right-1);
        int BoundTop    = ((int)p_y + p_top);
        int BoundBottom = ((int)p_y + p_bottom-1);

        //set temp Move = true? vars to false
        bool MoveLeft = false;
        bool MoveRight = false;

        //loop from boundtop to boundbottom (replace loop with mar's idea!)
        for(int Point=BoundTop; Point<=BoundBottom; Point++)
        {
            //if object going left
            if(p_xvel < 0)
            {
                //if object's left bound minus 1 is in a solid tile
                if(map[ (BoundLeft-1)/32 ][ (Point)/32 ] == 1)
                {
                    //set the object's xvel to 0 and return with -1
                    p_xvel = 0;
                    return -1;
                }
                else
                {
                    //set the MoveLeft var to true
                    MoveLeft = true;
                }
            }

            //if object going right
            if(p_xvel > 0)
            {
                //if object's right bound plus 1 is in a solid tile
                if(map[ (BoundRight+1)/32 ][ (Point)/32 ] == 1)
                {
                    //set the object's xvel to 0 and return with 1
                    p_xvel = 0;
                    return 1;
                }
                else
                {
                    //set the MoveRight var to true
                    MoveRight = true;
                }
            }
        }
        //if the Move vars are now true, adjust the x values
        if(MoveLeft == true) { p_x = p_x - 1; }
        if(MoveRight == true) { p_x = p_x + 1; }

        //if the object has gone out of array bounds, push it back on
        if(p_x < 0) { p_x = 0; p_xvel = 0; }
        if(p_x > 640) { p_x = 640; p_xvel = 0; }    //replace 20*32 with map height var/function
    }

    //if no solids were hit at all, return 0
    return 0;
}


//MoveVertical() - moves thing based on velocity
//returns -1 if top boundry hits a solid
// 1 if bottom boundry hits a solid
// 0 if no collision detected in move
int MoveVertical(float& p_yvel, float& p_x, float& p_y, int p_left, int p_right, int p_top, int p_bottom)
{
    for(int i=1; i<=abs( (int)p_yvel ); i++ )
    {
        //temporarily define the object's bounderies
        int BoundLeft   = ((int)p_x + p_left);
        int BoundRight  = ((int)p_x + p_right-1);
        int BoundTop    = ((int)p_y + p_top);
        int BoundBottom = ((int)p_y + p_bottom-1);

        //set temp Move = true? vars to false
        bool MoveUp = false;
        bool MoveDown = false;

        //loop from boundleft to boundright (replace loop with mar's idea!)
        for(int Point=BoundLeft; Point<=BoundRight; Point++)
        {
            //if object going up
            if(p_yvel < 0)
            {
                //if object's top bound minus 1 is in a solid tile
                if(map[ (Point)/32 ][ (BoundTop-1)/32 ] == 1)
                {
                    //set the object's yvel to 0 and return with -1
                    p_yvel = 0;
                    return -1;
                }
                else
                {
                    //set the MoveUp var to true
                    MoveUp = true;
                }
            }

            //if object going down
            if(p_yvel > 0)
            {
                //if object's bottom bound plus 1 is in a solid tile
                if(map[ (Point)/32 ][ (BoundBottom+1)/32 ] == 1)
                {
                    //set the object's yvel to 0 and return with 1
                    p_yvel = 0;
                    return 1;
                }
                else
                {
                    //set the MoveDown var to true
                    MoveDown = true;
                }
            }
        }
        //if the Move vars are now true, adjust the y values
        if(MoveUp == true) { p_y = p_y - 1; }
        if(MoveDown == true) { p_y = p_y + 1; }

        //if the object has gone out of array bounds, push it back on
        if(p_y < 0) { p_y = 0; p_yvel = 0; }
        if(p_y > 15*32) { p_y = 15*32; p_yvel = 0; }    //replace 15*32 with map height var/function
    }

    //if no solids were hit at all, return 0
    return 0;
}

Code: Select all

// Function Prototypes
void DrawFrame();
void Friction();
void DrawMap();
void DrawPlayer();
void GetInput();
int MoveHorizontal(float& p_xvel, float& p_x, float& p_y, int p_left, int p_right, int p_top, int p_bottom);
int MoveVertical(float& p_yvel, float& p_x, float& p_y, int p_left, int p_right, int p_top, int p_bottom);
void Shoot(int x, int y, bool dir);
void UpdateBullets();
void draw_tr_quad(int x, int y, int z, int w, int h, int a, int r, int g, int b);
void SetVMU();


// Classes
class Player {
public:
    //general movement
    float m_x, m_y;
    float m_xvel, m_yvel;

    //jumping
    bool m_jump;
    bool m_letgo;       //keeps track if the user is holding down space
	bool m_canshoot;    //keeps track if the user can shoot
    bool m_dir;
    float m_jumptimer;

	//stats
	int level, exp;
	int attack, defense, hp;
	int avgbattle_time, avgbattle_hits;

    //constructor
    Player() {
        m_x = 0;
        m_y = 0;
        m_xvel = 0;
        m_yvel = 0;
        m_jump = false;
        m_letgo = true;
        m_jumptimer = 0;
		m_canshoot = true;
		level = 0;
		exp = 0;
		attack = 5;
		defense = 5;
		hp = 10;
		avgbattle_time = 0;
		avgbattle_hits = 0;
    }

	void CheckLevelUp() {
		if(exp >= 100+(25*level)) LevelUp();
	}

	void LevelUp() {
		unsigned short int hp_base = 0, attack_base = 0, defense_base = 0, hp_bonus = 0, attack_bonus = 0, defense_bonus = 0; 
		
		//base stat increases
		hp_base      += rand()%2 + 1;
		attack_base  += rand()%2 + 1;
		defense_base += rand()%2 + 1;

		printf("Hp base: %d\nAttack base: %d\nDefense base: %d\n", hp_base, attack_base, defense_base);

		//bonus stat increases
		if(avgbattle_hits == 0) hp_bonus += 3;
		if(avgbattle_hits > 0 && avgbattle_hits < 3) hp_bonus += 2;
		if(avgbattle_hits > 2 && avgbattle_hits < 5) hp_bonus++;
		
		if(avgbattle_time > 0 && avgbattle_time < 601) attack_bonus += 3;
		if(avgbattle_time > 600 && avgbattle_time < 1561) attack_bonus += 2;
		if(avgbattle_time > 1560 && avgbattle_time < 2101) attack_bonus++;

        defense_bonus = rand()%hp_bonus + 1;

        printf("Hp bonus: %d\nAttack bonus: %d\nDefense bonus: %d\n", hp_bonus, attack_bonus, defense_bonus);

        level++;
		exp = 0;
	}
};

class Bullet { 
public: 
    int x; 
    int y; 
    bool active; 
    int direction;
}; 

Code: Select all

void SetVMU() {
    static const char vmu[] = {
	".....++.+++++++...+++++.+.++++..++++++++++++++++"
    "++.++.+.++.+++.++++++++.+.+.+.++.+.+++++++++++++"
    "++.++++.+.+.++.++++..++.+.+++.+++++++..++.+..+++"
    "++.++.+.+...++.+++.++.+.+.+.++..++.+.++.+..++.++"
    "++.++.+.+.++++.+++.++.+.+.+.++++.+.+.++.+.+++.++"
    "++.++.+.++..+++...+..++.+.+.+...++.++..++.+++.++"
    "++++++++++++++++++++++++++++++++++++++++++++++++"
    "..++++++...+++++++++++++++++++++.+++++...+++++++"
    ".+.++++.+++++++.+.++.+.+.+.+.+.+.+++.+.+++++++++"
    "..+++++.+..+.+...+..+..+..+...+...++++...+++++++"
    ".+..+.+.++.++.+.+++.+..+..+..+++.+.+.+++.+++++++"
    "..++.+++...+.++.++++.++.++.+.+++..++.+...+++++++"
    "+++.+++++++.++++++++++++++++++++++++++++++++++++"
    "++++++........++.+++.+++++++++++++++++++++++++++"
    "++++++++.++.++++.++.+..++++.+++++.+.+.+++.++++++"
    "++++++++.++...++.++.....+.+..+.++++..+.+.+.+++++"
    "++++++.+.++++.++.++.++.+.+..+.+.+.+.++.+.+.+++++"
    "+++++++..++...++...+...+.+..+.+.+.+.++.++..+++++"
    "++++++++++++++++++++++++++++++++++++++++.+.+++++"
    "++++++++++++++++++++++.+.++..++++++++++++.++++++"
    "++++++....+++...++++.+..+.+.++++++.++++.++.+++++"
    "+++++++.+.+++..++++.+...+++.+.+...+.+.+.+.++++++"
    "+++++++.++.+.+....+....+.+.....++....+...+++++++"
    "+++++++.++.+.++..+..++.++.+.+.+++.++.+..+.++++++"
    "+++++++.+++.++....++.....++.+.++++..+...++.+++++"
    "++++++++++++++++.+++++++++++++++++++++++++++++++"
    "++++++++++++++++.+++++++++++++++++++++++++++++++"
    "....+++..++...++++++++......+++..+++++++++++++++"
    "+.+.++.++..++.+++.++.+.++.+.+.+.++.++..+.+.+.+.+"
    "+.+......+.++....+..+.......++......+.+.+...+.+."
    "+.+.+..+++.++.+..+..+.++..+.+.+.++.++.+.+..++.+."
    "+.+.+.+..++...+.+..+.+....++..+.++.....+.+.++.+."};

    vmu_set_icon(vmu);
    uint8 logo_bits[48*32/8]; // Setting VMU dimensions (48x32)
	int x, y;

	for (y=0; y<32; y++) {
		for (x=0; x<48/8; x++) {
			logo_bits[y*48/8 + x] = vmu[(31-y)*48/8 + ((48/8 - 1) - x)];
		}
	}
}

Code: Select all

void Shoot(int x, int y, bool dir) {
    for(int i=0; i<3; i++) {
        if(bullet[i].active == false) {
            bullet[i].active = true;
            bullet[i].x = x;
            bullet[i].y = y + 20;
			bullet[i].direction = dir;
            break;
        }
    }
}

void UpdateBullets() {
	for(int a=0; a<3; a++) { 
		if(bullet[a].active) {
			if(bullet[a].direction == 0) bullet[a].x -= 14; // Left
			if(bullet[a].direction == 1) bullet[a].x += 14; // Right 

			draw_tr_quad(bullet[a].x, bullet[a].y - 16, 5, 4, 4, 1, 256-255, 256-1, 256-1);

            if(bullet[a].x < 0 || bullet[a].x > 640 || bullet[a].y < 0 || bullet[a].y > 480) {
                bullet[a].active = false;
			}
            else{
                for(int Point = bullet[a].y; Point < bullet[a].y+4; Point++){
                    if(map[ (bullet[a].x)/32 ][ (Point)/32 ] == 1) {
						map[ (bullet[a].x)/32 ][ (Point)/32 ] = 0;
						bullet[a].active = false;
					}
				}
			}
        } 
    }
}

Code: Select all

void draw_tr_quad(int x, int y, int z, int w, int h, int a, int r, int g, int b) { 
	pvr_poly_cxt_t cxt; 
	pvr_poly_hdr_t hdr; 
	pvr_vertex_t vert; 
	pvr_poly_cxt_col(&cxt,PVR_LIST_TR_POLY); 
	pvr_poly_compile(&hdr,&cxt); 
	pvr_prim(&hdr,sizeof(hdr)); 
	vert.argb = PVR_PACK_COLOR(a,r,g,b);    
	vert.oargb = 0; 
	vert.flags = PVR_CMD_VERTEX; 
	vert.x = x-(w/2); 
	vert.y = y-(h/2); 
	vert.z = z; 
	pvr_prim(&vert,sizeof(vert)); 
	vert.x = x+(w/2); 
	vert.y = y-(h/2); 
	vert.z = z;
	pvr_prim(&vert,sizeof(vert)); 
	vert.x = x-(w/2); 
	vert.y = y+(h/2); 
	vert.z = z; 
	pvr_prim(&vert,sizeof(vert)); 
	vert.x = x+(w/2); 
	vert.y = y+(h/2); 
	vert.z = z; 
	vert.flags = PVR_CMD_VERTEX_EOL; 
	pvr_prim(&vert,sizeof(vert)); 
} 

Code: Select all

123
456
789

Code: Select all

123000
456000
789000

Code: Select all

123 
456 
789

Code: Select all

123456789

Code: Select all

123000 
456000 
789000

Code: Select all

123000456000789000