rendered paste body/* Mario interpreter for the iPod
* Written from scratch by Joseph Constan (Saintjimmy5294)
* This is just an Early Alpha Release, but
* I plan to have the Interpreter open an external text file
* with level data in it and load the level from there.
* I haven't done it yet (still confused a bit w/ file pointers)
* But until then, It's just a simple Mario Game, demo, thingy.
*/
/* Oh, and special thanks to
* zacaj, for the idea
* Mike Sweeney (ichaelmay8), for writing iBolo,
* whose level loading system I based mine off of ;)
* Nintendo, for wowing the world with the invention of Mario,
* Um, Apple, I guess, for making the iPod,
* And, of course, the iPodlinux team, without whom this would not be possible.
*/
//May 17, 2007, in this program, I wrote my first 1,000 lines of code. This one's goin' in the baby book :D
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "pz.h"
#include <errno.h>
#include <string.h>
#define LBLUE 0, 240, 255 //defines value for teh color Light Blue
#define SHEIGHT (ttk_screen->h - ttk_screen->wy) //sets SHEIGHT to the height of the screen
#define SHWIDTH (ttk_screen->w) //sets SWIDTH to the height of the screen
static PzModule *module;
/*images (for the ones with arrays, ie. goomba[2], the number represents the frames)*/
static ttk_surface small_mario_left[2]; //small mario facing left
static ttk_surface small_mario_right[2]; //small mario facing right
static ttk_surface mario_left[3]; //mario facing left
static ttk_surface mario_right[3]; //mario facing right
static ttk_surface flower_mario_left[3]; //flower mario facing left
static ttk_surface flower_mario_right[3]; //flower mario facing right
static ttk_surface mario_crouch_right; //mario crouching & facing right
static ttk_surface mario_crouch_left; //mario crouching & facing left
static ttk_surface goomba[2]; //goomba
static ttk_surface goomba_squish; //goomba squished
static ttk_surface gkoopa_l[2]; //green koopa facing left
static ttk_surface gkoopa_r[2]; //green koopa facing right
static ttk_surface rkoopa_l[2]; //red koopa facing left
static ttk_surface rkoopa_r[2]; //red koopa facing right
static ttk_surface redshell[4]; //red shell spinning
static ttk_surface greenshell[4]; //green shell spinning
static ttk_surface ground; //image of ground (brick)
static ttk_surface block; //coin block
static ttk_surface qblock[4]; //question mark (powerup) block
static ttk_surface coin[4]; //coin image
static ttk_surface mushroom; //mushroom
static ttk_surface 1up; //green mushroom (extra life)
static ttk_surface flower; //power flower
//static ttk_surface star[4]; //star for to give you teh invinsiblity!!!11!1!!
static ttk_surface fireball[4]; //OH NOES!! T3h f1r3b4l1 0f z3h d3th!!1! run 4w4yz!
/*variable declarations (brace yourself there's a lot of them)*/
static int mario_x; //x coordinate of mario
static int mario_y; //y coordinate of mario
static int goomba_x[100]; //x coordinate of goomba
static int goomba_y[100]; //y coordinate of goomba
static int gkoopa_x[100]; //x coordinate of teh green koopa
static int gkoopa_y[100]; //y coordinate of teh green koopa
static int rkoopa_x[100]; //x coordinate of teh red koopa
static int rkoopa_y[100]; //y coordinate of teh red koopa
static int ground_x[100]; //x coordinate of the ground
static int ground_y[100]; //y coordinate of the ground
static int block_x[100]; //x coordinate of block
static int block_y[100]; //y coordinate of block
static int qblock_x[100]; //x coordinate of question mark block
static int qblock_y[100]; //y coordinate of question mark block
static int coin_x[100]; //x coordinate of coin
static int coin_y[100]; //y coordinate of coin
static int mushroom_x; //I think you get the idea by now, if not, get some help
static int mushroom_y;
static int 1up_x;
static int 1up_y;
static int flower_x;
static int flower_y;
//static int star_x;
//static int star_y;
static int fireball_x[2];
static int fireball_y[2];
static int start_x;
static int start_y;
static int end_x;
static int view_x=0; //left end of viewport
static int view_y=0; //bottom of viewport
static int view_w=SWIDTH; //width of viewport, automatically set to the width of the iPod's screen
static int view_h=SHEIGHT; //height of viewport, automatically set to the height of the iPod's screen
static int eframe=0; //frame for the animation of koopas and goombas
static int mframe=0; //frame for the animation of mario
static int mdirection; //direction mario [0], green koopa [1] or red koopa [2] is facing, 1=left. 2=right
static int mwalk=0; //if mario is moving (running or walking), 1=yes, 0=no
static int mjump=0; //if mario is jumping, 1=yes, 0=no
static int mrun=0; //if mario is running, 1=running, 0=walking
static int mcrouch=0; //if mario is crouching, 1=yes, 0=no
static int invincible=0; //if mario is unnnnn-tuchable
static int fallpt; //when mario starts falling after he jumps
static int onground; //if mario is on the ground
static int buttondown[5]={0,0,0,0,0}; //if button is down, 1=yes, 2=no; [0]=select, 1=menu, 2=prev, 3=next, 4=down
static int rkoopa_direction[100];
static int gkoopa_direction[100];
static int i=0, j=0, k=0, l=0, m=0, n=0, o=0, p=0, q=0, r=0, s=0, t=0, u=0, v=0, w=0, a=0, b=0; //don't ask
static int goomba_state[100]; /*whether goomba is alive (1), squished (2), or dead(0)*/
static int rkoopa_state[100]; /*whether red koopa is alive (1), in shell (2), or dead(0)*/
static int gkoopa_state[100]; /*whether green koopa is alive (1), in shell (2), or dead(0)*/
static int item_state[4]=(1,1,1,1); /*whether item is unused (item_state[]=1) or used(=0).
Array: [1] - mushroom, [2] - green mushroom, [3] - power flower, [0] - star*/
static int item_direction[3]=(1,1,1); //self explanatory, 1=left, 2=right, [0] - mushroom, [2] - green mushroom, [0] - star
static int block_state[100]; //whether block is unhit (block_state[]=1, being hit(2), or hit(=0)
static int qblock_state[100]; //same as above
static int coin_state[100]; //same as above
static int mario_state=1; //whether mario is small (1), big (2), flower (3), or, heaven forbid, dead (0)
static int mxspeed=0; //mario's horizontal speed
static int myspeed=0; //No, not "my speed", mario's vertical speed
static int rkxspeed[100]; //red koopa's horizontal speed
static int rkyspeed[100]; //red koopa's vertical speed
static int gkxspeed[100]; //green koopa's horizontal speed
static int gkyspeed[100]; //green koopa's vertical speed
static int gxspeed[100]; //goomba's horizontal speed
static int gyspeed[100]; //goomba's vertical speed
static int lives=3;
static int coins=0;
static int score=0;
static int lvl_width=20;
static int lvl_height=14;
static int lvl_tiles=lvl_width*lvl_height;
static char leveldata1[lvl_tiles]={ .,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,
.,Q,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,
.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,
C,C,C,C,C,C,.,.,.,.,.,.,.,.,.,.,.,.,.,.,
B,B,B,B,B,B,C,.,.,.,.,.,.,.,.,.,.,.,.,.,
.,.,.,.,.,.,B,C,.,.,.,.,.,.,.,.,.,.,.,.,
.,.,.,.,.,.,.,B,C,.,.,.,.,.,.,.,.,.,.,.,
.,.,.,.,.,.,.,.,B,.,.,.,.,k,.,.,.,.,.,.,
.,.,.,.,.,.,.,.,.,B,B,B,B,B,B,.,.,.,.,., //The Leveldata is the information
.,Q,B,.,.,.,.,.,.,.,.,.,.,.,.,.,.,B,.,., //used to load the level, such as
.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,.,B,B,.,., //locations of start and end loca-
S,.,.,.,B,g,.,.,.,r,.,B,C,C,C,B,B,B,.,E, //tions. It uses an array based on
G,G,G,G,G,G,G,G,G,G,G,G,G,G,G,G,G,G,G,G, //the size of the level, which is
G,G,G,G,G,G,G,G,G,G,G,G,G,G,G,G,G,G,G,G}; //height * width.
//Done with declarations, starting the game (sorta)
static void draw_mario(PzWidget *wid, ttk_surface srf)
{
int x=0;
int y=0;
int tilex=0;
int tiley=0;
ttk_fillrect (srf, 0, 0, SWIDTH, SHEIGHT, ttk_makecol(LBLUE));
/*Level Drawing (I'm confused on this part and will probably screw up, but bear with me here) (Most of the stuff is explained in the block functiony thingy)*/
while(y<lvl_width)
{
if(leveldata1[x]==G)//ground
{
if(ground_x[i]>view_x && ground_x[i]<view_x+view_w && ground_y[i]>view_y && ground_y[i]<view_y+view_h)
{
ttk_blit_image (ground, srf, ground_x[i] - view_x, ground_y[i] - view_y);
ground_y=tiley;
ground_x=tilex;
}
i++;
if(i=99)
i=0;
}
if(leveldata1[x]==S)//start point
{
start_x=tilex;
start_y=tiley;
}
if(leveldata1[x]==E)//end point
{
end_x=tilex;
end_y=tiley;
}
if(leveldata1[x]==B && block_state[j]!=0)//regular block
{
if(block_x[j]>view_x && block_x[j]<view_x+view_w && block_y[j]>view_y && block_y[j]<view_y+view_h && block_state[j]!=0) //checks if the block is on the screen (if it only has to worry about stuff thats on the screen, it saves a lot of memory and stuff (thats how Nintendo did it ;D))
{
block_x[j]=tilex; //sets the block's x coordinate (block_x) to the tile it is currently checking
block_y[j]=tiley; //sets the block's y coordinate to the current tile
if(block_state[j]==1) //if the block is not broken
ttk_blit_image (block, srf, block_x[j] - view_x, block_y[j] - view_y); //draws the image
else if(block_state[j]==2) //if block is being hit
{
ttk_blit_image (block, srf, block_x[j] - view_x - 4, block_y[j] - view_y - 4); //draws the image 4 px higher than usual
}
}
j++; //with all this code, I almost look like I know what I'm doing =O
if(j==99)
j=0;
}
if(leveldata1[x]==Q)//? powerup block
{
if(qblock_x[k]>view_x && qblock_x[k]<view_x+view_w && qblock_y[k]>view_y && qblock_y[k]<view_y+view_h)
{
qblock_x[k]=tilex;
qblock_y[k]=tiley;
if(qblock_state[k]=1)
ttk_blit_image (qblock[qframe], srf, qblock_x[k] - view_x, qblock_y[k] - view_y);
else if(qblock_state[k]==2)
{
ttk_blit_image (qblock[qframe], srf, qblock_x[k] - view_x - 5, qblock_y[k] - view_y - 5);
}
else
ttk_blit_image (usedblock, srf, qblock_x[k] - view_x, qblock_y[k] - view_y);
}
k++;
if(k==99)
k=0;
}
/*if(star_x[b]>view_x && star_x[b]<view_x+view_w && star_y[b]>view_y && star_y[b]<view_y+view_h)
{
star_x[b]=tilex;
star_y[b]=tiley;
if(qblock_state=1)
ttk_blit_image (qblock[qframe], srf, qblock_x[k] - view_x, qblock_y[k] - view_y);
else if(qblock_state[k]==2)
{
ttk_blit_image (qblock, srf, qblock_x[k] - view_x - 5, qblock_y[k] - view_y - 5);
}
else
ttk_blit_image (usedblock, srf, qblock_x[k] - view_x, qblock_y[k] - view_y);
}
k++;
if(k==99)
k=0;
*/
if(leveldata1[x]==C && coin_state[l]!=0)//coin
{
if(coin_x[l]>view_x && coin_x[l]<view_x+view_w && coin_y[l]>view_y && coin_y[l]<view_y+view_h)
{
coin_x[l]=tilex;
coin_y[l]=tiley;
ttk_blit_image (coin[qframe], srf, coin_x[l] - view_x, coin_y[l] - view_y);
l++;
}
if(l==99)
l=0;
}
if(leveldata1[x]==g)//goomba
{
if(goomba_x[m]>view_x && goomba_x[m]<view_x+view_w && goomba_y[m]>view_y && goomba_y[m]<view_y+view_h)
{
goomba_x[m]=tilex;
goomba_y[m]=tiley;
m++;
}
if(m==99)
m=0;
}
if(leveldata1[x]==r)//red koopa
{
if(rkoopa_x[n]>view_x && rkoopa_x[n]<view_x+view_w && rkoopa_y[n]>view_y && rkoopa_y[n]<view_y+view_h)
{
rkoopa_x[n]=tilex;
rkoopa_y[n]=tiley;
n++;
}
if(n==99)
n=0;
}
if(leveldata1[x]==k)//green koopa
{
if(gkoopa_x[o]>view_x && gkoopa_x[o]<view_x+view_w && gkoopa_y[o]>view_y && gkoopa_y[o]<view_y+view_h)
{
gkoopa_x[o]=tilex;
gkoopa_y[o]=tiley;
o++;
}
if(o==99)
o=0;
}
x++;
tilex=tilex+16;
if(tilex==144)
{
tilex=0;
y++;
tiley=tiley+16;
}
}
mario_x=start_x;
mario_y=start_y+12;
draw_images();
}
static void draw_images()
{
if(mushroom_x>view_x && mushroom_x<view_x+view_w && mushroom_y>view_y && mushroom_y<view_y+view_h && item_state[1]==1)
{
ttk_blit_image (mushroom, srf, mushroom_x - view_x, mushroom_y - view_y);
}
if(goomba_x[p]>view_x && goomba_x[p]<view_x+view_w && goomba_y[p]>view_y && goomba_y[p]<view_y+view_h && goomba_state[p]!=0)
{
if(goomba_state==1)
ttk_blit_image (goomba[eframe], srf, goomba_x[p] - view_x, goomba_y[p] - view_y);
else if(goomba_state==2)
ttk_blit_image (goomba_squished, srf, goomba_x[p] - view_x, (goomba_y[p] + 8) - view_y);
p++;
if(p==99)
p=0;
}
if(gkoopa_x[q]>view_x && gkoopa_x[q]<view_x+view_w && gkoopa_y[q]>view_y && gkoopa_y[q]<view_y+view_h && gkoopa_state[q]!=0)
{
if(gkoopa_state==1)
{
if(gkoopa_direction[q]==1)
ttk_blit_image (gkoopa_l[eframe], srf, gkoopa_x[q] - view_x, gkoopa_y[q] - view_y);
if(gkoopa_direction[q]=2)
ttk_blit_image (gkoopa_r[eframe], srf, gkoopa_x[q] - view_x, gkoopa_y[q] - view_y);
}
else if(gkoopa_state==2)
ttk_blit_image (greenshell[qframe], srf, gkoopa_x[q] - view_x, (gkoopa_y[q] - 9) - view_y);
q++;
if(q==99)
q=0;
}
if(rkoopa_x[r]>view_x && rkoopa_x[r]<view_x+view_w && rkoopa_y[r]>view_y && rkoopa_y[r]<view_y+view_h && rkoopa_state[r]!=0)
{
if(rkoopa_state==1)
{
if(rkoopa_direction[r]==1)
ttk_blit_image (gkoopa_l[eframe], srf, gkoopa_x[q] - view_x, gkoopa_y[q] - view_y);
if(rkoopa_direction[r]=2)
ttk_blit_image (gkoopa_r[eframe], srf, gkoopa_x[q] - view_x, gkoopa_y[q] - view_y);
}
else if(gkoopa_state==2)
ttk_blit_image (greenshell[qframe], srf, gkoopa_x[q] - view_x, (gkoopa_y[q] - 9) - view_y);
r++;
if(r==99)
r=0;
}
if(mario_x>view_x && mario_x<view_x+view_w && mario_y>view_y && mario_y<view_y+view_h)
{
if(mdirection==1 && mario_state==1 && mwalk==1 && mcrouch==0) //if mario is small and walking left
ttk_blit_image (small_mario_left[eframe], srf, mario_x - view_x, mario_y - (view_y + 9));
if(mdirection==1 && mario_state==1 && mwalk==0 && mcrouch==0) //if mario is small and standing left
ttk_blit_image (small_mario_left[0], srf, mario_x - view_x, mario_y - (view_y + 9));
if(mdirection==1 && mario_state==2 && mwalk==1 && mcrouch==0) //if mario is big and walking left
ttk_blit_image (mario_left[mframe], srf, mario_x - view_x, mario_y - view_y);
if(mdirection==1 && mario_state==2 && mwalk==0 && mcrouch==0) //if mario is big and standing left
ttk_blit_image (mario_left[0], srf, mario_x - view_x, mario_y - view_y);
if(mdirection==1 && mario_state==3 && mwalk==1 && mcrouch==0) //if mario has flower powers and is walking left
ttk_blit_image (flower_mario_left[mframe], srf, mario_x - view_x, mario_y - view_y);
if(mdirection==1 && mario_state==3 && mwalk==0 && mcrouch==0) //if mario has flower powers and is standing left
ttk_blit_image (flower_mario_left[0], srf, mario_x - view_x, mario_y - view_y);
if(mdirection==2 && mario_state==1 && mwalk==1 && mcrouch==0) //if mario is small and walking right
ttk_blit_image (small_mario_right[eframe], srf, mario_x - view_x, mario_y - view_y);
if(mdirection==2 && mario_state==1 && mwalk==0 && mcrouch==0) //if mario is small and standing right
ttk_blit_image (small_mario_right[0], srf, mario_x - view_x, mario_y - (view_y + 9));
if(mdirection==2 && mario_state==2 && mwalk==1 && mcrouch==0) //if mario is big and walking right
ttk_blit_image (mario_right[mframe], srf, mario_x - view_x, mario_y - (view_y + 9));
if(mdirection==2 && mario_state==2 && mwalk==0 && mcrouch==0) //if mario is big and standing right
ttk_blit_image (mario_right[0], srf, mario_x - view_x, mario_y - view_y);
if(mdirection==2 && mario_state==3 && mwalk==1 && mcrouch==0) //if mario has flower powers and is walking right
ttk_blit_image (flower_mario_right[mframe], srf, mario_x - view_x, mario_y - view_y);
if(mdirection==2 && mario_state==3 && mwalk==0 && mcrouch==0) //if mario has flower powers and is standing right
ttk_blit_image (flower_mario_right[0], srf, mario_x - view_x, mario_y - view_y);
if(mdirection==1 && mcrouch==1) //if mario is crouching and is facing left
ttk_blit_image (flower_mario_right[mframe], srf, mario_x - view_x, mario_y - view_y);
if(mdirection==2 && mcrouch==1) //if mario is crouching and is facing right
ttk_blit_image (flower_mario_right[0], srf, mario_x - view_x, mario_y - view_y);
else if(mario_state=0) //mario is dead-dead
lives=lives-1;
}
mframe++; //changes frame for mario's animation
if(mframe==2)
mframe=0;
eframe++; //changes frame for teh enemy animations,
if(eframe==1) //and since koopas and goombas only have
eframe=0; //2 frames, I only need 1 variable for them all :D.
qframe++;
if(qframe==3)
qframe=0;
}
if(t=2)//<- remember to fix this part so it only happens when there are less than 2 fireballs on the screen
t=0;
if(mwalk==1 && mrun==0 && mdirection=2) //mario is walking right (but not running cuz he might trip :o)
mxspeed=4;
if(mwalk==1 && mrun==1 && mdirection=2) //mario is running right (but be careful now, don't go too fast ;))
mxspeed=6;
if(mwalk==1 && mrun==0 && mdirection=1) //mario is walking left
mxspeed=-4;
if(mwalk==1 && mrun==1 && mdirection=1) //mario is running left
mxspeed=-6;
if(mwalk==0) //mario's a just standin der, chillin
mxspeed=0;
if(mjump==1 && onground==1) //mario wants to jump and is on the ground
{
fallpt=mario_y-64;
myspeed=4;
}
if(mario_x>=fallpt) //the (fake and badly coded) gravity kicks in and mario starts to fall
myspeed--;
if(myspeed<-4) //gravity is just too much
myspeed=-4;
if(myspeed>4) //going up too fast
myspeed=4;
if(mario_state!=0 && myspeed!=0) //mario is not on the ground
mario_y=mario_y-myspeed;
if(mario_state!=0 && mxspeed!=0)
mario_x=mario_x+mxspeed;
if(onground=0 && myspeed<=0 && myspeed!=-4)//there's probably a better way to do this, I'm just too lazy to figure it out
myspeed--;
if(mario_state==1) //Mario is small
{
if(mario_x<ground_x[u]+16 && mario_x+16>ground_x[u] && mario_y+19<=ground_y[u]+16 && mario_y+19>=ground_y[u]) //mario is on a block of ground
onground=1;
if(mario_x<block_x[u]+16 && mario_x+16>block_x[u] && mario_y+19<=block_y[u]+16 && mario_y+19>=ground_y[u]) //mario is on a block
onground=1;
if(mario_x<qblock_x[u]+16 && mario_x+16>qblock_x[u] && mario_y+19<=qblock_y[u]+16 && mario_y+19>=ground_y[u]) //mario is on a [?] block
onground=1;
else
onground=0;
if(mario_x>=rkoopa_x[u]-16 && mario_x<=rkoopa_x[u]+8 && mario_y+19>=rkoopa_y[u] && mario_y+19<=rkoopa_y[u]+16 && myspeed<0)
{
if(rkoopa_state[u]==1)
{
if(mario_y+19>rkoopa_y[u]+8 && myspeed<0)
{
lives--;
mario_die();
}
else
{
myspeed=4;
rkoopa_state[u]=2;
}
}
else if(rkoopa_state==2)
{
if(mario_y+19>rkoopa_y[u]+8 && myspeed<0)
{
lives--;
mario_die();
}
else
{
rkxspeed[u]=-6;
myspeed=4;
)
}
}
if(mario_x>rkoopa_x[u]+8 && mario_x<=rkoopa_x[u]+16 && mario_y+19>=rkoopa_y[u] && mario_y+19<=rkoopa_y[u]+16 && myspeed<0)
{
if(rkoopa_state[u]==1)
{
if(mario_y+19>rkoopa_y[u]+8 && myspeed<0)
{
lives--;
mario_die();
}
else
{
myspeed=4;
rkoopa_state[u]=2;
}
}
else if(rkoopa_state==2)
{
if(mario_y+19>rkoopa_y[u]+8 && myspeed<0)
{
lives--;
mario_die();
}
else
{
rkxspeed[u]=-6;
myspeed=4;
)
}
}
if(mario_x>=gkoopa_x[u]-16 && mario_x<=gkoopa_x[u]+8 && mario_y+19>=gkoopa_y[u] && mario_y+19<=gkoopa_y[u]+16 && myspeed<0)
{
if(gkoopa_state[u]==1)
{
if(mario_y+19>gkoopa_y[u]+8 && myspeed<0)
{
lives--;
mario_die();
}
else
{
myspeed=4;
gkoopa_state[u]=2;
}
}
else if(gkoopa_state==2)
{
if(mario_y+19>gkoopa_y[u]+8 && myspeed<0)
{
lives--;
mario_die();
}
else
{
gkxspeed[u]=-6;
myspeed=4;
)
}
}
if(mario_x>gkoopa_x[u]+8 && mario_x<=gkoopa_x[u]+16 && mario_y+19>=gkoopa_y[u] && mario_y+19<=gkoopa_y[u]+16 && myspeed<0)
{
if(gkoopa_state[u]==1)
{
if(mario_y+19>gkoopa_y[u]+8 && myspeed<0)
{
lives--;
mario_die();
}
else
{
myspeed=4;
gkoopa_state[u]=2;
}
}
else if(gkoopa_state==2)
{
if(mario_y+19>gkoopa_y[u]+8 && myspeed<0)
{
lives--;
mario_die();
}
else
{
gkxspeed[u]=-6;
myspeed=4;
)
}
}
if(mario_x>=goomba_x[u]-16 && mario_x<=goomba_x[u]+16 && mario_y+19>=goomba_y[u] && mario_y+19<=goomba_y[u]+16 && myspeed<0)
{
if(myspeed<0)
{
myspeed=4;
goomba_state[u]=2;
}
else if(myspeed!<0)
{
lives--;
mario_die();
}
}
}
if(mario_state==2 || mario_state==3) //Mario is big or flower
{
if(mario_x<ground_x[u]+16 && mario_x+16>ground_x[u] && mario_y+28<=ground_y[u]+16 && mario_y+28>=ground_y[u]) //mario is on a block of ground
onground=1;
if(mario_x<block_x[u]+16 && mario_x+16>block_x[u] && mario_y+28<=block_y[u]+16 && mario_y+28>=block_y[u]) //mario is on a block
onground=1;
if(mario_x<qblock_x[u]+16 && mario_x+16>qblock_x[u] && mario_y+28<=qblock_y[u]+16 && mario_y+28>=qblock_y[u])) //mario is on a [?] block
onground=1;
else
onground=0;
if(mario_x>=rkoopa_x[u]-16 && mario_x<=rkoopa_x[u]+8 && mario_y+28>=rkoopa_y[u] && mario_y+28<=rkoopa_y[u]+16 && myspeed<0)
{
if(rkoopa_state[u]==1)
{
if(mario_y+28>rkoopa_y[u]+8 && myspeed<0)
{
mario_state=1;
}
else
{
myspeed=4;
rkoopa_state[u]=2;
}
}
else if(rkoopa_state==2)
{
if(mario_y+28>rkoopa_y[u]+8 && myspeed<0)
{
mario_state=1;
}
else
{
rkxspeed[u]=-6;
myspeed=4;
)
}
}
if(mario_x>rkoopa_x[u]+8 && mario_x<=rkoopa_x[u]+16 && mario_y+28>=rkoopa_y[u] && mario_y+28<=rkoopa_y[u]+16 && myspeed<0)
{
if(rkoopa_state[u]==1)
{
if(mario_y+28>rkoopa_y[u]+8 && myspeed<0)
{
mario_state=1;
}
else
{
myspeed=4;
rkoopa_state[u]=2;
}
}
else if(rkoopa_state==2)
{
if(mario_y+28>rkoopa_y[u]+8 && myspeed<0)
{
mario_state=1;
}
else
{
rkxspeed[u]=-6;
myspeed=4;
)
}
}
if(mario_x>=gkoopa_x[u]-16 && mario_x<=gkoopa_x[u]+8 && mario_y+28>=gkoopa_y[u] && mario_y+28<=gkoopa_y[u]+16 && myspeed<0)
{
if(gkoopa_state[u]==1)
{
if(mario_y+28>gkoopa_y[u]+8 && myspeed<0)
{
mario_state=1;
}
else
{
myspeed=4;
gkoopa_state[u]=2;
}
}
else if(gkoopa_state==2)
{
if(mario_y+28>gkoopa_y[u]+8 && myspeed<0)
{
mario_state=1;
}
else
{
gkxspeed[u]=-6;
myspeed=4;
)
}
}
if(mario_x>gkoopa_x[u]+8 && mario_x<=gkoopa_x[u]+16 && mario_y+28>=gkoopa_y[u] && mario_y+28<=gkoopa_y[u]+16) //Mario is touching the eft side of the green koopa
{
if(gkoopa_state[u]==1)
{
if(mario_y+28>gkoopa_y[u]+8 && myspeed<0)
{
mario_state=1;
}
else
{
myspeed=4;
gkoopa_state[u]=2;
}
}
else if(gkoopa_state==2)
{
if(mario_y+28>gkoopa_y[u]+8 && myspeed<0)
{
mario_state=1;
}
else
{
gkxspeed[u]=-6;
myspeed=4;
)
}
}
if(mario_x>=goomba_x[u]-16 && mario_x<=goomba_x[u]+16 && mario_y+28>=goomba_y[u] && mario_y+28<=goomba_y[u]+16 && goomba_state[u]==1)
{
if(myspeed<0)
{
myspeed=4;
goomba_state[u]=2;
}
else if(myspeed!<0)
{
mario_state=1;
}
}
if(mario_x>=mushroom_x-16 && mario_x<=mushroom_x+16 && mario_y+28>=mushroom_y && mario_y+28<=mushroom_y+16)
{
mario_state=2;
score=score+1000;
item_state[1]=0;
}
if(mario_x>=1up_x-16 && mario_x<=1up_x+16 && mario_y+28>=1up_y && mario_y+28<=1up_y+16)
{
lives++;
score=score+1000;
item_state[3]=0;
}
if(mario_x>=flower_x-16 && mario_x<=flower_x+16 && mario_y+28>=flower_y && mario_y+28<=flower_y+16)
{
mario_state=3;
score=score+1000;
item_state[3]=0;
}
if(mario_x>=coin_x[u]-16 && mario_x<=coin_x[u]+16 && mario_y+28>=coin_y[u] && mario_y+28<=coin_y[u]+16)
{
coins++;
score=score+100;
coin_state[u]=0;
}
}
if(onground==1 && myspeed<0) //If Mario is falling and hits the ground
myspeed=0; //break the fall (so he doesn't go through the ground of course)
if(mario_x<=block_x[u]+16 && mario_x+16>=block_x[u] && mario_y<=block_y[u]+16 && mario_y>=block_y[u] && myspeed>2) //mario hits a block (from under it)
{
myspeed=myspeed*-1; //reverse vertical speed
block_state[u]=2; //tell the computer that the block was hit but hasn't paid its coin yet
}
/*All the stuff for the viewport system*/
if(view_x+(view_w/2)<mario_x && view_x+view_h!>lvl_width*16)
view_x=view_x+mxspeed;
if(view_x+(view_w/2)>mario_x && view_x!<0)
view_x=view_x+mxspeed;
if(view_y+(view_h/2)<mario_y && view_y+view_h!>lvl_height*16)
view_y=view_y+myspeed;
if(view_y+(view_h/2)>mario_y && view_y!<0)
view_y=view_y+myspeed;
if(rkoopa_state[u]!=0)
{
if(rkoopa_y[u]<block_y[w]+16 && rkoopa_y[u]>block_y[w]-16 && rkoopa_x[u]<=block_x[w] && rkoopa_x[u]>=block_x[w]-16 && )
{
rkxspeed[u]=rkxspeed[u]*-1;
if(rkoopa_state=2)
block_state[w]=2;
}
else if(rkoopa_y[u]<block_y[w]+16 && rkoopa_y[u]>block_y[w]-16 && rkoopa_x[u]>=block_x[w] && rkoopa_x[u]<=block_x[w]+16)
{
rkxspeed[u]=rkxspeed[u]*-1;
if(rkoopa_state=2)
block_state[w]=2;
}
else if(rkoopa_y[u]<qblock_y[w]+16 && rkoopa_y[u]>qblock_y[w]-16 && rkoopa_x[u]<=qblock_x[w] && rkoopa_x[u]>=qblock_x[w]-16)
{
rkxspeed[u]=rkxspeed[u]*-1;
if(rkoopa_state=2)
qblock_state[w]=2;
}
else if(rkoopa_y[u]<qblock_y[w]+16 && rkoopa_y[u]>qblock_y[w]-16 && rkoopa_x[u]>=qblock_x[w] && rkoopa_x[u]<=qblock_x[w]+16)
{
rkxspeed[u]=rkxspeed[u]*-1;
if(rkoopa_state=2)
qblock_state[a]=2;
}
else if(rkoopa_y[u]<ground_y[w]+16 && rkoopa_y[u]>ground_y[w]-16 && rkoopa_x[u]<=ground_x[w] && rkoopa_x[u]>=ground_x[w]-16)
{
rkxspeed[u]=rkxspeed[u]*-1;
}
else if(rkoopa_y[u]<ground_y[w]+16 && rkoopa_y[u]>ground_y[w]-16 && rkoopa_x[u]>=ground_x[w] && rkoopa_x[u]<=ground_x[w]+16)
{
rkxspeed[u]=rkxspeed[u]*-1;
}
/*this is the part where a red koopa is at the edge of a platform and turns around (badly coded, 'cuz I'm tired)*/
else if((rkoopa_y[u]+25!>ground_y[w] && rkoopa_y[u]+39!<ground_y[w] && rkoopa_x[u]!>ground_x && rkoopa_x!<ground_x-16) && (rkoopa_y[u]+25!>block_y[w] && rkoopa_y[u]+39!<block_y[w] && rkoopa_x[u]!>block_x && rkoopa_x!<block_x-16) && (rkoopa_y[u]+25!>qblock_y[w] && rkoopa_y[u]+39!<qblock_y[w] && rkoopa_x[u]!>qblock_x && rkoopa_x!<qblock_x-16)
(
if(rkoopa_sttate[u]==1)
{
rkxspeed[u]=rkxspeed[u]*-1;
}
else if(rkoopa_state[u]==20
{
rkyspeed[u]=-4;
}
}
else if(w==99)
w=0;
else
w++;
}
if(gkoopa_state[u]!=0)
{
if(gkoopa_y[u]<block_y[a]+16 && gkoopa_y[u]>block_y[a]-16 && gkoopa_x[u]<=block_x[a] && gkoopa_x[u]>=block_x[a]-16)
{
gkxspeed[u]=gkxspeed[u]*-1;
if(gkoopa_state=2)
block_state[a]=2;
}
else if(gkoopa_y[u]<block_y[a]+16 && gkoopa_y[u]>block_y[a]-16 && gkoopa_x[u]>=block_x[a] && gkoopa_x[u]<=block_x[a]+16)
{
gkxspeed[u]=gkxspeed[u]*-1;
if(gkoopa_state=2)
block_state[a]=2;
}
else if(gkoopa_y[u]<qblock_y[a]+16 && gkoopa_y[u]>qblock_y[a]-16 && gkoopa_x[u]<=qblock_x[a] && rkoopa_x[u]>=qblock_x[a]-16)
{
gkxspeed[u]=gkxspeed[u]*-1;
if(gkoopa_state=2)
qblock_state[a]=2;
}
else if(gkoopa_y[u]<qblock_y[a]+16 && gkoopa_y[u]>qblock_y[a]-16 && gkoopa_x[u]>=qblock_x[a] && gkoopa_x[u]<=qblock_x[a]+16)
{
gkxspeed[u]=gkxspeed[u]*-1;
if(gkoopa_state=2)
qblock_state[a]=2;
}
else if((gkoopa_y[u]+25!>ground_y[w] && gkoopa_y[u]+39!<ground_y[w] && gkoopa_x[u]!>ground_x && gkoopa_x!<ground_x-16) && (gkoopa_y[u]+25!>block_y[w] && gkoopa_y[u]+39!<block_y[w] && gkoopa_x[u]!>block_x && gkoopa_x!<block_x-16) && (gkoopa_y[u]+25!>qblock_y[w] && gkoopa_y[u]+39!<qblock_y[w] && gkoopa_x[u]!>qblock_x && gkoopa_x!<qblock_x-16)
{
gkyspeed=-4;
}
else if(a==99)
a=0;
else
a++;
}
if(qblock_state[u]==2)
{
if(mario_state==1)
{
mushroom_y=qblock_y[u]+16;
mushroom_x=qblock_x[u];
item_direction[1]=2;
qblock_state[u]=0;
}
if(mario_state==2 || mario_state==3
{
flower_y=qblock_y[u]+16;
flower_x=qblock_x[u];
qblock_state[u]=0;
}
}
if(block_state[u]==2)
{
ttk_blit_image (coin[0], srf, block_x[u], block_y[u]+16));
coins++;
block_state[u]=0;
}
if(item_state[1]!=0)
{
if(mushroom_y[u]<block_y[a]+16 && mushroom_y[u]>block_y[a]-16 && mushroom_x[u]<=block_x[a] && mushroom_x[u]>=block_x[a]-16) //mushroom hit the left of the block
{
item_direction[1]=2;
}
else if(mushroom_y[u]<block_y[a]+16 && mushroom_y[u]>block_y[a]-16 && mushroom_x[u]>=block_x[a] && mushroom_x[u]<=block_x[a]+16) //mushroom hit the right of the block
{
item_direction[1]=1;
}
else if(mushroom_y[u]<qblock_y[a]+16 && mushroom_y[u]>qblock_y[a]-16 && mushroom_x[u]<=qblock_x[a] && mushroom_x[u]>=qblock_x[a]-16) //mushroom hit the left of the [?] block
{
item_direction[1]=2;
}
else if(mushroom_y<qblock_y[v]+16 && mushroom_y[u]>qblock_y[v]-16 && mushroom_x[u]>=qblock_x[v] && mushroom_x[u]<=qblock_x[v]+16) //mushroom hit the right of the [?] block
{
item_direction[1]=1;
}
else if(v==99)
v=0;
else
v++;
}
u++;
if(u==99)
u=0;
if(mario_y==end_y)
{
ttk_blit_image (win, srf, 0, 0);
game_over();
}
//bookmark (add code for star and crouching, then finish up these 2 funcions and make sure everything else is all good, compile, and test on desktop build :D
static void mario_die();
{
//if(memory<10 && function_finished[mario_die]==0)
// {
// kick_my_ass(); }
}
static void game_over();
{
//DONT FORGET TO FINISH THIS FUNCTION!!!!!
//if you are reading this, apparently I forgot, please notify me immediately.
}
static void mario_events(PzEvent *e)
{
e->wid->dirty = 1;
int ret = TTK_EV_CLICK;
switch(e->type)
{
case PZ_EVENT_BUTTON_DOWN:
switch (e->arg)
{
case PZ_BUTTON_ACTION:
buttondown[0]=1;
mrun=1;
if(mario_state==3 || mario_state==6)
{
if(t!=2)
{
fireball_x[t]=mario_x+16;
fireball_y[t]=mario_y-16;
t++;
}
}
break;
case PZ_BUTTON_MENU:
buttondown[1]=1;
mjump=1;
break;
case PZ_BUTTON_NEXT:
mwalk=1;
mdirection=2;
buttondown[3]=1;
break;
case PZ_BUTTON_PREVIOUS:
mwalk=1;
mdirection=1;
buttondown[2]=1;
break;
case PZ_BUTTON_PLAY:
buttondown[4]=1;
if(onground==1 && (mario_state==2 || mario_state==3))
{
mcrouch=1;
mario_y=mario_y-12;
}
break;
}
break;
case PZ_EVENT_BUTTON_UP:
switch (e->arg)
{
case PZ_BUTTON_ACTION:
buttondown[0]=0;
mrun=0;
break;
case PZ_BUTTON_MENU:
buttondown[1]=0;
mjump=0;
break;
case PZ_BUTTON_NEXT:
mwalk=0;
buttondown[3]=0;
break;
case PZ_BUTTON_PREVIOUS:
mwalk=0;
buttondown[2]=0;
break;
case PZ_BUTTON_PLAY:
buttondown[4]=0;
mcrouch=0;
break;
}
break;
default:
ret = TTK_EV_UNUSED;
break;
}
return ret;
}
static PzWindow *new_mario_window()
{
PzWindow *ret;
ret = pz_new_window(_("Mario"), PZ_WINDOW_NORMAL);
pz_add_widget(ret, draw_mario, mario_events);
return pz_finish_window(ret);
}
static void init_mario()
{
/*Load the images and assign them to a surface. Get their dimensions*/
module = pz_register_module("Mario", NULL);
pz_menu_add_action("/Extras/Games/Mario", new_ibolo_window);
small_mario_left[0] = ttk_load_image (pz_module_get_datapath (module, "smallmarioleft.png"));
ttk_surface_get_dimen (small_mario_left[0], &imgw, &imgh);
small_mario_left[1] = ttk_load_image (pz_module_get_datapath (module, "smallmarioleft2.png"));
ttk_surface_get_dimen (small_mario_left[1], &imgw, &imgh);
small_mario_right[0] = ttk_load_image (pz_module_get_datapath (module, "smallmarioright.png"));
ttk_surface_get_dimen (small_mario_right[0], &imgw, &imgh);
small_mario_right[1] = ttk_load_image (pz_module_get_datapath (module, "smallmarioright2.png"));
ttk_surface_get_dimen (small_mario_right[1], &imgw, &imgh);
mario_left[0] = ttk_load_image (pz_module_get_datapath (module, "marioleft.png"));
ttk_surface_get_dimen (mario_left[0], &imgw, &imgh);
mario_left[1] = ttk_load_image (pz_module_get_datapath (module, "marioleft2.png"));
ttk_surface_get_dimen (mario_left[1], &imgw, &imgh);
mario_left[2] = ttk_load_image (pz_module_get_datapath (module, "marioleft3.png"));
ttk_surface_get_dimen (mario_left[2], &imgw, &imgh);
mario_right[0] = ttk_load_image (pz_module_get_datapath (module, "marioright.png"));
ttk_surface_get_dimen (mario_right[0], &imgw, &imgh);
mario_right[1] = ttk_load_image (pz_module_get_datapath (module, "marioright2.png"));
ttk_surface_get_dimen (mario_right[1], &imgw, &imgh);
mario_right[2] = ttk_load_image (pz_module_get_datapath (module, "marioright3.png"));
ttk_surface_get_dimen (mario_right[2], &imgw, &imgh);
mario_crouch_left = ttk_load_image (pz_module_get_datapath (module, "mariocrouchright.png"));
ttk_surface_get_dimen (mario_crouch_left, &imgw, &imgh);
mario_crouch_right = ttk_load_image (pz_module_get_datapath (module, "mariocrouchleft.png"));
ttk_surface_get_dimen (mario_crouch_right, &imgw, &imgh);
flower_mario_left[0] = ttk_load_image (pz_module_get_datapath (module, "flowermarioleft1.png"));
ttk_surface_get_dimen (flower_mario_left[0], &imgw, &imgh);
flower_mario_left[1] = ttk_load_image (pz_module_get_datapath (module, "flowermarioleft2.png"));
ttk_surface_get_dimen (flower_mario_left[1], &imgw, &imgh);
flower_mario_left[2] = ttk_load_image (pz_module_get_datapath (module, "flowermarioleft3.png"));
ttk_surface_get_dimen (flower_mario_left[2], &imgw, &imgh);
flower_mario_right[0] = ttk_load_image (pz_module_get_datapath (module, "flowermarioright1.png"));
ttk_surface_get_dimen (flower_mario_right[0], &imgw, &imgh);
flower_mario_right[1] = ttk_load_image (pz_module_get_datapath (module, "flowermarioright2.png"));
ttk_surface_get_dimen (flower_mario_right[1], &imgw, &imgh);
flower_mario_right[2] = ttk_load_image (pz_module_get_datapath (module, "flowermarioright3.png"));
ttk_surface_get_dimen (flower_mario_right[2], &imgw, &imgh);
goomba[0] = ttk_load_image (pz_module_get_datapath (module, "goomba1.png"));
ttk_surface_get_dimen (goomba[0], &imgw, &imgh);
goomba[1] = ttk_load_image (pz_module_get_datapath (module, "goomba2.png"));
ttk_surface_get_dimen (goomba[1], &imgw, &imgh);
goomba_squish = ttk_load_image (pz_module_get_datapath (module, "goomba_squished.png"));
ttk_surface_get_dimen (goomba_squish, &imgw, &imgh);
gkoopa_l[0] = ttk_load_image (pz_module_get_datapath (module, "greenkoopaleft.png"));
ttk_surface_get_dimen (gkoopa_l[0], &imgw, &imgh);
gkoopa_l[1] = ttk_load_image (pz_module_get_datapath (module, "greenkoopaleft2.png"));
ttk_surface_get_dimen (gkoopa_r[1], &imgw, &imgh);
gkoopa_r[0] = ttk_load_image (pz_module_get_datapath (module, "greenkooparight.png"));
ttk_surface_get_dimen (gkoopa_r[0], &imgw, &imgh);
gkoopa_r[1] = ttk_load_image (pz_module_get_datapath (module, "greenkooparight2.png"));
ttk_surface_get_dimen (gkoopa_r[1], &imgw, &imgh);
rkoopa_l[0] = ttk_load_image (pz_module_get_datapath (module, "redkoopaleft.png"));
ttk_surface_get_dimen (rkoopa_l[0], &imgw, &imgh);
rkoopa_l[1] = ttk_load_image (pz_module_get_datapath (module, "redkoopaleft2.png"));
ttk_surface_get_dimen (rkoopa_r[1], &imgw, &imgh);
rkoopa_r[0] = ttk_load_image (pz_module_get_datapath (module, "redkooparight.png"));
ttk_surface_get_dimen (rkoopa_r[0], &imgw, &imgh);
rkoopa_r[1] = ttk_load_image (pz_module_get_datapath (module, "redkooparight2.png"));
ttk_surface_get_dimen (rkoopa_r[1], &imgw, &imgh);
greenshell[0] = ttk_load_image (pz_module_get_datapath (module, "greenshell1.png"));
ttk_surface_get_dimen (greenshell[0], &imgw, &imgh);
greenshell[1] = ttk_load_image (pz_module_get_datapath (module, "greenshell2.png"));
ttk_surface_get_dimen (greenshell[1], &imgw, &imgh);
greenshell[2] = ttk_load_image (pz_module_get_datapath (module, "greenshell3.png"));
ttk_surface_get_dimen (greenshell[2], &imgw, &imgh);
greenshell[3] = ttk_load_image (pz_module_get_datapath (module, "greenshell4.png"));
ttk_surface_get_dimen (greenshell[3], &imgw, &imgh);
redshell[0] = ttk_load_image (pz_module_get_datapath (module, "redshell1.png"));
ttk_surface_get_dimen (redshell[0], &imgw, &imgh);
redshell[1] = ttk_load_image (pz_module_get_datapath (module, "redshell2.png"));
ttk_surface_get_dimen (redshell[1], &imgw, &imgh);
redshell[2] = ttk_load_image (pz_module_get_datapath (module, "redshell3.png"));
ttk_surface_get_dimen (redshell[2], &imgw, &imgh);
redshell[3] = ttk_load_image (pz_module_get_datapath (module, "redshell4.png"));
ttk_surface_get_dimen (redshell[3], &imgw, &imgh);
ground = ttk_load_image (pz_module_get_datapath (module, "brick.png"));
ttk_surface_get_dimen (ground, &imgw, &imgh);
block = ttk_load_image (pz_module_get_datapath (module, "block.png"));
ttk_surface_get_dimen (block, &imgw, &imgh);
qblock[0] = ttk_load_image (pz_module_get_datapath (module, "qblock1.png"));
ttk_surface_get_dimen (qblock[0], &imgw, &imgh);
qblock[1] = ttk_load_image (pz_module_get_datapath (module, "qblock2.png"));
ttk_surface_get_dimen (qblock[1], &imgw, &imgh);
qblock[2] = ttk_load_image (pz_module_get_datapath (module, "qblock3.png"));
ttk_surface_get_dimen (qblock[2], &imgw, &imgh);
qblock[3] = ttk_load_image (pz_module_get_datapath (module, "qblock4.png"));
ttk_surface_get_dimen (qblock[3], &imgw, &imgh);
usedblock = ttk_load_image (pz_module_get_datapath (module, "usedblock.png"));
ttk_surface_get_dimen (usedblock, &imgw, &imgh);
coin[0] = ttk_load_image (pz_module_get_datapath (module, "coin.png"));
ttk_surface_get_dimen (coin[0], &imgw, &imgh);
coin[1] = ttk_load_image (pz_module_get_datapath (module, "coin2.png"));
ttk_surface_get_dimen (coin[1], &imgw, &imgh);
coin[2] = ttk_load_image (pz_module_get_datapath (module, "coin3.png"));
ttk_surface_get_dimen (coin[2], &imgw, &imgh);
coin[3] = ttk_load_image (pz_module_get_datapath (module, "coin4.png"));
ttk_surface_get_dimen (coin[3], &imgw, &imgh);
mushroom = ttk_load_image (pz_module_get_datapath (module, "mushroom.png"));
ttk_surface_get_dimen (mushroom, &imgw, &imgh);
1up = ttk_load_image (pz_module_get_datapath (module, "1up.png"));
ttk_surface_get_dimen (1up, &imgw, &imgh);
flower = ttk_load_image (pz_module_get_datapath (module, "flower.png"));
ttk_surface_get_dimen (flower, &imgw, &imgh);
fireball[0] = ttk_load_image (pz_module_get_datapath (module, "fireball1.png"));
ttk_surface_get_dimen (fireball[0], &imgw, &imgh);
fireball[1] = ttk_load_image (pz_module_get_datapath (module, "fireball2.png"));
ttk_surface_get_dimen (fireball[1], &imgw, &imgh);
fireball[2] = ttk_load_image (pz_module_get_datapath (module, "fireball3.png"));
ttk_surface_get_dimen (fireball[2], &imgw, &imgh);
fireball[3] = ttk_load_image (pz_module_get_datapath (module, "fireball4.png"));
ttk_surface_get_dimen (fireball[3], &imgw, &imgh);
star[0] = ttk_load_image (pz_module_get_datapath (module, "star1.png"));
ttk_surface_get_dimen (star[0], &imgw, &imgh);
star[1] = ttk_load_image (pz_module_get_datapath (module, "star2.png"));
ttk_surface_get_dimen (star[1], &imgw, &imgh);
star[2] = ttk_load_image (pz_module_get_datapath (module, "star3.png"));
ttk_surface_get_dimen (star[2], &imgw, &imgh);
star[3] = ttk_load_image (pz_module_get_datapath (module, "star4.png"));
ttk_surface_get_dimen (star[3], &imgw, &imgh);
win = ttk_load_image (pz_module_get_datapath (module, "win1.png"));
ttk_surface_get_dimen (win, &imgw, &imgh);
}
PZ_MOD_INIT(init_mario)