short AddArrayDeref(short array, short index, int offset)
/*
* offset is integer constant. array,index are entries in the ST.
* array[index+offset]
*/
{
int mul=4, flag;
flag = STflag[array-1];
if (IS_DOUBLE(flag)) mul = 8;
else if (IS_CHAR(flag)) mul = 1;
assert(!IS_VEC(flag));
/*
* FIXED: we multiply the offset with mul always... for architectures which
* don't support LoadMul/ConstAndIndex, they will be fixed in FixDeref()
*/
offset *= mul;
return(AddDerefEntry(array, index, mul, offset, array));
}
/***************************************************************************
* draw_background()
* Draws the Alizarin Tetris background. Not yet complete, but it's getting
* better. :-)
*********************************************************************PROTO*/
void
draw_background(SDL_Surface *screen, int blockWidth, Grid g[],
int level[], int my_adj[], int their_adj[], char *name[])
{
char buf[1024];
int i;
#define IS_DOUBLE(x) ((x==NETWORK)||(x==SINGLE_VS_AI)||(x==TWO_PLAYERS)||(x==AI_VS_AI))
if (IS_DOUBLE(gametype)) {
Assert(g[0].w == g[1].w);
Assert(g[0].h == g[1].h);
}
/*
* clear away the old stuff
*/
memset(&layout, 0, sizeof(layout));
if (!adjust_symbol[0]) { /* only load these guys the first time */
load_adjust_symbols();
}
/*
* THE BOARD
*/
if (IS_DOUBLE(gametype)) {
layout.grid[0].x = ((screen->w / 2) - ((g[0].w*blockWidth))) - 5 * blockWidth - 2;
layout.grid[0].y = ((screen->h - (g[0].h*blockWidth)) / 2);
layout.grid[0].w = (g[0].w*blockWidth);
layout.grid[0].h = (g[0].h*blockWidth);
layout.grid[1].y = ((screen->h - (g[0].h*blockWidth)) / 2);
layout.grid[1].w = (g[0].w*blockWidth);
layout.grid[1].h = (g[0].h*blockWidth);
layout.grid[1].x = ((screen->w / 2) - 4) + 5 * blockWidth + 6;
/* Draw the opponent's board */
draw_bordered_rect(&layout.grid[1], &layout.grid_border[1], 2);
g[1].board = layout.grid[1];
} else {
layout.grid[0].x = (screen->w - (g[0].w*blockWidth))/2 ;
layout.grid[0].y = (screen->h - (g[0].h*blockWidth))/2 ;
layout.grid[0].w = (g[0].w*blockWidth) ;
layout.grid[0].h = (g[0].h*blockWidth) ;
/* Don't need a Board[1] */
}
/* draw the leftmost board */
draw_bordered_rect(&layout.grid[0], &layout.grid_border[0], 2);
g[0].board = layout.grid[0];
/*
* SCORING, Names
*/
for (i=0; i< 1+IS_DOUBLE(gametype); i++) {
layout.name[i].x = layout.grid[i].x;
layout.name[i].y = layout.grid[i].y + layout.grid[i].h + 2;
layout.name[i].w = layout.grid[i].w;
layout.name[i].h = screen->h - layout.name[i].y;
if (gametype == DEMO) {
char buf[1024];
SDL_FillRect(widget_layer, &layout.name[i], int_black);
SDL_FillRect(screen, &layout.name[i], int_black);
SPRINTF(buf,"Demo (%s)",name[i]);
draw_string(buf, color_blue, layout.grid_border[i].x +
layout.grid_border[i].w/2, layout.grid_border[i].y +
layout.grid_border[i].h, DRAW_CENTER | DRAW_CLEAR | DRAW_UPDATE);
} else {
draw_string(name[i], color_blue,
layout.grid_border[i].x + layout.grid_border[i].w/2,
layout.grid_border[i].y + layout.grid_border[i].h,
DRAW_CENTER);
}
/* Set up the coordinates for future score writing */
layout.score[i].x = layout.grid_border[i].x;
layout.score[i].w = layout.grid_border[i].w;
layout.score[i].y = 0;
layout.score[i].h = layout.grid_border[i].y;
SDL_FillRect(widget_layer, &layout.score[i], int_black);
SDL_FillRect(screen, &layout.score[i], int_black);
SPRINTF(buf,"Level %d, Score:",level[i]);
draw_string(buf, color_blue, layout.grid_border[i].x,
layout.grid_border[i].y, DRAW_ABOVE | DRAW_CLEAR);
layout.score[i].x = layout.grid_border[i].x + layout.grid_border[i].w;
layout.score[i].y = layout.grid_border[i].y;
}
/*
* TIME LEFT
*/
#define TIME_WIDTH (16*5)
#define TIME_HEIGHT 28
if (gametype == DEMO) {
/* do nothing */
} else if (IS_DOUBLE(gametype)) {
draw_string("Time Left", color_blue,
screen->w/2, layout.score[0].y, DRAW_CENTER | DRAW_ABOVE);
layout.time.x = (screen->w - TIME_WIDTH)/2;
layout.time.y = layout.score[0].y;
layout.time.w = TIME_WIDTH;
layout.time.h = TIME_HEIGHT;
draw_bordered_rect(&layout.time, &layout.time_border, 2);
} else { /* single */
int text_h = draw_string("Time Left", color_blue,
screen->w/10, screen->h/5, 0);
layout.time.x = screen->w / 10;
layout.time.y = screen->h / 5 + text_h;
layout.time.w = TIME_WIDTH;
layout.time.h = TIME_HEIGHT;
draw_bordered_rect(&layout.time, &layout.time_border, 2);
}
/*
* LEVEL ADJUSTMENT
*/
if (gametype == DEMO) {
} else if (gametype == AI_VS_AI) {
for (i=0;i<3;i++) {
char buf[80];
layout.adjust[0].symbol[i].x = (screen->w - adjust_symbol[i]->w)/2;
layout.adjust[0].symbol[i].w = adjust_symbol[i]->w;
layout.adjust[0].symbol[i].h = adjust_symbol[i]->h;
layout.adjust[0].symbol[i].y =
layout.time_border.y+layout.time_border.h + i * adjust_symbol[i]->h;
SDL_BlitSafe(adjust_symbol[i], NULL, widget_layer,
&layout.adjust[0].symbol[i]);
/* draw the textual tallies */
SPRINTF(buf,"%d",my_adj[i]);
draw_string(buf, color_red,
layout.adjust[0].symbol[i].x - 10,
layout.adjust[0].symbol[i].y, DRAW_LEFT | DRAW_CLEAR);
SPRINTF(buf,"%d",their_adj[i]);
draw_string(buf, color_red,
layout.adjust[0].symbol[i].x + layout.adjust[0].symbol[i].w + 10,
layout.adjust[0].symbol[i].y, DRAW_CLEAR);
}
} else if (IS_DOUBLE(gametype)) {
for (i=0;i<3;i++) {
layout.adjust[0].symbol[i].w = adjust_symbol[i]->w;
layout.adjust[0].symbol[i].h = adjust_symbol[i]->h;
layout.adjust[0].symbol[i].x = (screen->w - 3*adjust_symbol[i]->w)/2;
layout.adjust[0].symbol[i].y =
layout.time_border.y+layout.time_border.h + i * adjust_symbol[i]->h;
SDL_FillRect(widget_layer, &layout.adjust[0].symbol[i], int_black);
SDL_FillRect(screen, &layout.adjust[0].symbol[i], int_black);
if (my_adj[i] != -1)
SDL_BlitSafe(adjust_symbol[my_adj[i]], NULL, widget_layer,
&layout.adjust[0].symbol[i]);
layout.adjust[1].symbol[i].w = adjust_symbol[i]->w;
layout.adjust[1].symbol[i].h = adjust_symbol[i]->h;
layout.adjust[1].symbol[i].x = (screen->w)/2 + adjust_symbol[i]->w/2;
layout.adjust[1].symbol[i].y =
layout.time_border.y+layout.time_border.h + i * adjust_symbol[i]->h;
SDL_FillRect(widget_layer, &layout.adjust[1].symbol[i], int_black);
SDL_FillRect(screen, &layout.adjust[1].symbol[i], int_black);
if (their_adj[i] != -1)
SDL_BlitSafe(adjust_symbol[their_adj[i]], NULL, widget_layer,
&layout.adjust[1].symbol[i]);
}
} else { /* single player */
for (i=0;i<3;i++) {
layout.adjust[0].symbol[i].w = adjust_symbol[i]->w;
layout.adjust[0].symbol[i].h = adjust_symbol[i]->h;
layout.adjust[0].symbol[i].x =
layout.grid_border[0].x + layout.grid_border[0].w +
2 * adjust_symbol[i]->w;
layout.adjust[0].symbol[i].y =
layout.time_border.y +layout.time_border.h+ i * adjust_symbol[i]->h;
SDL_FillRect(widget_layer, &layout.adjust[0].symbol[i], int_black);
SDL_FillRect(screen, &layout.adjust[0].symbol[i], int_black);
if (my_adj[i] != -1)
SDL_BlitSafe(adjust_symbol[my_adj[i]], NULL, widget_layer,
&layout.adjust[0].symbol[i]);
}
}
/*
* NEXT PIECE
*/
if (gametype == DEMO) {
/* do nothing */
} else if (IS_DOUBLE(gametype)) {
int text_h = draw_string("Next Piece", color_blue,
screen->w / 2,
layout.adjust[0].symbol[2].y +
layout.adjust[0].symbol[2].h, DRAW_CENTER);
layout.next_piece[0].w = 5 * blockWidth;
layout.next_piece[0].h = 5 * blockWidth;
layout.next_piece[0].x = (screen->w / 2) - (5 * blockWidth);
layout.next_piece[0].y = layout.adjust[0].symbol[2].y +
layout.adjust[0].symbol[2].h + text_h;
draw_bordered_rect(&layout.next_piece[0], &layout.next_piece_border[0], 2);
layout.next_piece[1].w = layout.next_piece[0].w;
layout.next_piece[1].h = layout.next_piece[0].h;
layout.next_piece[1].y = layout.next_piece[0].y;
layout.next_piece[1].x = (screen->w / 2);
draw_bordered_rect(&layout.next_piece[1], &layout.next_piece_border[1], 2);
} else {
int text_h = draw_string("Next Piece", color_blue,
screen->w/10, 2*screen->h/5, 0);
layout.next_piece[0].w = 5 * blockWidth;
layout.next_piece[0].h = 5 * blockWidth;
layout.next_piece[0].x = screen->w/10;
layout.next_piece[0].y = (2*screen->h/5) + text_h;
/* Draw the box for the next piece to fit in */
draw_bordered_rect(&layout.next_piece[0], &layout.next_piece_border[0], 2);
}
/*
* PAUSE BOX
*/
if (gametype == DEMO) {
} else if (IS_DOUBLE(gametype)) {
layout.pause.x = layout.next_piece_border[0].x;
layout.pause.y = layout.next_piece_border[0].h + layout.next_piece_border[0].y + 2 +
layout.next_piece_border[0].h / 3;
layout.pause.w = layout.next_piece_border[0].w + layout.next_piece[1].w;
layout.pause.h = layout.next_piece_border[0].h / 3;
} else {
layout.pause.x = layout.next_piece_border[0].x;
layout.pause.y = layout.next_piece_border[0].h + layout.next_piece_border[0].y + 2 +
layout.next_piece_border[0].h / 3;
layout.pause.w = layout.next_piece_border[0].w;
layout.pause.h = layout.next_piece_border[0].h / 3;
}
/* Blit onto the screen surface */
{
SDL_Rect dest;
dest.x = 0; dest.y = 0; dest.w = screen->w; dest.h = screen->h;
SDL_BlitSafe(flame_layer, NULL, screen, NULL);
SDL_BlitSafe(widget_layer, NULL, screen, NULL);
SDL_UpdateSafe(screen, 1, &dest);
}
return;
}
void DoArrayStore(short ptr, short id)
{
short lreg, k, type;
k = ptr-1;
type = FLAG2TYPE(STflag[id-1]);
#if IFKO_DEBUG_LEVEL > 1
fprintf(stderr, "pnam=%s, pflag=%d, idname='%s', idflag=%d\n",
STname[SToff[k].sa[0]-1], STflag[SToff[k].sa[0]-1],
STname[id-1], STflag[id-1]);
#endif
lreg = LocalLoad(id);
/*
* NOTE: we added vector store where the array type and variable type
* may not exactly match. we may have DOUBLE pointer but the variable is
* T_VDOUBLE.
*/
#if 0
assert(FLAG2TYPE(STflag[SToff[k].sa[0]-1]) == type);
#else
if (IS_VEC(STflag[id-1]))
{
if ( (IS_VDOUBLE(STflag[id-1]) && !IS_DOUBLE(STflag[SToff[ptr-1].sa[0]-1]))
|| (IS_VFLOAT(STflag[id-1]) && !IS_FLOAT(STflag[SToff[ptr-1].sa[0]-1])) )
fko_error(__LINE__, "type mismatch for vector store!");
}
else
{
if (FLAG2TYPE(STflag[SToff[k].sa[0]-1]) != type)
fko_error(__LINE__, "type mismatch for store!");
}
#endif
FixDeref(ptr);
switch(type)
{
case T_INT:
#ifdef X86_64
assert(lreg < 8);
InsNewInst(NULL, NULL, NULL, STS, ptr, -lreg, 0);
#else
InsNewInst(NULL, NULL, NULL, ST, ptr, -lreg, 0);
#endif
break;
case T_FLOAT:
InsNewInst(NULL, NULL, NULL, FST, ptr, -lreg, 0);
break;
case T_DOUBLE:
InsNewInst(NULL, NULL, NULL, FSTD, ptr, -lreg, 0);
break;
#if 1
case T_VFLOAT:
InsNewInst(NULL, NULL, NULL, VFST, ptr, -lreg, 0);
break;
case T_VDOUBLE:
InsNewInst(NULL, NULL, NULL, VDST, ptr, -lreg, 0);
break;
#endif
default:
fko_error(__LINE__, "Unknown type %d\n", type);
}
GetReg(-1);
}
