void clear_screens() {
clear_screen(0);
clear_screen(1);
}
//=================================================
// setting up all the necessary things for the
// start of a new level
//=================================================
void TheMathGame::startLevel(int level){
clear_screen();
currentLevel = level;
clockTicksCurrentLevel = 0;
// setting up player1 for a new level
player1.setLives(3);
player1.setPosition(Point(10, 9));
player1.changeDirection(Direction::RIGHT);
if (currentLevel >= 1 && currentLevel < 20){
player1.resetExercise();
player1.createExercise(currentLevel);
}
else if (currentLevel == 20){
player1.resetExercise();
player1.createAdvExercise(currentLevel);
}
else{
player1.resetAdvExercise();
player1.createAdvExercise(currentLevel);
}
player1.resetPlayerAlive();
player1.resetPlayerDone();
player1.setShotsCounter(5);
// setting up player2 for a new level
player2.setLives(3);
player2.setPosition(Point(70, 9));
player2.changeDirection(Direction::LEFT);
if (currentLevel >= 1 && currentLevel < 20){
player2.resetExercise();
player2.createExercise(currentLevel);
}
else if (currentLevel == 20){
player2.resetExercise();
player2.createAdvExercise(currentLevel);
}
else{
player2.resetAdvExercise();
player2.createAdvExercise(currentLevel);
}
player2.resetPlayerAlive();
player2.resetPlayerDone();
player2.setShotsCounter(5);
//settinp up status bar for a new level
stBar.setTimeLeft(300);
stBar.setCurrentLevel(currentLevel);
stBar.drawStatusBar();
// erasing the screen matrix
myScreen.eraseMatrix();
// erase all bullets from screen and cleans the array
playShooting.initArr();
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// "NEW CODE EX3, author=Dror Moyal, date=2015-06-02, author=Maya Bugana, date=2015-31-05
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//inits all creatures
RowsFlyerR.initObject(Direction::RIGHT, Point(30, 23));
RowsFlyerL.initObject(Direction::LEFT, Point(50, 15));
ColFlyerUP.initObject(Direction::UP, Point(45, 23));
ColFlyerD.initObject(Direction::DOWN, Point(55, 15));
eater1.initObject(Direction::DOWN, Point(10, 19));
eater2.initObject(Direction::UP, Point(70, 19));
//+++++++++++++++++++++
// END of NEW CODE EX3
//+++++++++++++++++++++
}
LRESULT CALLBACK MainDlg(HWND hwnd,UINT message,WPARAM wparam,LPARAM lparam)
{
PAINTSTRUCT ps;
BITMAPINFO bmi;
char str[255];
static int timer=FALSE;
static int xpos=0,ypos=0,LMB=FALSE,dx=0,dy=0;
static HWND hview=0;
static HGLRC hglrc=0;
static HDC hdc=0;
int i;
#ifdef _DEBUG
// if(message!=0x200&&message!=0x84&&message!=0x20&&message!=WM_ENTERIDLE)
// debug_printf("message=%08X wparam=%08X lparam=%08X\n",message,wparam,lparam);
#endif
switch(message)
{
case WM_INITDIALOG:
bufA=malloc(bwidth*bheight*bdepth);
bufB=malloc(bwidth*bheight*bdepth);
if(bufA==0 || bufB==0)
MessageBox(hwnd,"malloc failed","error",MB_OK);
else{
memset(bufB,0,bwidth*bheight*bdepth);
rand_fill(bufA,bwidth,bheight,bdepth);
}
create_grippy(hwnd);
BringWindowToTop(hwnd);
BringWindowToTop(hwnd);
update_title(hwnd);
SendMessage(hwnd,WM_KEYDOWN,VK_TAB,0);
SendMessage(hwnd,WM_LBUTTONDOWN,0,0);
create_view_windows(hwnd,&hview);
init_ogl(hview,&hglrc,&hdc);
resize_view(hwnd,hview);
break;
case WM_SIZE:
{
int w,h;
w=LOWORD(lparam);
h=HIWORD(lparam);
grippy_move(hwnd);
resize_view(hwnd,hview);
reshape(w,h);
}
break;
case WM_TIMER:
if(LMB)
handle_click(xpos,ypos);
display_view1(hview,hglrc);
break;
case WM_COMMAND:
switch(LOWORD(wparam))
{
case IDC_ONTOP:
SetWindowPos(hwnd,IsDlgButtonChecked(hwnd,LOWORD(wparam))? HWND_TOPMOST : HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE );
break;
case WM_DESTROY:
#ifndef _DEBUG
if(MessageBox(hwnd,"Sure you want to quit?","QUIT",MB_OKCANCEL)!=IDOK)
break;
#endif
PostQuitMessage(0);
break;
}
break;
case WM_PAINT:
/*
hdc=BeginPaint(hwnd,&ps);
memset(&bmi,0,sizeof(BITMAPINFO));
bmi.bmiHeader.biBitCount=24;
bmi.bmiHeader.biWidth=BUF_WIDTH;
bmi.bmiHeader.biHeight=BUF_HEIGHT;
bmi.bmiHeader.biPlanes=1;
bmi.bmiHeader.biSize=40;
if(stretch)
StretchDIBits(hdc,0,0,client_rect.right,client_rect.bottom,0,0,BUF_WIDTH,BUF_HEIGHT,buffer,&bmi,DIB_RGB_COLORS,SRCCOPY);
else
SetDIBitsToDevice(hdc,0,0,BUF_WIDTH,BUF_HEIGHT,0,0,0,BUF_WIDTH,buffer,&bmi,DIB_RGB_COLORS);
screen_updated=TRUE;
EndPaint(hwnd,&ps);
*/
break;
case WM_CLOSE:
case WM_QUIT:
PostQuitMessage(0);
break;
case WM_DROPFILES:
break;
case WM_RBUTTONDOWN:
case WM_LBUTTONDOWN:
case WM_MBUTTONDOWN:
xpos=LOWORD(lparam);
ypos=HIWORD(lparam);
break;
case WM_MOUSEMOVE:
{
int x,y;
int key=wparam;
x=LOWORD(lparam);
y=HIWORD(lparam);
if(key&MK_LBUTTON){
x=xpos-x;
ry=x;
y=ypos-y;
rx=y;
printf("rz=%.1f ry=%.1f\n",rx,ry);
}
if(key&MK_RBUTTON){
x=xpos-x;
rz=-x;
printf("z=%.1f\n",rz);
}
update_title(hwnd);
}
break;
case WM_MOUSEWHEEL:
if(wparam&0x80000000)
SendMessage(hwnd,WM_KEYDOWN,VK_NEXT,0);
else
SendMessage(hwnd,WM_KEYDOWN,VK_PRIOR,0);
break;
case WM_KEYUP:
break;
case WM_KEYDOWN:
{
int ctrl=GetKeyState(VK_CONTROL)&0x8000;
int shift=GetKeyState(VK_SHIFT)&0x8000;
#ifdef _DEBUG
// debug_printf("message=%08X wparam=%08X lparam=%08X\n",message,wparam,lparam);
#endif
switch(wparam)
{
case VK_INSERT:
clear_screen();
break;
case 0xBD:
case 0xBB:
break;
case 'Q':
rx=ry=rz=0;
printf("angles reset\n");
break;
case 'W':
break;
case 0xC0:
rand_fill(swap?bufB:bufA,bwidth,bheight,bdepth);
break;
case 'K':
set_offsety(1);
break;
case 'L':
set_offsety(-1);
break;
case 'X':
if(shift)
scale+=10;
else
scale++;
printf("scale=%i\n",scale);
break;
case 'Z':
if(shift)
scale-=10;
else
scale--;
printf("scale=%i\n",scale);
break;
//case 0xC0:
change_direction(0);
rx=ry=rz=0;
break;
case '0':
case '1':
//tube();
frame_step=1;
break;
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
change_direction(wparam-'0');
break;
case VK_SPACE:
break;
case VK_TAB:
if(timer)
KillTimer(hwnd,1);
else
SetTimer(hwnd,1,60,NULL);
timer=!timer;
break;
case VK_F1:
display_help(hwnd);
break;
/* case VK_F2:
i=CreateDialog(ghInstance,MAKEINTRESOURCE(IDD_DIALOG2),hwnd,request_value);
ShowWindow(i,SW_SHOWNORMAL);
debug_printf("return =%i\r\n",i);
break;*/
case VK_F5:
break;
case VK_F9:
stretch=!stretch;
break;
case 0xDEADBEEF:
break;
case VK_DOWN:
if(GetKeyState(VK_CONTROL)&0x8000)
move_center(3);
else if(GetKeyState(VK_SHIFT)&0x8000)
change_direction(12);
else
change_direction(2);
break;
case VK_UP:
if(GetKeyState(VK_CONTROL)&0x8000)
move_center(4);
else if(GetKeyState(VK_SHIFT)&0x8000)
change_direction(11);
else
change_direction(1);
break;
case VK_LEFT:
if(GetKeyState(VK_CONTROL)&0x8000)
move_center(1);
else if(GetKeyState(VK_SHIFT)&0x8000)
change_direction(14);
else
change_direction(4);
break;
case VK_RIGHT:
if(GetKeyState(VK_CONTROL)&0x8000)
move_center(2);
else if(GetKeyState(VK_SHIFT)&0x8000)
change_direction(13);
else
change_direction(3);
break;
case VK_ADD:
break;
case VK_SUBTRACT:
break;
case VK_NEXT: //page key
if(GetKeyState(VK_CONTROL)&0x8000)
;
else if(GetKeyState(VK_SHIFT)&0x8000)
;
change_direction(100);
break;
case VK_PRIOR: //page key
if(GetKeyState(VK_CONTROL)&0x8000)
;
else if(GetKeyState(VK_SHIFT)&0x8000)
;
change_direction(100);
break;
case VK_HOME:
change_direction(5);
break;
case VK_END:
;
break;
case ZOOM_IN_KEY: //[
if(GetKeyState(VK_SHIFT)&0x8000){
if(GetKeyState(VK_CONTROL)&0x8000)
;
else
;
}
else
;
break;
case ZOOM_OUT_KEY: //]
if(GetKeyState(VK_SHIFT)&0x8000){
if(GetKeyState(VK_CONTROL)&0x8000)
;
else
;
}
else
;
break;
case 0xBE: //>
if(GetKeyState(VK_SHIFT)&0x8000){
if(GetKeyState(VK_CONTROL)&0x8000)
;
else
;
}
else
;
break;
case 0xBC: //<
if(GetKeyState(VK_SHIFT)&0x8000){
if(GetKeyState(VK_CONTROL)&0x8000)
;
else
;
}
else
;
break;
case 'V':
if(GetKeyState(VK_CONTROL)&0x8000){
if(OpenClipboard(NULL)){
char *p=GetClipboardData(CF_TEXT);
if(p!=0){
strncpy(str,p,sizeof(str));
SetDlgItemText(hwnd,IDC_EDIT1,str);
}
CloseClipboard();
}
}
break;
case VK_ESCAPE:
if(MessageBox(hwnd,"Sure you want to quit?","QUIT",MB_OKCANCEL)==IDOK)
PostQuitMessage(0);
break;
}
update_title(hwnd);
}
break;
}
return 0;
}
void
initialize(void)
{
register int i;
/* Loop over all threads in the thread table and reset the owner. */
for(i=0; i<MAX_NUMBER_OF_THREADS; i++)
{
thread_table[i].data.owner=-1; /* -1 is an illegal process_table index.
We use that to show that the thread
is dormant. */
}
/* Loop over all processes in the thread table and mark them as not
executing. */
for(i=0; i<MAX_NUMBER_OF_PROCESSES; i++)
{
process_table[i].threads=0; /* No executing process has less than 1
thread. */
}
/* Initialize the ready queue. */
thread_queue_init(&ready_queue);
/* Initialize the list of blocked threads waiting for the keyboard. */
thread_queue_init(&keyboard_blocked_threads);
/* Calculate the number of pages. */
memory_pages = memory_size/(4*1024);
{
/* Calculate the number of frames occupied by the kernel and executable
images. */
const register int k=first_available_memory_byte/(4*1024);
/* Mark the pages that are used by the kernel or executable images as taken
by the kernel (-2 in the owner field). */
for(i=0; i<k; i++)
{
page_frame_table[i].owner=-2;
page_frame_table[i].free_is_allowed=0;
}
/* Loop over all the rest page frames and mark them as free (-1 in owner
field). */
for(i=k; i<memory_pages; i++)
{
page_frame_table[i].owner=-1;
page_frame_table[i].free_is_allowed=1;
}
/* Mark any unusable pages as taken by the kernel. */
for(i=memory_pages; i<MAX_NUMBER_OF_FRAMES; i++)
{
page_frame_table[i].owner=-2;
page_frame_table[i].free_is_allowed=0;
}
}
/* Go through the linked list of executable images and verify that they
are correct. At the same time build the executable_table. */
{
const struct executable_image* image;
for (image=ELF_images_start; 0!=image; image=image->next)
{
unsigned long image_size;
/* First calculate the size of the image. */
if (0 != image->next)
{
image_size = ((char *) (image->next)) - ((char *) image) -1;
}
else
{
image_size = ((char *) ELF_images_end) - ((char *) image) - 1;
}
/* Check that the image is an ELF image and that it is of the
right type. */
if (
/* EI_MAG0 - EI_MAG3 have to be 0x7f 'E' 'L' 'F'. */
(image->elf_image.e_ident[EI_MAG0] != 0x7f) ||
(image->elf_image.e_ident[EI_MAG1] != 'E') ||
(image->elf_image.e_ident[EI_MAG2] != 'L') ||
(image->elf_image.e_ident[EI_MAG3] != 'F') ||
/* Check that the image is a 64-bit image. */
(image->elf_image.e_ident[EI_CLASS] != 2) ||
/* Check that the image is a little endian image. */
(image->elf_image.e_ident[EI_DATA] != 1) ||
/* And that the version of the image format is correct. */
(image->elf_image.e_ident[EI_VERSION] != 1) ||
/* NB: We do not check the ABI or ABI version. We really should
but currently those fields are not set properly by the build
tools. They are both set to zero which means: System V ABI,
third edition. However, the ABI used is clearly not System V :-) */
/* Check that the image is executable. */
(image->elf_image.e_type != 2) ||
/* Check that the image is executable on AMD64. */
(image->elf_image.e_machine != 0x3e) ||
/* Check that the object format is corrent. */
(image->elf_image.e_version != 1) ||
/* Check that the processor dependent flags are all reset. */
(image->elf_image.e_flags != 0) ||
/* Check that the length of t he header is what we expect. */
(image->elf_image.e_ehsize != sizeof(struct Elf64_Ehdr)) ||
/* Check that the size of the program header table entry is what
we expect. */
(image->elf_image.e_phentsize != sizeof(struct Elf64_Phdr)) ||
/* Check that the number of entries is reasonable. */
(image->elf_image.e_phnum < 0) ||
(image->elf_image.e_phnum > 8) ||
/* Check that the entry point is within the image. */
(image->elf_image.e_entry < 0) ||
(image->elf_image.e_entry >= image_size) ||
/* Finally, check that the program header table is within the image. */
(image->elf_image.e_phoff > image_size) ||
((image->elf_image.e_phoff +
image->elf_image.e_phnum * sizeof(struct Elf64_Phdr)) > image_size )
)
{
/* There is something wrong with the image. */
while (1)
{
kprints("Kernel panic! Corrupt executable image.\n");
}
continue;
}
/* Now check the program header table. */
{
int program_header_index;
struct Elf64_Phdr* program_header = ((struct Elf64_Phdr*)
(((char*) &(image->elf_image)) +
image->elf_image.e_phoff));
unsigned long memory_footprint_size = 0;
for (program_header_index = 0;
program_header_index < image->elf_image.e_phnum;
program_header_index++)
{
/* First sanity check the entry. */
if (
/* Check that the segment is a type we can handle. */
(program_header[program_header_index].p_type < 0) ||
(!((program_header[program_header_index].p_type == PT_NULL) ||
(program_header[program_header_index].p_type == PT_LOAD) ||
(program_header[program_header_index].p_type == PT_PHDR))) ||
/* Look more carefully into loadable segments. */
((program_header[program_header_index].p_type == PT_LOAD) &&
/* Check if any flags that we can not handle is set. */
(((program_header[program_header_index].p_flags & ~7) != 0) ||
/* Check if sizes and offsets look sane. */
(program_header[program_header_index].p_offset < 0) ||
(program_header[program_header_index].p_vaddr < 0) ||
(program_header[program_header_index].p_filesz < 0) ||
(program_header[program_header_index].p_memsz < 0) ||
/* Check if the segment has an odd size. We require the
segment size to be an even multiple of 8. */
(0 != (program_header[program_header_index].p_memsz&7)) ||
(0 != (program_header[program_header_index].p_filesz&7)) ||
/* Check if the segment goes beyond the image. */
((program_header[program_header_index].p_offset +
program_header[program_header_index].p_filesz) > image_size)))
)
{
while (1)
{
kprints("Kernel panic! Corrupt segment.\n");
}
}
/* Check that all PT_LOAD segments are contiguous starting from
address 0. Also, calculate the memory footprint of the image. */
if (program_header[program_header_index].p_type == PT_LOAD)
{
if (program_header[program_header_index].p_vaddr !=
memory_footprint_size)
{
while (1)
{
kprints("Kernel panic! Executable image has illegal memory layout.\n");
}
}
memory_footprint_size += program_header[program_header_index].p_memsz;
}
}
executable_table[executable_table_size].memory_footprint_size =
memory_footprint_size;
}
executable_table[executable_table_size].elf_image = &(image->elf_image);
executable_table_size += 1;
kprints("Found an executable image.\n");
if (executable_table_size >= MAX_NUMBER_OF_PROCESSES)
{
while (1)
{
kprints("Kernel panic! Too many executable images found.\n");
}
}
}
}
/* Check that actually some executable files are found. Also check that the
thread structure is of the right size. The assembly code will break if it
is not. Finally, initialize memory protection. You will implement memory
protection in task A4. */
if ((0 >= executable_table_size) ||
(1024 != sizeof(union thread)))
{
while (1)
{
kprints("Kernel panic! Can not boot.\n");
}
}
initialize_memory_protection();
initialize_ports();
initialize_thread_synchronization();
/* All sub-systems are now initialized. Kernel areas can now get the right
memory protection. */
{
/* Use the kernel's ELF header. */
struct Elf32_Phdr* program_header = ((struct Elf32_Phdr*)
(((char*) (0x00100000)) +
((struct Elf32_Ehdr*)0x00100000)->
e_phoff));
/* Traverse the program header. */
short number_of_program_header_entries =
((struct Elf32_Ehdr*)0x00100000)->e_phnum;
int i;
for(i=0; i<number_of_program_header_entries; i++)
{
if (PT_LOAD == program_header[i].p_type)
{
/* Set protection on each segment. */
update_memory_protection(kernel_page_table_root,
program_header[i].p_vaddr,
program_header[i].p_memsz,
(program_header[i].p_flags&7) | PF_KERNEL);
}
}
}
/* Start running the first program in the executable table. */
/* Use the ELF program header table and copy the right portions of the
image to memory. This is done by prepare_process. */
{
struct prepare_process_return_value prepare_process_ret_val =
prepare_process(executable_table[0].elf_image,
0,
executable_table[0].memory_footprint_size);
if (0 == prepare_process_ret_val.first_instruction_address)
{
while (1)
{
kprints("Kernel panic! Can not start process 0!\n");
}
}
/* Start executable program 0 as process 0. At this point, there are no
processes so we can just grab entry 0 and use it. */
process_table[0].parent=-1; /* We put -1 to indicate that there is no
parent process. */
process_table[0].threads=1;
/* all processes should start with an allocated port with id zero */
if (-1 == allocate_port(0,0))
{
while(1)
{
kprints("Kernel panic! Can not initialize the IPC system!\n");
}
}
/* Set the page table address. */
process_table[0].page_table_root =
prepare_process_ret_val.page_table_address;
cpu_private_data.page_table_root =
prepare_process_ret_val.page_table_address;
/* We need a thread. We just take the first one as no threads are running or
have been allocated at this point. */
thread_table[0].data.owner=0; /* 0 is the index of the first process. */
/* We reset all flags and enable interrupts */
thread_table[0].data.registers.integer_registers.rflags=0x200;
/* And set the start address. */
thread_table[0].data.registers.integer_registers.rip =
prepare_process_ret_val.first_instruction_address;
/* Finally we set the current thread. */
cpu_private_data.thread_index = 0;
}
/* Set up the timer hardware to generate interrupts 200 times a second. */
outb(0x43, 0x36);
outb(0x40, 78);
outb(0x40, 23);
/* Set up the keyboard controller. */
/* Empty the keyboard buffer. */
{
register unsigned char status_byte;
do
{
status_byte=inb(0x64);
if ((status_byte&3)==1)
{
inb(0x60);
}
} while((status_byte&0x3)!=0x0);
}
/* Change the command byte to enable interrupts. */
outb(0x64, 0x20);
{
register unsigned char keyboard_controller_command_byte;
{
register unsigned char status_byte;
do
{
status_byte=inb(0x64);
} while((status_byte&3)!=1);
}
keyboard_controller_command_byte=inb(0x60);
/* Enable keyboard interrupts. */
keyboard_controller_command_byte|=1;
kprints("Keyboard controller command byte:");
kprinthex(keyboard_controller_command_byte);
kprints("\n");
outb(0x64, 0x60);
outb(0x60, keyboard_controller_command_byte);
/* Wait until command is done. */
{
register unsigned char status_byte;
do
{
status_byte=inb(0x64);
} while((status_byte&0x2)!=0x0);
}
}
/* Now we set up the interrupt controller to allow timer and keyboard
interrupts. */
outb(0x20, 0x11);
outb(0xA0, 0x11);
outb(0x21, 0x20);
outb(0xA1, 0x28);
outb(0x21, 1<<2);
outb(0xA1, 2);
outb(0x21, 1);
outb(0xA1, 1);
outb(0x21, 0xfc);
outb(0xA1, 0xff);
clear_screen();
kprints("\n\n\nThe kernel has booted!\n\n\n");
/* Now go back to the assembly language code and let the process run. */
}
/*
* Display main menu.
*/
void oedit_disp_menu(struct descriptor_data *d)
{
char tbitbuf[MAX_INPUT_LENGTH], ebitbuf[MAX_INPUT_LENGTH];
struct obj_data *obj;
obj = OLC_OBJ(d);
get_char_colors(d->character);
clear_screen(d);
/*
* Build buffers for first part of menu.
*/
sprinttype(GET_OBJ_TYPE(obj), item_types, tbitbuf, sizeof(tbitbuf));
sprintbitarray(GET_OBJ_EXTRA(obj), extra_bits, EF_ARRAY_MAX, ebitbuf);
/*
* Build first half of menu.
*/
write_to_output(d,
"-- Item number : [%s%d%s]\r\n"
"%s1%s) Namelist : %s%s\r\n"
"%s2%s) S-Desc : %s%s\r\n"
"%s3%s) L-Desc :-\r\n%s%s\r\n"
"%s4%s) A-Desc :-\r\n%s%s"
"%s5%s) Type : %s%s\r\n"
"%s6%s) Extra flags : %s%s\r\n",
cyn, OLC_NUM(d), nrm,
grn, nrm, yel, (obj->name && *obj->name) ? obj->name : "undefined",
grn, nrm, yel, (obj->short_description && *obj->short_description) ? obj->short_description : "undefined",
grn, nrm, yel, (obj->description && *obj->description) ? obj->description : "undefined",
grn, nrm, yel, (obj->action_description && *obj->action_description) ? obj->action_description : "<not set>\r\n",
grn, nrm, cyn, tbitbuf,
grn, nrm, cyn, ebitbuf
);
/*
* Send first half.
*/
/*
* Build second half of menu.
*/
sprintbitarray(GET_OBJ_WEAR(OLC_OBJ(d)), wear_bits, EF_ARRAY_MAX, tbitbuf);
sprintbitarray(GET_OBJ_PERM(OLC_OBJ(d)), affected_bits, EF_ARRAY_MAX, ebitbuf);
write_to_output(d,
"%s7%s) Wear flags : %s%s\r\n"
"%s8%s) Weight : %s%d\r\n"
"%s9%s) Cost : %s%d\r\n"
"%sA%s) Cost/Day : %s%d\r\n"
"%sB%s) Timer : %s%d\r\n"
"%sC%s) Values : %s%d %d %d %d\r\n"
"%sD%s) Applies menu\r\n"
"%sE%s) Extra descriptions menu\r\n"
"%sM%s) Min Level : %s%d\r\n"
"%sP%s) Perm Affects: %s%s\r\n"
"%sS%s) Script : %s%s\r\n"
"%sQ%s) Quit\r\n"
"Enter choice : ",
grn, nrm, cyn, tbitbuf,
grn, nrm, cyn, GET_OBJ_WEIGHT(obj),
grn, nrm, cyn, GET_OBJ_COST(obj),
grn, nrm, cyn, GET_OBJ_RENT(obj),
grn, nrm, cyn, GET_OBJ_TIMER(obj),
grn, nrm, cyn, GET_OBJ_VAL(obj, 0),
GET_OBJ_VAL(obj, 1),
GET_OBJ_VAL(obj, 2),
GET_OBJ_VAL(obj, 3),
grn, nrm, grn, nrm,
grn, nrm, cyn, GET_OBJ_LEVEL(obj),
grn, nrm, cyn, ebitbuf,
grn, nrm, cyn, OLC_SCRIPT(d) ? "Set." : "Not Set.",
grn, nrm
);
OLC_MODE(d) = OEDIT_MAIN_MENU;
}
/*======== void parse_file () ==========
Inputs: char * filename
struct matrix * transform,
struct matrix * pm,
screen s
Returns:
Goes through the file named filename and performs all of the actions listed in that file.
The file follows the following format:
Every command is a single character that takes up a line
Any command that requires arguments must have those arguments in the second line.
The commands are as follows:
l: add a line to the edge matrix -
takes 6 arguemnts (x0, y0, z0, x1, y1, z1)
c: add a circle to the edge matrix -
takes 3 arguments (cx, cy, r)
h: add a hermite curve to the edge matrix -
takes 8 arguments (x0, y0, x1, y1, x2, y2, x3, y3)
b: add a bezier curve to the edge matrix -
takes 8 arguments (x0, y0, x1, y1, x2, y2, x3, y3)
i: set the transform matrix to the identity matrix -
s: create a scale matrix,
then multiply the transform matrix by the scale matrix -
takes 3 arguments (sx, sy, sz)
t: create a translation matrix,
then multiply the transform matrix by the translation matrix -
takes 3 arguments (tx, ty, tz)
x: create an x-axis rotation matrix,
then multiply the transform matrix by the rotation matrix -
takes 1 argument (theta)
y: create an y-axis rotation matrix,
then multiply the transform matrix by the rotation matrix -
takes 1 argument (theta)
z: create an z-axis rotation matrix,
then multiply the transform matrix by the rotation matrix -
takes 1 argument (theta)
a: apply the current transformation matrix to the
edge matrix
v: draw the lines of the edge matrix to the screen
display the screen
g: draw the lines of the edge matrix to the screen
save the screen to a file -
takes 1 argument (file name)
q: end parsing
See the file script for an example of the file format
IMPORTANT MATH NOTE:
the trig functions int math.h use radian mesure, but us normal
humans use degrees, so the file will contain degrees for rotations,
be sure to conver those degrees to radians (M_PI is the constant
for PI)
jdyrlandweaver
====================*/
void parse_file ( char * filename,
struct matrix * transform,
struct matrix * pm,
screen s, color c) {
FILE * fp = fopen(filename, "r");
char * lines = (char *)malloc(1);
float x0, y0, z0, x1, y1, z1, x2, y2, x3, y3;
float step;
float cx, cy, r;
float x, y, z;
float theta;
while(fscanf(fp, "%c", lines)) {
printf("lines gets: %c \n", *lines);
switch (*lines){
case 'c':
{
fscanf(fp, "%f %f %f %f", &cx, &cy, &r, &step);
add_circle(pm, cx, cy, r, step);
break;
}
case 'b':
{
fscanf(fp, "%f %f %f %f %f %f %f %f %f", &x0, &y0, &x1, &y1, &x2, &y2, &x3, &y3, &step);
add_curve(pm, x0, y0, x1, y1, x2, y2, x3, y3, step, 0);
break;
}
case 'h':
{
fscanf(fp, "%f %f %f %f %f %f %f %f %f", &x0, &y0, &x1, &y1, &x2, &y2, &x3, &y3, &step);
add_curve(pm, x0, y0, x1, y1, x2, y2, x3, y3, step, 1);
break;
}
case 'l':
{
fscanf(fp, "%f %f %f %f %f %f", &x0, &y0, &z0, &x1, &y1, &z1);
add_edge(pm, x0, y0, z0, x1, y1, z1);
break;
}
case 'i':
{
ident(transform);
break;
}
case 's':
{
fscanf(fp, "%f %f %f", &x, &y, &z);
struct matrix * scale = make_scale(x, y, z);
matrix_mult(scale, transform);
free(scale);
break;
}
case 't':
{
fscanf(fp, "%f %f %f", &x, &y, &z);
struct matrix * trans = make_translate(x, y, z);
matrix_mult(trans, transform);
free(trans);
break;
}
case 'x':
{
fscanf(fp, "%f", &theta);
struct matrix * transx = make_rotX(theta);
matrix_mult(transx, transform);
free(transx);
break;
}
case 'y':
{
fscanf(fp, "%f", &theta);
struct matrix * transy = make_rotY(theta);
matrix_mult(transy, transform);
free(transy);
break;
}
case 'z':
{
fscanf(fp, "%f", &theta);
struct matrix * transz = make_rotZ(theta);
matrix_mult(transz, transform);
free(transz);
break;
}
case 'a':
{
matrix_mult(transform, pm);
break;
}
case 'v':
{
clear_screen(s);
draw_lines(pm, s, c);
display(s);
break;
}
case 'g':
{
char * file = (char *)malloc(256);
fscanf(fp, "%s", file);
clear_screen(s);
draw_lines(pm, s, c);
save_extension(s, file);
free(file);
break;
}
case 'q':
{
exit(0);
}
default:
{
exit(1);
}
}
fscanf(fp, "%c", lines);
}
fclose(fp);
free(lines);
}
void end_all()//end the program cycle
{
clear_screen();
printf("Thank you for using my database V1.0\r\n");
exit(0);
}
/**
* @brief
* @param None
* @retval None
*/
void clr_scr_rst_cur(void)
{
clear_screen();
reset_cursor();
}
void display_loop(){
// mcuf_serial_mode();
mode = setjmp(newmode_jmpbuf);
#ifdef JOYSTICK_SUPPORT
// in case we get here via mode jump, we (re)enable joystick queries
waitForFire = 1;
#endif
oldOldmode = oldMode;
#ifdef JOYSTICK_SUPPORT
waitForFire = 1;
#endif
for(;;){
#ifndef MENU_SUPPORT
clear_screen(0);
#endif
oldMode = mode;
switch(mode++) {
#ifdef ANIMATION_SCROLLTEXT
case 1:
scrolltext(scrolltext_text);
#ifdef RANDOM_SUPPORT
{
char a[28];
sprintf(a,"</# counter == %lu ",
(unsigned long)percnt_get(&g_reset_counter, &g_reset_counter_idx));
scrolltext(a);
}
#endif
#endif
#ifdef ANIMATION_TIME
#ifndef ANIMATION_SCROLLTEXT
case 1:
#endif
time_anim();
break;
#else
#ifdef ANIMATION_SCROLLTEXT
break;
#endif
#endif
#ifdef ANIMATION_SPIRAL
# ifndef SPIRAL_DELAY
# define SPIRAL_DELAY 5
# endif
case 2:
spiral(SPIRAL_DELAY);
break;
#endif
#ifdef ANIMATION_JOERN1
case 3:
joern1();
break;
#endif
#ifdef ANIMATION_SNAKE
case 4:
snake_animation();
break;
#endif
#ifdef ANIMATION_CHECKERBOARD
case 5:
checkerboard(20);
break;
#endif
#ifdef ANIMATION_FIRE
case 6:
fire();
break;
#endif
#ifdef ANIMATION_TIME
case 7:
time_anim();
break;
#endif
#ifdef ANIMATION_MATRIX
case 8:
matrix();
break;
#endif
#ifdef ANIMATION_RANDOM_BRIGHT
case 9:
random_bright(30);
break;
#endif
#ifdef ANIMATION_STONEFLY
case 10:
stonefly();
break;
#endif
#ifdef ANIMATION_GAMEOFLIFE
case 11:
gameoflife();
break;
#endif
#ifdef ANIMATION_FLYINGDOTS
case 12:
flyingdots();
break;
#endif
#ifdef ANIMATION_BREAKOUT
case 13:
breakout_demo();
break;
#endif
#ifdef ANIMATION_MHERWEG
case 14:
mherweg();
break;
#endif
#ifdef ANIMATION_MOIRE
case 15:
moire();
break;
#endif
#ifdef ANIMATION_TIME
case 16:
time_anim();
break;
#endif
#ifdef ANIMATION_LTN_ANT
case 17:
ltn_ant();
break;
#endif
#ifdef ANIMATION_LABORLOGO
case 18:
laborlogo();
break;
#endif
#ifdef ANIMATION_AMPHIBIAN
case 19:
amphibian();
break;
#endif
#ifdef ANIMATION_LOGO_OOS
case 20:
logo_OutOfSpec();
break;
#endif
#ifdef ANIMATION_FAIRYDUST
case 21:
fairydust();
break;
#endif
#ifdef ANIMATION_PLASMA
case 22:
plasma();
break;
#endif
#ifdef ANIMATION_PSYCHEDELIC
case 23:
psychedelic();
break;
#endif
#ifdef ANIMATION_BLACKHOLE
case 24:
blackhole();
break;
#endif
#ifdef ANIMATION_SQUARES
case 25:
squares();
break;
#endif
#ifdef ANIMATION_DNA
case 26:
dna();
break;
#endif
#ifdef ANIMATION_TESTS
case 31:
test_level(1, false);
break;
case 32:
test_level(2, false);
break;
case 33:
test_level(3, false);
break;
case 35:
test_palette(false);
test_palette2(false);
break;
#endif
#ifdef SMALLANIMATION_ROWWALK
case 36:
rowwalk(SMALLANIMATION_ROWWALK_COUNT,SMALLANIMATION_ROWWALK_SPEED);
break;
#endif
#ifdef SMALLANIMATION_COLWALK
case 37:
colwalk(SMALLANIMATION_COLWALK_COUNT,SMALLANIMATION_COLWALK_SPEED);
break;
#endif
#ifdef SMALLANIMATION_COLBOUNCE
case 38:
colbounce(SMALLANIMATION_COLBOUNCE_COUNT,SMALLANIMATION_COLBOUNCE_SPEED);
break;
#endif
#ifdef SMALLANIMATION_ROWBOUNCE
case 39:
rowbounce(SMALLANIMATION_ROWBOUNCE_COUNT,SMALLANIMATION_ROWBOUNCE_SPEED);
break;
#endif
#ifdef MENU_SUPPORT
case 0xFDu:
mode = 1;
break;
case 0xFEu:
menu();
mode = oldOldmode;
break;
#else
case 0xFDu:
#ifdef JOYSTICK_SUPPORT
if (JOYISFIRE)
mode = 0xFEu;
else
#endif
mode = 1;
break;
case 0xFEu:
#ifdef JOYSTICK_SUPPORT
waitForFire = 0; // avoid circular jumps
while (JOYISFIRE); // wait until user released the fire button
#endif
wait(25); // wait for button to settle
# ifdef GAME_TETRIS
tetris();
# endif
# ifdef GAME_BASTET
tetris_bastet();
# endif
# ifdef GAME_TETRIS_FP
tetris_fp();
# endif
# ifdef GAME_SPACE_INVADERS
borg_invaders();
# endif
# ifdef GAME_SNAKE
snake_game();
# endif
# ifdef GAME_BREAKOUT
borg_breakout(0);
# endif
#ifdef JOYSTICK_SUPPORT
while (JOYISFIRE); // avoid an unwanted restart of the game loop
#endif
wait(25); // wait for button to settle
mode = oldOldmode; // restore old animation mode
#ifdef JOYSTICK_SUPPORT
waitForFire = 1; // reenable joystick query of the wait() function
#endif
break;
#endif
#ifdef ANIMATION_OFF
case 0xFFu:
off();
break;
#endif
default:
if (reverseMode) {
if (reverseMode-- == (mode - 1)) {
mode -= 2;
} else {
reverseMode = 0;
}
}
break;
}
}
}
static void on_clear (GtkMenuItem *menuitem,
gpointer user_data)
{
GromitData *data = (GromitData *) user_data;
clear_screen(data);
}
/*======== void parse_file () ==========
Inputs: char * filename
struct matrix * transform,
struct matrix * pm,
screen s
Returns:
Goes through the file named filename and performs all of the actions listed in that file.
The file follows the following format:
Every command is a single character that takes up a line
Any command that requires arguments must have those arguments in the second line.
The commands are as follows:
l: add a line to the edge matrix -
takes 6 arguemnts (x0, y0, z0, x1, y1, z1)
b: add a hermite cutve to the edge matrix -
takes 8 arguemnts (x0, y0, x1, y1, x2, y2, x3, y3)
h: add a bezier to the edge matrix -
takes 8 arguemnts (x0, y0, x1, y1, x2, y2, x3, y3)
c: add a circle to the edge matrix -
takes 3 arguemnts (cx, cy, r)
m: add a sphere to the edge matrix -
takes 3 arguemnts (cx, cy, r)
d: add a torus to the edge matrix -
takes 4 arguemnts (cx, cy, r1, r2)
p: add a rectangular prism to the edge matrix -
takes 6 arguemnts (x, y, z, width, height, depth)
w: clear the currnt edge matrix -
takes 0 arguments
i: set the transform matrix to the identity matrix -
s: create a scale matrix,
then multiply the transform matrix by the scale matrix -
takes 3 arguments (sx, sy, sz)
t: create a translation matrix,
then multiply the transform matrix by the translation matrix -
takes 3 arguments (tx, ty, tz)
x: create an x-axis rotation matrix,
then multiply the transform matrix by the rotation matrix -
takes 1 argument (theta)
y: create an y-axis rotation matrix,
then multiply the transform matrix by the rotation matrix -
takes 1 argument (theta)
z: create an z-axis rotation matrix,
then multiply the transform matrix by the rotation matrix -
takes 1 argument (theta)
a: apply the current transformation matrix to the
edge matrix
v: draw the lines of the edge matrix to the screen
display the screen
g: draw the lines of the edge matrix to the screen
save the screen to a file -
takes 1 argument (file name)
q: end parsing
See the file script for an example of the file format
IMPORTANT MATH NOTE:
the trig functions int math.h use radian mesure, but us normal
humans use degrees, so the file will contain degrees for rotations,
be sure to conver those degrees to radians (M_PI is the constant
for PI)
03/08/12 16:22:10
jdyrlandweaver
====================*/
void parse_file ( char * filename,
struct matrix * transform,
struct matrix * pm,
screen s) {
FILE *f;
char line[256];
struct matrix * tmp;
double angle;
color g;
g.red = 0;
g.green = 255;
g.blue = 255;
clear_screen(s);
if ( strcmp(filename, "stdin") == 0 )
f = stdin;
else
f = fopen(filename, "r");
while ( fgets(line, 255, f) != NULL ) {
line[strlen(line)-1]='\0';
//printf(":%s:\n",line);
char c;
double x, y, z, x1, y1, z1, x2, y2, x3, y3, x4, y4;
c = line[0];
switch (c) {
case 'l':
// printf("LINE!\n");
fgets(line, 255, f);
// printf("\t%s", line);
//line[strlen(line)-1]='\0';
sscanf(line, "%lf %lf %lf %lf %lf %lf", &x, &y, &z, &x1, &y1, &z1);
add_edge(pm, x, y, z, x1, y1, z1);
// printf( "%lf %lf %lf %lf %lf %lf\n", x, y, z, x1, y1, z1);
break;
case 'p':
fgets(line, 255, f);
sscanf(line, "%lf %lf %lf %lf %lf %lf", &x, &y, &z, &x1, &y1, &z1);
add_box(pm, x, y, z, x1, y1, z1);
// printf( "%lf %lf %lf %lf %lf %lf\n", x, y, z, x1, y1, z1);
break;
case 'm':
fgets(line, 255, f);
sscanf(line, "%lf %lf %lf", &x, &y, &z);
add_sphere(pm, x, y, z, 0.06);
//printf( "%lf %lf %lf\n", x, y, z);
break;
case 'd':
fgets(line, 255, f);
sscanf(line, "%lf %lf %lf %lf", &x, &y, &z, &z1);
add_torus(pm, x, y, z, z1, 0.06);
//printf( "%lf %lf %lf\n", x, y, z);
break;
case 'c':
fgets(line, 255, f);
sscanf(line, "%lf %lf %lf", &x, &y, &z);
add_circle(pm, x, y, z, 0.05);
//printf( "%lf %lf %lf\n", x, y, z);
break;
case 'b':
fgets(line, 255, f);
sscanf(line, "%lf %lf %lf %lf %lf %lf %lf %lf",
&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4);
add_curve(pm, x1, y1, x2, y2, x3, y3, x4, y4, 0.01, BEZIER_MODE );
//printf( "%lf %lf %lf\n", x, y, z);
break;
case 'h':
fgets(line, 255, f);
sscanf(line, "%lf %lf %lf %lf %lf %lf %lf %lf",
&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4);
add_curve(pm, x1, y1, x2, y2, x3, y3, x4, y4, 0.01, HERMITE_MODE );
//printf( "%lf %lf %lf\n", x, y, z);
break;
case 's':
//printf("SCALE\n");
fgets(line, 255, f);
//line[strlen(line)-1]='\0';
sscanf(line, "%lf %lf %lf", &x, &y, &z);
tmp = make_scale(x, y, z);
matrix_mult(tmp, transform);
//print_matrix(transform);
break;
case 't':
//printf("TRANSLATE\n");
fgets(line, 255, f);
// line[strlen(line)-1]='\0';
sscanf(line, "%lf %lf %lf", &x, &y, &z);
tmp = make_translate(x, y, z);
matrix_mult(tmp, transform);
//print_matrix(transform);
break;
case 'x':
//printf("ROTATE!\n");
fgets(line, 255, f);
sscanf(line, "%lf", &angle);
angle = angle * (M_PI / 180);
tmp = make_rotX( angle);
matrix_mult(tmp, transform);
break;
case 'y':
//printf("ROTATE!\n");
fgets(line, 255, f);
sscanf(line, "%lf", &angle);
angle = angle * (M_PI / 180);
tmp = make_rotY( angle);
matrix_mult(tmp, transform);
break;
case 'z':
//printf("ROTATE!\n");
fgets(line, 255, f);
sscanf(line, "%lf", &angle);
angle = angle * (M_PI / 180);
tmp = make_rotZ( angle);
matrix_mult(tmp, transform);
break;
case 'i':
ident(transform);
break;
case 'a':
//printf("APPLY!\n");
//print_matrix( transform );
// print_matrix(pm);
matrix_mult(transform, pm);
break;
case 'v':
clear_screen(s);
draw_polygons(pm, s, g);
display(s);
break;
case 'w':
pm->lastcol = 0;
break;
case 'g':
fgets(line, 255, f);
// line[strlen(line)-1] = '\0';
clear_screen(s);
draw_polygons(pm, s, g);
save_extension(s, line);
break;
case 'q':
return;
case '#':
break;
default:
printf("Invalid command\n");
break;
}
}
free_matrix(tmp);
fclose(f);
//printf("END PARSE\n");
}
/* Efface la fenetre graphique */
void Effacer() {
clear_screen(fenetreCourante);
}
void ConsoleUI::add_scientist()
{
Scientist s = Scientist();
string firstname_, lastname_, gender_, birth_, death_;
clear_screen();
cout << readFileToString("../templates/commands.txt") << endl;
cout << "Name of Scientist: [FirstName LastName]" << endl;
cout << endl << " -> ";
cin >> firstname_ >> lastname_;
clear_screen();
cout << readFileToString("../templates/commands.txt") << endl;
cout << "Gender of scientist: \n(1) male \n(2) female" << endl;
cout << endl << " -> ";
cin >> gender_;
while ((gender_ != "1") && (gender_ != "2"))
{
clear_screen();
cout << readFileToString("../templates/commands.txt") << endl;
cout << "Invalid input! Please try again:" << endl;
cout << "Gender of scientist: \n(1) male \n(2) female" << endl;
cout << endl << " -> ";
cin >> gender_;
}
clear_screen();
cout << readFileToString("../templates/commands.txt") << endl;
cout << "Birth year of scientist:" << endl;
cout << endl << " -> ";
cin >> birth_;
while (!is_digits(birth_))
{
clear_screen();
cout << readFileToString("../templates/commands.txt") << endl;
cout << "Invalid input! Please try again:" << endl;
cout << "Birth year of scientist:" << endl;
cout << endl << " -> ";
cin >> birth_;
}
clear_screen();
cout << readFileToString("../templates/commands.txt") << endl;
cout << "Scientist's Year of death: " << endl;
cout << endl << " -> ";
cin >> death_;
while (!is_digits(death_) || (atoi(death_.c_str()) < atoi(birth_.c_str())))
{
clear_screen();
cout << readFileToString("../templates/commands.txt") << endl;
if (!is_digits(death_))
{
cout << "Invalid input! Please try again:" << endl;
}
else if (atoi(death_.c_str()) < atoi(birth_.c_str()))
{
cout << "Year of death should be AFTER year of birth! Please ry again:" << endl;
}
cout << "Scientist's Year of death:" << endl;
cout << endl << " -> ";
cin >> death_;
}
if (gender_ == "1")
{
s.set_gender("Male");
}
else if (gender_ == "2")
{
s.set_gender("Female");
}
fix_string(firstname_);
fix_string(lastname_);
s.set_firstname(firstname_);
s.set_lastname(lastname_);
s.set_birth(birth_);
s.set_death(death_);
dbService.addS(s);
clear_screen();
cout << readFileToString("../templates/commands.txt") << endl;
cout << "\t\t " << "Scientist has been added to the list!\n\n\n\n\n\n\n" << endl;
}
void cTtyStatus::Recording(const cDevice *Device, const char *Name)
{
const char *FileName = NULL;
bool On = (Name != NULL);
#else
void cTtyStatus::Recording(const cDevice *Device,
const char *Name, const char *FileName, bool On, int ChannelNumber)
{
#endif
const char *startStop = On ? "start" : "stop";
const char *s = Name;
if (!s)
s = FileName;
if (!s)
s = "...";
set_pos(24, 0);
set_color(BLACK_GREEN);
print(" Card %d: %s recording '%s'%-60s",
Device->CardIndex()+1, startStop, s, "");
refresh();
set_pos(2, 0);
}
#if VDRVERSNUM <= 10337
void cTtyStatus::Replaying(const cControl *Control, const char *Name)
{
const char *FileName = NULL;
bool On = (Name != NULL);
#else
void cTtyStatus::Replaying(const cControl *Control,
const char *Name, const char *FileName, bool On)
{
#endif
const char *startStop = On ? "Start" : "Stop";
const char *s = Name;
if (!s)
s = FileName;
if (!s)
s = "...";
set_pos(24, 0);
set_color(BLACK_GREEN);
print(" %s replay '%s'%-70s", startStop, s, "");
refresh();
set_pos(2, 0);
}
void cTtyStatus::SetVolume(int Volume, bool Absolute)
{
static int lastVolume;
// dsyslog("%s: vol %d abs %d", __FUNCTION__, Volume, Absolute);
set_pos(24, 0);
set_color(BLACK_GREEN);
#if APIVERSNUM < 10402
Absolute = true;
#endif
if (Absolute)
lastVolume = Volume;
else
lastVolume += Volume;
print(" Set volume %d %-70s", lastVolume, "");
refresh();
set_pos(2, 0);
}
void cTtyStatus::OsdClear(void)
{
clear_screen();
refresh();
}
void cTtyStatus::OsdTitle(const char *Title)
{
// dsyslog("%s: '%s'", __FUNCTION__, Title);
clear_screen();
set_color(BLACK_CYAN);
set_pos(0, 0);
print(" %-80s", Title);
set_color(WHITE_BLACK);
refresh();
set_pos(2, 0);
}
static int clear ()
{
return clear_screen ();
}
/**
* \brief Example application entry routine
*/
int main(void)
{
/* The sensor_platform_init() function will initialize the system
* clock and sensor bus support in addition to configuring the
* XMEGA-A3BU and Sensor Xplained boards.
*
* Use gfx_mono_init() to initialize the monochrome graphical system
* API then write a splash screen after enabling the LCD display
* backlight and setting the contrast.
*
* The MCU is going to be put in a sleep mode, so initialize the
* sleep manager API with a call to the sleepmgr_init() routine.
*/
sensor_platform_init();
gfx_mono_init();
sleepmgr_init();
gpio_set_pin_high(NHD_C12832A1Z_BACKLIGHT);
st7565r_set_contrast(ST7565R_DISPLAY_CONTRAST_MIN);
/* Attach an accelerometer on a Sensors Xplained board. */
sensor_t accelerometer;
sensor_attach(&accelerometer, SENSOR_TYPE_ACCELEROMETER, 0, 0);
/* Enable the accelerometer low-g (free fall) event. */
sensor_enable_event(&accelerometer, SENSOR_EVENT_LOW_G);
/* Set the free fall threshold (low-g event), bandwidth and range. */
sensor_set_threshold(&accelerometer, SENSOR_THRESHOLD_LOW_G,
LOW_G_THRESHOLD);
sensor_set_bandwidth(&accelerometer, BANDWIDTH);
sensor_set_range(&accelerometer, RANGE);
while (true) {
/* Put the accelerometer into a low-power mode (if available). */
sensor_set_state(&accelerometer, SENSOR_STATE_LOW_POWER);
LED_Off(ACCEL_LED);
clear_screen();
/* Display the "armed" message and put the MCU in sleep mode. */
gfx_mono_draw_string("ATMEL Drop Demo\r\nXMEGA Powered Down\r\n"
"g Sensor Armed", 1, 5, &sysfont);
sleepmgr_lock_mode(SLEEP_MODE);
sleepmgr_enter_sleep();
/* The following runs after the MCU has been woken by an
* external low-g interrupt from the accelerometer.
*
* Turn on the red LED while falling and put the accelerometer
* into a high-power mode (if available) to sample date points.
*/
LED_On(ACCEL_LED);
sensor_set_state(&accelerometer, SENSOR_STATE_HIGHEST_POWER);
static scalar_t acceleration_waveform[DATA_SAMPLE_COUNT];
scalar_t acceleration_max = 0;
for (int data_count = 0; data_count < DATA_SAMPLE_COUNT;
++data_count) {
acceleration_waveform[data_count] = 0;
for (int i = 0; i < SAMPLE_AVG_COUNT; ++i) {
/* Calculate the gravity vector magnitude. */
vector3_t gvec;
sensor_get_vector(&accelerometer, &gvec);
scalar_t const acceleration_magnitude
= vector3_magnitude(&gvec);
/* Store the maximum g magnitude for this
* sub-group. */
if (acceleration_magnitude >
acceleration_waveform[data_count]) {
acceleration_waveform[data_count]
= acceleration_magnitude;
}
/* Store the maximum g magnitude for the whole
* data set. */
if (acceleration_magnitude > acceleration_max) {
acceleration_max = acceleration_magnitude;
}
}
}
clear_screen();
/* Turn the max acceleration into a string and convert to g. */
static char max_g_string[20];
if (acceleration_max > LOW_G_SATURATION) {
sprintf(max_g_string, "g Sensor Saturated");
} else {
sprintf(max_g_string, "Peak = %02.2f g",
acceleration_max / 1000);
}
/* Print the max g on the monochrome display. */
gfx_mono_draw_string("Drop Detected", 1, 5, &sysfont);
gfx_mono_draw_string(max_g_string, 1, 13, &sysfont);
gfx_mono_draw_string("Press SW1 for chart", 1, 21, &sysfont);
do {
LED_Toggle(ACCEL_LED);
delay_ms(100);
} while (!switch_pressed(SW1));
/* Plot the collected data points to create the waveform chart. */
clear_screen();
screen_border();
for (int data_count = 0; data_count < DATA_SAMPLE_COUNT; ++data_count) {
gfx_mono_draw_filled_circle(data_count,
32 -
(acceleration_waveform[data_count] / 500), 1,
GFX_PIXEL_SET, GFX_WHOLE);
}
do {
LED_Toggle(PROMPT_LED);
delay_ms(100);
} while (!switch_pressed(SW1));
LED_Off(PROMPT_LED);
}
}
int main(int argc, char** argv)
{
color_t pikachu[24][28] = {
{BLA, BLA, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, BLA, BLA},
{BLA, BLA, BLA, BLA, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, BLA, BLA, BLA, BLA},
{BLA, BLA, BLA, YEL, BLA, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, BLA, YEL, BLA, BLA, BLA},
{BLA, BLA, BLA, YEL, YEL, BLA, BLA, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, BLA, BLA, YEL, YEL, BLA, BLA, BLA},
{WHI, BLA, BLA, YEL, YEL, YEL, YEL, BLA, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, BLA, YEL, YEL, YEL, YEL, BLA, BLA, WHI},
{WHI, BLA, BLA, YEL, YEL, YEL, YEL, YEL, BLA, BLA, WHI, WHI, BLA, BLA, BLA, BLA, WHI, WHI, BLA, BLA, YEL, YEL, YEL, YEL, YEL, BLA, BLA, WHI},
{WHI, WHI, BLA, YEL, YEL, YEL, YEL, YEL, YEL, YEL, BLA, BLA, YEL, YEL, YEL, YEL, BLA, BLA, YEL, YEL, YEL, YEL, YEL, YEL, YEL, BLA, WHI, WHI},
{WHI, WHI, BLA, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, BLA, WHI, WHI},
{WHI, WHI, WHI, BLA, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, BLA, WHI, WHI, WHI},
{WHI, WHI, WHI, WHI, BLA, YEL, BLA, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, BLA, YEL, BLA, WHI, WHI, WHI, WHI},
{WHI, WHI, WHI, WHI, WHI, BLA, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, BLA, WHI, WHI, WHI, WHI, WHI},
{WHI, WHI, WHI, WHI, WHI, BLA, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, BLA, WHI, WHI, WHI, WHI, WHI},
{WHI, WHI, WHI, WHI, BLA, YEL, YEL, YEL, BLA, BLA, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, BLA, BLA, YEL, YEL, YEL, BLA, WHI, WHI, WHI, WHI},
{WHI, WHI, WHI, WHI, BLA, YEL, YEL, BLA, WHI, BLA, BLA, YEL, YEL, YEL, YEL, YEL, YEL, BLA, BLA, WHI, BLA, YEL, YEL, BLA, WHI, WHI, WHI, WHI},
{WHI, WHI, WHI, WHI, BLA, YEL, YEL, BLA, BLA, BLA, BLA, YEL, YEL, YEL, YEL, YEL, YEL, BLA, BLA, BLA, BLA, YEL, YEL, BLA, WHI, WHI, WHI, WHI},
{WHI, WHI, WHI, WHI, BLA, YEL, YEL, YEL, BLA, BLA, YEL, YEL, YEL, BLA, BLA, YEL, YEL, YEL, BLA, BLA, YEL, YEL, YEL, BLA, WHI, WHI, WHI, WHI},
{WHI, WHI, WHI, BLA, YEL, YEL, RED, RED, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, YEL, RED, RED, YEL, YEL, BLA, WHI, WHI, WHI},
{WHI, WHI, WHI, BLA, YEL, RED, RED, RED, RED, YEL, YEL, BLA, YEL, BLA, BLA, YEL, BLA, YEL, YEL, RED, RED, RED, RED, YEL, BLA, WHI, WHI, WHI},
{WHI, WHI, WHI, BLA, YEL, RED, RED, RED, RED, YEL, YEL, YEL, BLA, BLA, BLA, BLA, YEL, YEL, YEL, RED, RED, RED, RED, YEL, BLA, WHI, WHI, WHI},
{WHI, WHI, WHI, WHI, BLA, YEL, RED, RED, YEL, YEL, YEL, YEL, BLA, RED, RED, BLA, YEL, YEL, YEL, YEL, RED, RED, YEL, BLA, WHI, WHI, WHI, WHI},
{WHI, WHI, WHI, WHI, WHI, BLA, YEL, YEL, YEL, YEL, YEL, YEL, BLA, RED, RED, BLA, YEL, YEL, YEL, YEL, YEL, YEL, BLA, WHI, WHI, WHI, WHI, WHI},
{WHI, WHI, WHI, WHI, WHI, WHI, BLA, BLA, YEL, YEL, YEL, YEL, YEL, BLA, BLA, YEL, YEL, YEL, YEL, YEL, BLA, BLA, WHI, WHI, WHI, WHI, WHI, WHI},
{WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, BLA, BLA, BLA, YEL, YEL, YEL, YEL, YEL, YEL, BLA, BLA, BLA, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI},
{WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, BLA, BLA, BLA, BLA, BLA, BLA, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI, WHI}
};
char key;
char *dance = "Let's dance!!";
char *exit = "n => EXIT";
int swip = 0;
int pika = 0;
init_graphics();
sleep_ms(20);
char* s = "Hello PIKACHU!!!";
draw_text(50, 30, s, YEL);
clear_screen();
int i, j;
/*
for (i = 0; i < 24; i++)
{
for (j = 0; j < 28; j++)
{
draw_rect((50+j*8), (50+i*8), 8, 8, pikachu[i][j]);
fill_circle((350+j*8), (50+i*8), 4, pikachu[i][j]);
}
}
*/
sleep_ms(200000000);
char* start = "Want to see pikachu dance? (y => YES; n => EXIT)";
draw_text(50, 30, s, BLA);
draw_text(50, 30, start, YEL);
for (i = 0; i < 24; i++)
{
for (j = 0; j < 28; j++)
{
draw_rect((50+j*8), (50+i*8), 8, 8, pikachu[i][j]);
fill_circle((350+j*8), (50+i*8), 4, pikachu[i][j]);
}
}
do
{
key = getkey();
if(key == 'y')
pika = 1;
if(key == 'n')
pika = 0;
if (pika == 1)
{
clear_screen();
fill_rect(50, 30, 400, 16, BLA);
fill_rect(40, 30, 600, 400, BLA);
if (swip == 0)
{
for (i = 0; i < 24; i++)
{
for (j = 0; j < 28; j++)
{
fill_circle((350+j*8), (50+i*8), 8, pikachu[i][j]);
}
}
swip = 1;
}
else
{
for (i = 23; i >= 0; i--)
{
for (j = 27; j >= 0; j--)
{
fill_circle((50+j*8), (50+i*8), 8, pikachu[i][j]);
}
}
swip = 0;
}
sleep_ms(900000000000000);
draw_text(50, 350, exit, YEL);
}
} while(key != 'n');
/*
int i, j;
for (i = 0; i < 24; i++)
{
for (j = 0; j < 28; j++)
{
draw_rect((50+j*8), (50+i*8), 8, 8, pikachu[i][j]);
fill_circle((350+j*8), (50+i*8), 4, pikachu[i][j]);
}
}
*/
char *gb = "Goodbye!! PIKAPIKACHU!!";
// draw_text(50, 30, start, BLA);
// draw_text(50, 30, dance, BLA);
draw_text(50, 350, exit, BLA);
// fill_rect(50, 30, 400, 16, BLA);
fill_rect(50, 30, 400, 16, BLA);
fill_rect(30, 20, 600, 400, BLA);
draw_text(50, 30, gb, YEL);
exit_graphics();
return 0;
}
int main (int argc, char *argv[])
{
int ghost[3],pacman[3], red[3], target[2], number_ghost;
char maze[L][C];
char ch;
int i=0,j=0;
FILE *fp;
fp = fopen("maze.txt","r" );
if(fp == NULL)
printf("Erro, nao foi possivel abrir o arquivo\n");
else
while( (ch=fgetc(fp))!= EOF )
{
if (ch != '\n')
{
maze[i][j] = ch;
j++;
}else
{
j = 0;
i++;
}
}
fclose(fp);
clear_screen();
print_maze(maze);
printf ( "\t>>> GHOSTS <<<\n" );
printf ( "1.BLINK 2.PINK 3.INKY 4.CLYDE\n" );
do
{
printf ( "Qual o numero do Ghost? = " );
scanf ("%d", &number_ghost);
}while(number_ghost > 4 || number_ghost < 1 );
//number_ghost = 2;
do
{
print_maze(maze);
printf ( "Qual a posição do GHOST? (x,y)\n" );
printf ( "x: " );
scanf ( "%d", &ghost[1] ); // referente a coluna - ghost
printf ( "y: " );
scanf ( "%d", &ghost[0] ); // referente a linha - ghost
printf ( "Direção do ghost = 1-Down , 2-Right, 3-Up, 4-Left = " );
scanf ("%d", &ghost[2]);
clear_screen();
}while (!validate_position(maze,ghost[0],ghost[1]) || ghost[2] > 4 ||ghost[2] < 1); //mudar os parametros
position (maze,ghost,'3');
do
{
print_maze(maze);
printf ( "Qual a posição do RED? (x,y)\n" );
printf ( "x: " );
scanf ( "%d", &red[1] ); // referente a coluna - ghost
printf ( "y: " );
scanf ( "%d", &red[0] ); // referente a linha - ghost
printf ( "Direção do red = 1-Down , 2-Right, 3-Up, 4-Left = " );
scanf ("%d", &red[2]);
clear_screen();
}while (!validate_position(maze,red[0],red[1]) || red[2] > 4 ||red[2] < 1); //mudar os parametros
position (maze,red,'4');
do
{
clear_screen();
print_maze (maze);
printf ( "Qual a posição do Pacman? (x,y)\n" );
printf ( "x: " );
scanf ( "%d", &pacman[1]); // referente a coluna - ghost
printf ( "y: " );
scanf ( "%d", &pacman[0]); // referente a linha - ghost
}while (!validate_position(maze,pacman[0],pacman[1])); //mudar os parametros
do
{
printf ( "Direção do Pac-mam: 1-Down , 2-Right, 3-Up, 4-Left = " );
scanf ("%d",&pacman[2]);
}while( pacman[2]>4 ||pacman[2]<1);
position (maze,pacman,'5' );//mudar os parametros
dist(pacman);
//marca_target aqui// calcular o target aqui e passa-lo para a walking
//target[0]=(pacman[0]-red[0])+pacman[0];
//target[1]=(pacman[1]-red[1])+pacman[1];
//verifica_target(maze, target);
calcula_target(maze, red, pacman, target);
position(maze, target, '8');
print_maze (maze);
walking(maze,ghost,target);//mudar os parametros
print_maze (maze);
return 0;
}
int main()
{
clear_screen();
options();
return 0;
}
void delay_test(void)
{
unsigned char s1[4];
unsigned char delay,c1,i;
while(1)
{
clear_screen();
printf("Test zur uC-spezifischen Delay-Festlegung\n");
printf("=========================================\n\n");
printf("VOR dem Test den DS18S20 abklemmen !\n\n");
printf("Es gibt nun zwei Moeglichkeiten, die notwendigen Zeitverzoegerungen\n");
printf("zu erzeugen:\n\n");
printf(" 1. Mit einer reinen for-Schleife direkt im Programm-Code.\n");
printf(" 2. Durch Aufruf einer Funktion, die eine for-Schleife enthaelt.\n\n");
printf("Die Methode 1 wird zur Erzeugung sehr kleiner Zeitverzoegerungen (< 20 us),\n");
printf("die Methode 2 fuer groessere Verzoegerungen verwendet.\n\n");
printf("Auswahl, was getestet werden soll (1, 2 oder 'e' (Ende)): ");
c1 = getchar();
if ((c1 != '1') && (c1 != '2')) break; // Rücksprung
if (c1 == '1') // Test für Methode 1
{
while(1)
{
clear_screen();
printf("Test Methode 1: Zeitverzoegerung d. reine for-Schleife direkt im Progamm-Code\n");
printf("=============================================================================\n");
printf("(Ruecksprung durch Reset ... )\n\n");
printf("\n\nTest laeuft ... ");
while(1)
{
DQ = 0;
for(i=0; i<8; i++); // for-Schleife zur Zeitverzögerung:
// Wert muss direkt eingetragen werden,
// keine Variable verwenden: würde dadurch
// langsamer !!!!
DQ = 1;
_wait_ms(10);
}
}
}
else // Test für Methode 2
{
while(1)
{
clear_screen();
printf("Test Methode 2: Zeitverzoegerung durch Funktionsaufruf\n");
printf("======================================================\n");
printf("(Ruecksprung durch Eingabe von 255)\n\n");
printf("Bitte Delay-Wert (Funktions-Uebergabe-Wert) eingeben (0 ... 254): ");
inputse(s1,4);
delay = atoi(s1);
if (delay == 255) break; // Rücksprung
printf("\n\nTest laeuft, weiter mit Taste ... ");
while(1)
{
DQ = 0;
ow_delay(delay);
DQ = 1;
if (seri_zeichen_da()) break;
_wait_ms(10);
}
}
}
}
}
/*======== void parse_file () ==========
Inputs: char * filename
struct matrix * transform,
struct matrix * pm,
screen s
Returns:
Goes through the file named filename and performs all of the actions listed in that file.
The file follows the following format:
Every command is a single character that takes up a line
Any command that requires arguments must have those arguments in the second line.
The commands are as follows:
line: add a line to the edge matrix -
takes 6 arguemnts (x0, y0, z0, x1, y1, z1)
circle: add a circle to the edge matrix -
takes 3 arguments (cx, cy, r)
hermite: add a hermite curve to the edge matrix -
takes 8 arguments (x0, y0, x1, y1, x2, y2, x3, y3)
bezier: add a bezier curve to the edge matrix -
takes 8 arguments (x0, y0, x1, y1, x2, y2, x3, y3)
sphere: add a sphere to the edge matrix -
takes 3 arguemnts (cx, cy, r)
torus: add a torus to the edge matrix -
takes 4 arguemnts (cx, cy, r1, r2)
box: add a rectangular prism to the edge matrix -
takes 6 arguemnts (x, y, z, width, height, depth)
clear: clear the currnt edge matrix -
takes 0 arguments
ident: set the transform matrix to the identity matrix -
scale: create a scale matrix,
then multiply the transform matrix by the scale matrix -
takes 3 arguments (sx, sy, sz)
translate: create a translation matrix,
then multiply the transform matrix by the translation matrix -
takes 3 arguments (tx, ty, tz)
xrotate: create an x-axis rotation matrix,
then multiply the transform matrix by the rotation matrix -
takes 1 argument (theta)
yrotate: create an y-axis rotation matrix,
then multiply the transform matrix by the rotation matrix -
takes 1 argument (theta)
zrotate: create an z-axis rotation matrix,
then multiply the transform matrix by the rotation matrix -
takes 1 argument (theta)
apply: apply the current transformation matrix to the
edge matrix
display: draw the lines of the edge matrix to the screen
display the screen
save: draw the lines of the edge matrix to the screen
save the screen to a file -
takes 1 argument (file name)
quit: end parsing
See the file script for an example of the file format
IMPORTANT MATH NOTE:
the trig functions int math.h use radian mesure, but us normal
humans use degrees, so the file will contain degrees for rotations,
be sure to conver those degrees to radians (M_PI is the constant
for PI)
====================*/
void parse_file ( char * filename,
struct matrix * transform,
struct matrix * pm,
screen s) {
FILE *f;
char line[256];
struct matrix * tmp;
double angle;
color g;
g.red = 0;
g.green = 255;
g.blue = 0;
clear_screen(s);
if ( strcmp(filename, "stdin") == 0 )
f = stdin;
else
f = fopen(filename, "r");
while ( fgets(line, 255, f) != NULL ) {
line[strlen(line)-1]='\0';
//printf(":%s:\n",line);
double x, y, z, x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4;
if ( strncmp(line, "line", strlen(line)) == 0 ) {
// printf("LINE!\n");
fgets(line, 255, f);
// printf("\t%s", line);
//line[strlen(line)-1]='\0';
sscanf(line, "%lf %lf %lf %lf %lf %lf", &x, &y, &z, &x1, &y1, &z1);
add_edge(pm, x, y, z, x1, y1, z1);
// printf( "%lf %lf %lf %lf %lf %lf\n", x, y, z, x1, y1, z1);
}
else if ( strncmp(line, "circle", strlen(line)) == 0 ) {
//printf("CIRCLE\n");
fgets(line, 255, f);
sscanf(line, "%lf %lf %lf", &x, &y, &z);
add_circle(pm, x, y, z, 0.01);
//printf( "%lf %lf %lf\n", x, y, z);
}
else if ( strncmp(line, "bezier", strlen(line)) == 0 ) {
//printf("BEZIER\n");
fgets(line, 255, f);
sscanf(line, "%lf %lf %lf %lf %lf %lf %lf %lf",
&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4);
add_curve(pm, x1, y1, x2, y2, x3, y3, x4, y4, 0.01, BEZIER_MODE );
//printf( "%lf %lf %lf\n", x, y, z);
}
else if ( strncmp(line, "hermite", strlen(line)) == 0 ) {
//printf("HERMITE\n");
fgets(line, 255, f);
sscanf(line, "%lf %lf %lf %lf %lf %lf %lf %lf",
&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4);
add_curve(pm, x1, y1, x2, y2, x3, y3, x4, y4, 0.01, HERMITE_MODE );
//printf( "%lf %lf %lf\n", x, y, z);
}
else if ( strncmp(line, "box", strlen(line)) == 0 ) {
fgets(line, 255, f);
sscanf(line, "%lf %lf %lf %lf %lf %lf", &x, &y, &z, &x1, &y1, &z1);
add_box(pm, x, y, z, x1, y1, z1);
// printf( "%lf %lf %lf %lf %lf %lf\n", x, y, z, x1, y1, z1);
}
else if (strncmp(line, "sphere", strlen(line)) == 0 ) {
fgets(line, 255, f);
sscanf(line, "%lf %lf %lf", &x, &y, &z);
add_sphere(pm, x, y, z, 1);
//printf( "%lf %lf %lf\n", x, y, z);
}
else if (strncmp(line, "torus", strlen(line)) == 0 ) {
fgets(line, 255, f);
sscanf(line, "%lf %lf %lf %lf", &x, &y, &z, &z1);
add_torus(pm, x, y, z, z1, 1);
//printf( "%lf %lf %lf\n", x, y, z);
}
else if ( strncmp(line, "scale", strlen(line)) == 0 ) {
//printf("SCALE\n");
fgets(line, 255, f);
//line[strlen(line)-1]='\0';
sscanf(line, "%lf %lf %lf", &x, &y, &z);
tmp = make_scale(x, y, z);
matrix_mult(tmp, transform);
//print_matrix(transform);
}
else if ( strncmp(line, "translate", strlen(line)) == 0 ) {
//printf("TRANSLATE\n");
fgets(line, 255, f);
// line[strlen(line)-1]='\0';
sscanf(line, "%lf %lf %lf", &x, &y, &z);
tmp = make_translate(x, y, z);
matrix_mult(tmp, transform);
//print_matrix(transform);
}
else if ( strncmp(line, "xrotate", strlen(line)) == 0 ) {
//printf("ROTATE!\n");
fgets(line, 255, f);
sscanf(line, "%lf", &angle);
angle = angle * (M_PI / 180);
tmp = make_rotX( angle);
matrix_mult(tmp, transform);
}
else if ( strncmp(line, "yrotate", strlen(line)) == 0 ) {
//printf("ROTATE!\n");
fgets(line, 255, f);
sscanf(line, "%lf", &angle);
angle = angle * (M_PI / 180);
tmp = make_rotY( angle);
matrix_mult(tmp, transform);
}
else if ( strncmp(line, "zrotate", strlen(line)) == 0 ) {
//printf("ROTATE!\n");
fgets(line, 255, f);
sscanf(line, "%lf", &angle);
angle = angle * (M_PI / 180);
tmp = make_rotZ( angle);
matrix_mult(tmp, transform);
}
else if ( strncmp(line, "ident", strlen(line)) == 0 ) {
ident(transform);
}
else if ( strncmp(line, "apply", strlen(line)) == 0 ) {
//printf("APPLY!\n");
//print_matrix( transform );
// print_matrix(pm);
matrix_mult(transform, pm);
}
else if ( strncmp(line, "display", strlen(line)) == 0 ) {
clear_screen(s);
draw_polygons(pm, s, g);
display(s);
}
else if ( strncmp(line, "save", strlen(line)) == 0 ) {
fgets(line, 255, f);
// line[strlen(line)-1] = '\0';
clear_screen(s);
draw_polygons(pm, s, g);
save_extension(s, line);
}
else if ( strncmp(line, "clear", strlen(line)) == 0 ) {
pm->lastcol = 0;
}
else if ( strncmp(line, "quit", strlen(line)) == 0 ) {
return;
}
else if ( line[0] != '#' ) {
printf("Invalid command\n");
}
}
free_matrix(tmp);
fclose(f);
//printf("END PARSE\n");
}
void bus_demo(void)
{
unsigned char i,merker;
float ftemp;
clear_screen();
printf("1-Wire-Bus-Demo fuer max. 5 DS18S20er-Slaves\n");
printf("============================================\n\n");
printf("Demo laeuft ... (Abbruch durch Tastendruck)\n\n\n");
printf(" Slave-Nr. Temperatur Scratch-Pad (Byte 8 .... Byte 0)");
// Endlosschleife
while(1)
{
merker = 0;
// Slaves abfragen
for (i=0; i<5; i++)
{
// Scratch Pad des DS1820 auslesen
ds1820_rd_temp(i); // i = Stellung des Slaves in Matrix ds1820_mat
// Scratch Pad-Inhalt ausgeben
set_cursor(2*i+8,36);
printf("%02x %02x %02x %02x %02x %02x %02x %02x %02x",ds1820[8],ds1820[7],ds1820[6],ds1820[5],ds1820[4],ds1820[3],ds1820[2],ds1820[1],ds1820[0]);
// Prüfen, ob Stat.-Nr. ok
if (ds1820[3] != i) // Falsche Stat.-Nr. oder Slave def.
{
set_cursor(2*i+8,6); printf("%u Keine kor. Antw.",i);
merker = 2;
}
else merker = 0;
// Ausgabe nur, wenn Slave-Ant. korrekt war
if (merker == 0)
{
// Temperatur berechnen, als float-Wert
if(ds1820[1] == 0) // Positve Temp.-Werte
{
ftemp = ds1820[0];
ftemp = ftemp/2;
}
else // Neg. Temp.-Werte
{
ftemp = (~ds1820[0])+1; // 2er-Komplement
ftemp = (ftemp*(-1))/2;
}
// Ausgabe: Slave-Nr. und Temp.
set_cursor(2*i+8,6); printf("%u %5.1f ",i,ftemp);
}
// Abfrage auf Abbruch
if (seri_zeichen_da())
{
merker = 1;
break;
}
// Warten bis zur nächsten Messung
_wait_ms(50);
}
if (merker == 1) break; // Aussprung
}
}
/*======== void my_main() ==========
Inputs: int polygons
Returns:
This is the main engine of the interpreter, it should
handle most of the commadns in mdl.
If frames is not present in the source (and therefore
num_frames is 1, then process_knobs should be called.
If frames is present, the enitre op array must be
applied frames time. At the end of each frame iteration
save the current screen to a file named the
provided basename plus a numeric string such that the
files will be listed in order, then clear the screen and
reset any other data structures that need it.
Important note: you cannot just name your files in
regular sequence, like pic0, pic1, pic2, pic3... if that
is done, then pic1, pic10, pic11... will come before pic2
and so on. In order to keep things clear, add leading 0s
to the numeric portion of the name. If you use sprintf,
you can use "%0xd" for this purpose. It will add at most
x 0s in <F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3><F3>front of a number, if needed, so if used correctly,
and x = 4, you would get numbers like 0001, 0002, 0011,
0487
05/17/12 09:41:35
jdyrlandweaver
====================*/
void my_main( int polygons ) {
struct vary_node ** knob_vals;
int i, f, j, k;
double step;
double xval, yval, zval, knob_value;
struct matrix *transform;
struct matrix *tmp;
struct stack *s;
screen t;
color g;
char q;
struct vary_node * temp_node;
step = 0.05;
g.red = 0;
g.green = 255;
g.blue = 255;
s = new_stack();
tmp = new_matrix(4, 1000);
clear_screen( t );
first_pass();
if(num_frames == -1)
exit(1);
knob_vals= second_pass();
// print_knobs();
for(k = 0; k < num_frames; k++){
//print_knobs();
//printf("%lu %lu\n", knob_vals, knob_vals[0]);
//printf("first node: %s %f\n", knob_vals[0]->name, knob_vals[1]->value);
for(temp_node = knob_vals[k]; temp_node; temp_node = temp_node->next){
//print_knobs();
set_value(lookup_symbol(temp_node->name), temp_node -> value);
}
for (i=0;i<lastop;i++) {
switch (op[i].opcode) {
case SPHERE:
add_sphere( tmp,op[i].op.sphere.d[0], //cx
op[i].op.sphere.d[1], //cy
op[i].op.sphere.d[2], //cz
op[i].op.sphere.r,
step);
//apply the current top origin
matrix_mult( s->data[ s->top ], tmp );
draw_polygons( tmp, t, g );
tmp->lastcol = 0;
break;
case TORUS:
add_torus( tmp, op[i].op.torus.d[0], //cx
op[i].op.torus.d[1], //cy
op[i].op.torus.d[2], //cz
op[i].op.torus.r0,
op[i].op.torus.r1,
step);
matrix_mult( s->data[ s->top ], tmp );
draw_polygons( tmp, t, g );
tmp->lastcol = 0;
break;
case BOX:
add_box( tmp, op[i].op.box.d0[0],
op[i].op.box.d0[1],
op[i].op.box.d0[2],
op[i].op.box.d1[0],
op[i].op.box.d1[1],
op[i].op.box.d1[2]);
matrix_mult( s->data[ s->top ], tmp );
draw_polygons( tmp, t, g );
tmp->lastcol = 0;
break;
case LINE:
add_edge( tmp, op[i].op.line.p0[0],
op[i].op.line.p0[1],
op[i].op.line.p0[1],
op[i].op.line.p1[0],
op[i].op.line.p1[1],
op[i].op.line.p1[1]);
draw_lines( tmp, t, g );
tmp->lastcol = 0;
break;
case MOVE:
//get the factors
knob_value = 1;
if(op[i].op.move.p)
knob_value = (double)op[i].op.move.p->s.value;
xval = op[i].op.move.d[0] * knob_value;
yval = op[i].op.move.d[1] * knob_value;
zval = op[i].op.move.d[2] * knob_value;
transform = make_translate( xval , yval, zval );
//multiply by the existing origin
matrix_mult( s->data[ s->top ], transform );
//put the new matrix on the top
copy_matrix( transform, s->data[ s->top ] );
free_matrix( transform );
break;
case SCALE:
knob_value = 1;
if(op[i].op.scale.p)
knob_value = op[i].op.scale.p->s.value;
xval = (op[i].op.scale.d[0]) * knob_value;
yval = (op[i].op.scale.d[1]) * knob_value;
zval = (op[i].op.scale.d[2]) * knob_value;
transform = make_scale( xval, yval, zval );
matrix_mult( s->data[ s->top ], transform );
//put the new matrix on the top
copy_matrix( transform, s->data[ s->top ] );
free_matrix( transform );
break;
case ROTATE:
knob_value = 1;
if(op[i].op.rotate.p)
knob_value = op[i].op.rotate.p->s.value;
xval = (op[i].op.rotate.degrees * ( M_PI / 180 )) * knob_value;
//get the axis
if ( op[i].op.rotate.axis == 0 )
transform = make_rotX( xval );
else if ( op[i].op.rotate.axis == 1 )
transform = make_rotY( xval );
else if ( op[i].op.rotate.axis == 2 )
transform = make_rotZ( xval );
matrix_mult( s->data[ s->top ], transform );
//put the new matrix on the top
copy_matrix( transform, s->data[ s->top ] );
free_matrix( transform );
break;
case PUSH:
push( s );
break;
case POP:
pop( s );
break;
case SAVE:
save_extension( t, op[i].op.save.p->name );
break;
case DISPLAY:
display( t );
break;
}
}
//strcpy(name, op[].op.basename.p->name);
char value[256];
char adder[256];
// strcpy(value, "pic");
// strcat(value, name);
strcpy(value, name);
sprintf(adder, "%04d", k);
//k++;
strcat(value, adder);
strcat(value, ".png");
save_extension(t, value);
//}
clear_screen(t);
s = new_stack();
}
free_stack( s );
free_matrix( tmp );
//free_matrix( transform );
}
void w_env_select::select_item(dialog *parent)
{
// Find available files
vector<FileSpecifier> files;
if (type == _typecode_theme) {
// Theme, find by theme script
FindThemes finder(files);
vector<DirectorySpecifier>::const_iterator i = data_search_path.begin(),
end = data_search_path.end();
while (i != end) {
FileSpecifier dir = *i + "Themes";
finder.Find(dir, WILDCARD_TYPE);
i++;
}
}
else {
// Map/phyics/shapes/sounds, find by type
FindAllFiles finder(files);
vector<DirectorySpecifier>::const_iterator i = data_search_path.begin(),
end = data_search_path.end();
while (i != end) {
FileSpecifier dir = *i;
finder.Find(dir, type);
i++;
}
}
// Create structured list of files
vector<env_item> items;
vector<FileSpecifier>::const_iterator i = files.begin(), end = files.end();
string last_base;
int indent_level = 0;
for (i = files.begin(); i != end; i++) {
string base, part;
i->SplitPath(base, part);
if (base != last_base) {
// New directory
FileSpecifier base_spec = base;
#ifdef __MACOS__
char name[256];
base_spec.GetName(name);
if (name[0] != '\0') {
#endif
// Subdirectory, insert name as unselectable item, put items on indentation level 1
items.push_back(env_item(base_spec, 0, false));
indent_level = 1;
#ifdef __MACOS__
}
else {
// Top-level directory, put items on indentation level 0
indent_level = 0;
}
#endif
last_base = base;
}
items.push_back(env_item(*i, indent_level, true));
}
// Create dialog
dialog d;
vertical_placer *placer = new vertical_placer;
placer->dual_add(new w_title(menu_title), d);
placer->add(new w_spacer(), true);
w_env_list *list_w = new w_env_list(items, item.GetPath(), &d);
placer->dual_add(list_w, d);
placer->add(new w_spacer(), true);
placer->dual_add(new w_button("CANCEL", dialog_cancel, &d), d);
d.activate_widget(list_w);
d.set_widget_placer(placer);
// Clear screen
clear_screen();
// Run dialog
if (d.run() == 0) { // Accepted
if (items.size()) {
set_path(items[list_w->get_selection()].spec.GetPath());
}
if(mCallback) {
mCallback(this);
}
}
}
/*======== void parse_file () ==========
Inputs: char * filename
struct matrix * transform,
struct matrix * pm,
screen s
Returns:
Goes through the file named filename and performs all of the actions listed in that file.
The file follows the following format:
Every command is a single character that takes up a line
Any command that requires arguments must have those arguments in the second line.
The commands are as follows:
line: add a line to the edge matrix -
takes 6 arguemnts (x0, y0, z0, x1, y1, z1)
circle: add a circle to the edge matrix -
takes 3 arguments (cx, cy, r)
hermite: add a hermite curve to the edge matrix -
takes 8 arguments (x0, y0, x1, y1, x2, y2, x3, y3)
bezier: add a bezier curve to the edge matrix -
takes 8 arguments (x0, y0, x1, y1, x2, y2, x3, y3)
ident: set the transform matrix to the identity matrix -
scale: create a scale matrix,
then multiply the transform matrix by the scale matrix -
takes 3 arguments (sx, sy, sz)
translate: create a translation matrix,
then multiply the transform matrix by the translation matrix -
takes 3 arguments (tx, ty, tz)
xrotate: create an x-axis rotation matrix,
then multiply the transform matrix by the rotation matrix -
takes 1 argument (theta)
yrotate: create an y-axis rotation matrix,
then multiply the transform matrix by the rotation matrix -
takes 1 argument (theta)
zrotate: create an z-axis rotation matrix,
then multiply the transform matrix by the rotation matrix -
takes 1 argument (theta)
apply: apply the current transformation matrix to the
edge matrix
display: draw the lines of the edge matrix to the screen
display the screen
save: draw the lines of the edge matrix to the screen
save the screen to a file -
takes 1 argument (file name)
quit: end parsing
See the file script for an example of the file format
IMPORTANT MATH NOTE:
the trig functions int math.h use radian mesure, but us normal
humans use degrees, so the file will contain degrees for rotations,
be sure to conver those degrees to radians (M_PI is the constant
for PI)
====================*/
void parse_file ( char * filename,
struct matrix * transform,
struct matrix * pm,
screen s) {
FILE *f;
char line[256];
char next[256];
char *next_arg;
color c;
c.red=255;c.blue=255;c.green=25;
double args[52];
double DEFAULT_STEP=0.01;
clear_screen(s);
if ( strcmp(filename, "stdin") == 0 )
f = stdin;
else
f = fopen(filename, "r");
while ( fgets(line, 255, f) != NULL ) {
line[strlen(line)-1]='\0';
if (strcmp(line,"apply")==0){
matrix_mult(transform,pm);
}
else if (strcmp(line,"display")==0){
draw_lines(pm,s,c);
display(s);
}
else if (strcmp(line,"quit")==0){
exit(0);
}
else if (strcmp(line,"ident")==0){
ident(transform);
}
else{
fgets(next,255,f);
next[strlen(next)-1]='\0';
next_arg=next;
int i = 0;
while (next_arg != 0){
args[i]=strtod(strsep(&next_arg," "),NULL);
i++;
}
if (strcmp(line,"save")==0){
fgets(next,255,f);
save_extension(s,next);
}
}
if (strcmp(line,"line")==0){
add_edge(pm,args[0],args[1],args[2],args[3],args[4],args[5]);
}
if (strcmp(line,"circle")==0){
add_circle(pm,args[0],args[1],args[2],DEFAULT_STEP);
}
if (strcmp(line,"hermite")==0){
add_curve(pm,args[0],args[1],args[4],args[5],args[2]-args[0],args[3]-args[1],args[6]-args[4],args[7]-args[5],DEFAULT_STEP,HERMITE_MODE);
}
if (strcmp(line,"bezier")==0){
add_curve(pm,args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],DEFAULT_STEP,BEZIER_MODE);
}
if (strcmp(line,"scale")==0){
matrix_mult(make_scale(args[0],args[1],args[2]),transform);
}
if (strcmp(line,"translate")==0){
matrix_mult(make_translate(args[0],args[1],args[2]),transform);
}
if (strcmp(line,"xrotate")==0){
matrix_mult(make_rotX(M_PI*args[0]/180.0),transform);
}
if (strcmp(line,"yrotate")==0){
matrix_mult(make_rotY(M_PI*args[0]/180.0),transform);
}
if (strcmp(line,"zrotate")==0){
matrix_mult(make_rotZ(M_PI*args[0]/180.0),transform);
}
printf(":%s:\n",line);
}
}
void demo_pong() {
printf("Demo pong\n");
int term_setting;
int size = 20;
int x=0, y=0;
int dx=3, dy=1;
int pady = 30;
int padx = 100;
int paddy = 30;
int paddx = 10;
int maxd = 4;
char c;
int active = 1;
int alive = 1;
term_setting = fcntl(0, F_GETFL, 0);
fcntl (0, F_SETFL, (term_setting | O_NDELAY));
clear_screen();
lcd_set_rect(padx, pady, padx+paddx, pady+paddy, FILL, YELLOW, display);
while (active) {
/* Clear previous */
lcd_set_rect(x, y, x+size, y+size, FILL, BLACK, display);
if (x+size >= padx) {
if ((y+size < pady) || (y > pady+paddy)) {
//die
alive = 0;
active = 0;
}
else {
if (dy <= 0) {
dy = -(rand() % 5);
}
else {
dy = rand() % 5;
}
dx = -dx;
x = padx - size - 1;
lcd_set_rect(padx, pady, padx+paddx, pady+paddy, FILL, YELLOW, display);
}
}
if (y+size >= 129) {
dy = -dy;
y = 129 - size;
}
if (x <= 0) {
dx = -dx;
x = 0;
}
if (y <= 0) {
dy = -dy;
y = 0;
}
x+=dx;
y+=dy;
/* Draw new */
lcd_set_rect(x, y, x+size, y+size, FILL, GREEN, display);
c = get_key();
switch (c) {
case LEFT:
lcd_set_rect(padx, pady, padx+paddx, pady+paddy, FILL, BLACK, display);
pady -= 10;
lcd_set_rect(padx, pady, padx+paddx, pady+paddy, FILL, YELLOW, display);
break;
case RIGHT:
lcd_set_rect(padx, pady, padx+paddx, pady+paddy, FILL, BLACK, display);
pady += 10;
lcd_set_rect(padx, pady, padx+paddx, pady+paddy, FILL, YELLOW, display);
break;
case QUIT:
case ENTER:
active = 0;
break;
}
}
fcntl(0, F_SETFL, term_setting);
/* Player pressed quit */
if (alive) {
return;
}
lcd_put_str("YOU LOST", 10, 10, LARGE, YELLOW, display);
active = 1;
while (active) {
/* Clear previous */
lcd_set_rect(x, y, x+size, y+size, FILL, BLACK, display);
if (x+size >= 129+size) {
active = 0;
}
x+=dx;
y+=dy;
/* Draw new */
lcd_set_rect(x, y, x+size, y+size, FILL, RED, display);
}
get_key();
}
int more(void)
{
long present_time;
static char more_buf[] = "-- more --";
char c;
if(!more_val.on
|| !more_val.delay
|| more_val.non_stop
|| kill_client_output
|| kill_socket_output
|| (client_stats < L_BOOTED)) {
return 0;
}
/* If we are doing a forward then skip if need be */
if(more_val.forward) {
if(more_val.forward < (more_val.num_rows - 1)) {
++more_val.forward;
return 1;
}
else {
move_val.forward = FALSE;
more_val.num_lines_scrolled = 0;
}
}
/* Too many lines in specified time? If not continue */
preset_time = time(0);
if(present_time > (more_val.last_line_time + more_val.delay)) {
more_val.num_lines_scrolled = 1;
move_val.last_line_time = present_time;
return 0;
}
/* Not too many lines yet...so print out the line */
++more_val.num_lines_scrolled;
if(more_val.num_lines_scrolled < more_val.num_rows) {
return 0;
}
/* Oops..too many lines...prompt the more */
paused = TRUE;
promptfor(more_buf, &c, PROMPT_CHAR);
pasued = FALSE;
if(c == more_val.k_quit) {
/* Prevent problems if prompt triggers */
++kill_client_output;
++kill_socket_output;
return 1;
}
else if(c == more_val.k_clear) {
clear_screen();
more_val.num_lines_scrolled = 0;
}
else if(c == more_val.k_cancel) {
move_val.on = FALSE;
}
else if(c == more_val.k_nonstop) {
more_val.non_stop = TRUE;
}
else if(c == more_val.k_forward) {
more_val.forward = TRUE;
return 1;
}
else if(c == more_val.k_oneline) {
--more_val.num_lines_scrolled;
}
else {
more_val.num_lines_scrolled = 0;
}
refresh_input();
more_val.last_line_time = time(0);
return 0;
}
int main (int argc, char** argv)
{
printf("\nPress \"1\" to draw a non-filled rectangle.\n");
printf("Press \"2\" to draw a filled circle.\n");
printf("Press \"3\" to display a string.\n");
printf("**Select shape. Use the \"WASD\" keys to move the shape around.\n");
printf("**Press the \"q\" at any point to termiante the program.\n");
char key;
int x = (640-20)/2;
int y = (480-20)/2;
int choice;
scanf("%d", &choice);
/**
* Draw a non-filled rectangle.
* Move around with 'WASD' keys.
* Terminate with 'q' key.
*/
{
if(choice == 1)
init_graphics();
clear_screen();
draw_rect(x, y, 200, 100, 20);
do
{
key = getkey();
if(key == 'w') y-=10;
else if(key == 's') y+=10;
else if(key == 'a') x-=10;
else if(key == 'd') x+=10;
clear_screen();
draw_rect(x, y, 200, 100, 20);
sleep_ms(20);
} while(key != 'q');
clear_screen();
exit_graphics();
}
/**
* Draw a filled circle with the midpoint circle algorithm.
* Move around with 'WASD' keys.
* Terminate with 'q' key.
*/
if(choice == 2)
{
init_graphics();
clear_screen();
fill_circle(x, y, 75, 20);
do
{
key = getkey();
if(key == 'w') y-=10;
else if(key == 's') y+=10;
else if(key == 'a') x-=10;
else if(key == 'd') x+=10;
clear_screen();
fill_circle(x, y, 75, 20);
sleep_ms(20);
} while(key != 'q');
clear_screen();
exit_graphics();
}
/**
* Write a string usign the iso_font.h header file.
* Move around with 'WASD' keys.
* Terminate with 'q' key.
*/
if(choice == 3)
{
const char *text_input = "Hello World!";
init_graphics();
clear_screen();
draw_text(x, y, text_input, 20);
do
{
key = getkey();
if(key == 'w') x-=10;
else if(key == 's') x+=10;
else if(key == 'a') y-=10;
else if(key == 'd') y+=10;
clear_screen();
draw_text(x, y, text_input, 20);
sleep_ms(20);
} while(key != 'q');
clear_screen();
exit_graphics();
}
return 0;
}
/*======== void my_main() ==========
Inputs: int polygons
Returns:
This is the main engine of the interpreter, it should
handle most of the commands in mdl.
If frames is not present in the source (and therefore
num_frames is 1) then process_knobs should be called.
If frames is present, the entire op array must be
applied frames time. At the end of each frame iteration
save the current screen to a file named the
provided basename plus a numeric string such that the
files will be listed in order, then clear the screen and
reset any other data structures that need it.
Important note: you cannot just name your files in
regular sequence, like pic0, pic1, pic2, pic3... if that
is done, then pic1, pic10, pic11... will come before pic2
and so on. In order to keep things clear, add leading 0s
to the numeric portion of the name. If you use sprintf,
you can use "%0xd" for this purpose. It will add at most
x 0s in front of a number, if needed, so if used correctly,
and x = 4, you would get numbers like 0001, 0002, 0011,
0487
05/17/12 09:41:35
jdyrlandweaver
====================*/
void my_main( int polygons ) {
int i, f, j;
double step;
double xval, yval, zval, knob_value;
struct matrix *transform;
struct matrix *tmp;
struct stack *s;
screen t;
color g;
char *q;
int k;
char *p;
p = name;
int m;
struct vary_node* caller;
knob_value = 1;
double carry;
num_frames = 1;
step = 0.05;
g.red = 0;
g.green = 255;
g.blue = 255;
s = new_stack();
tmp = new_matrix(4, 1000);
clear_screen( t );
first_pass();
if(num_frames < 0){
printf("AH...NO, NOT WITHOUT FRAMES CAN YOU VARY.\n");
}
struct vary_node ** kn = second_pass();
for(k = 0; k < num_frames; k++){
for(i = 0; i < XRES; i++){
for(j = 0; j < YRES; j++){
zBuffer[i][j] = -2147483647;
}
}
for ( i=0; i < lastsym; i++ ) {
if ( symtab[i].type == SYM_VALUE ) {
caller = kn[k];
while((caller) && (strcmp(caller->name,symtab[i].name) != 0)){
caller = caller->next;
}
if(caller){
(&symtab[i])->s.value = caller->value;
}
}
}
for (i=0;i<lastop;i++) {
switch (op[i].opcode) {
case SETKNOBS:
//carry = op[i].op.setknobs.value;
for( i = 0; i < lastsym; i++){
if(symtab[i].type == SYM_VALUE){
set_value(&(symtab[i]), op[i].op.setknobs.value);
}
}
break;
case SET:
//carry = op[i].op.set.p->s.value;
set_value(lookup_symbol(op[i].op.set.p->name), op[i].op.set.p->s.value);
break;
case SPHERE:
add_sphere( tmp,op[i].op.sphere.d[0], //cx
op[i].op.sphere.d[1], //cy
op[i].op.sphere.d[2], //cz
op[i].op.sphere.r,
step);
//apply the current top origin
//pointInfo(op[i].op.sphere.constants->name);
matrix_mult( s->data[ s->top ], tmp );
pointInfo(op[i].op.sphere.constants->name);
ambi.red = ambiRed;
ambi.green = ambiGreen;
ambi.blue = ambiBlue;
draw_polygons( tmp, t, g );
//printf("%f %f %f\n", ambiRed, ambiGreen, ambiBlue);
tmp->lastcol = 0;
break;
case TORUS:
add_torus( tmp, op[i].op.torus.d[0], //cx
op[i].op.torus.d[1], //cy
op[i].op.torus.d[2], //cz
op[i].op.torus.r0,
op[i].op.torus.r1,
step);
pointInfo(op[i].op.torus.constants->name);
matrix_mult( s->data[ s->top ], tmp );
draw_polygons( tmp, t, g );
tmp->lastcol = 0;
break;
case BOX:
add_box( tmp, op[i].op.box.d0[0],
op[i].op.box.d0[1],
op[i].op.box.d0[2],
op[i].op.box.d1[0],
op[i].op.box.d1[1],
op[i].op.box.d1[2]);
pointInfo(op[i].op.box.constants->name);
matrix_mult( s->data[ s->top ], tmp );
draw_polygons( tmp, t, g );
tmp->lastcol = 0;
break;
case LINE:
add_edge( tmp, op[i].op.line.p0[0],
op[i].op.line.p0[1],
op[i].op.line.p0[1],
op[i].op.line.p1[0],
op[i].op.line.p1[1],
op[i].op.line.p1[1]);
draw_lines( tmp, t, g );
tmp->lastcol = 0;
break;
case MOVE:
if(op[i].op.move.p != NULL){
caller = kn[k];
while((caller) && (strcmp(caller->name, op[i].op.move.p->name) != 0)){
caller = caller->next;
}
if(caller){
knob_value = caller->value;
}
}
//get the factors
xval = op[i].op.move.d[0] * knob_value;
yval = op[i].op.move.d[1] * knob_value;
zval = op[i].op.move.d[2] * knob_value;
transform = make_translate( xval, yval, zval );
//multiply by the existing origin
matrix_mult( s->data[ s->top ], transform );
//put the new matrix on the top
copy_matrix( transform, s->data[ s->top ] );
free_matrix( transform );
break;
case SCALE:
if(op[i].op.scale.p != NULL){
caller = kn[k];
while((caller) && (strcmp(caller->name, op[i].op.scale.p->name) != 0)){
caller = caller->next;
}
if(caller){
knob_value = caller->value;
}
}
xval = op[i].op.scale.d[0] * knob_value;
yval = op[i].op.scale.d[1] * knob_value;
zval = op[i].op.scale.d[2] * knob_value;
transform = make_scale( xval, yval, zval );
matrix_mult( s->data[ s->top ], transform );
//put the new matrix on the top
copy_matrix( transform, s->data[ s->top ] );
free_matrix( transform );
break;
case ROTATE:
if(op[i].op.rotate.p != NULL){
caller = kn[k];
while((caller) && (strcmp(caller->name, op[i].op.rotate.p->name) != 0)){
caller = caller->next;
}
if(caller){
knob_value = caller->value;
}
}
xval = op[i].op.rotate.degrees * ( M_PI / 180 ) * knob_value;
//get the axis
if ( op[i].op.rotate.axis == 0 )
transform = make_rotX( xval );
else if ( op[i].op.rotate.axis == 1 )
transform = make_rotY( xval );
else if ( op[i].op.rotate.axis == 2 )
transform = make_rotZ( xval );
matrix_mult( s->data[ s->top ], transform );
//put the new matrix on the top
copy_matrix( transform, s->data[ s->top ] );
free_matrix( transform );
break;
case PUSH:
push( s );
break;
case POP:
pop( s );
break;
case SAVE:
save_extension( t, op[i].op.save.p->name );
break;
case DISPLAY:
display( t );
break;
}
}
strcpy(name, op[refer].op.basename.p->name);
char value[256];
char adder[256];
strcpy(value, "hermano/");
strcat(value, name);
sprintf(adder, "%04d", k);
strcat(value, adder);
strcat(value, ".png");
save_extension(t, value);
clear_screen(t);
s = new_stack();
tmp = new_matrix(4,1000);
}
free_stack( s );
free_matrix( tmp );
//free_matrix( transform );
}
/*
* Check for escape code sequence.
* Rreturn true if escape
*
* <Support list>
* ESC[#;#H or : moves cursor to line #, column #
* ESC[#;#f
* ESC[#A : moves cursor up # lines
* ESC[#B : moves cursor down # lines
* ESC[#C : moves cursor right # spaces
* ESC[#D : moves cursor left # spaces
* ESC[#;#R : reports current cursor line & column
* ESC[s : save cursor position for recall later
* ESC[u : return to saved cursor position
* ESC[2J : clear screen and home cursor
* ESC[K : clear to end of line
* ESC[#m : attribute (0=attribure off, 4=underline, 5=blink)
*/
static int
check_escape(char c)
{
int move = 0;
int val;
u_short color;
if (c == 033) {
esc_index = 1;
esc_argc = 0;
return 1;
}
if (esc_index == 0)
return 0;
if (c >= '0' && c <= '9') {
val = c - '0';
switch (esc_argc) {
case 0:
esc_arg1 = val;
esc_index++;
break;
case 1:
esc_arg1 = esc_arg1 * 10 + val;
break;
case 2:
esc_arg2 = val;
esc_index++;
break;
case 3:
esc_arg2 = esc_arg2 * 10 + val;
break;
default:
goto reset;
}
esc_argc++;
return 1;
}
esc_index++;
switch (esc_index) {
case 2:
if (c != '[')
goto reset;
return 1;
case 3:
switch (c) {
case 's': /* Save cursor position */
esc_saved_x = pos_x;
esc_saved_y = pos_y;
break;
case 'u': /* Return to saved cursor position */
pos_x = esc_saved_x;
pos_y = esc_saved_y;
move_cursor();
break;
case 'K': /* Clear to end of line */
break;
}
goto reset;
case 4:
switch (c) {
case 'A': /* Move cursor up # lines */
pos_y -= esc_arg1;
if (pos_y < 0)
pos_y = 0;
move = 1;
break;
case 'B': /* Move cursor down # lines */
pos_y += esc_arg1;
if (pos_y >= rows)
pos_y = rows - 1;
move = 1;
break;
case 'C': /* Move cursor forward # spaces */
pos_x += esc_arg1;
if (pos_x >= cols)
pos_x = cols - 1;
move = 1;
break;
case 'D': /* Move cursor back # spaces */
pos_x -= esc_arg1;
if (pos_x < 0)
pos_x = 0;
move = 1;
break;
case ';':
if (esc_argc == 1)
esc_argc = 2;
return 1;
case 'J':
if (esc_arg1 == 2) /* Clear screen */
clear_screen();
break;
case 'm': /* Change attribute */
switch (esc_arg1) {
case 0: /* reset */
attrib = 0x0F;
break;
case 1: /* bold */
attrib = 0x0F;
break;
case 4: /* under line */
break;
case 5: /* blink */
attrib |= 0x80;
break;
case 30: case 31: case 32: case 33:
case 34: case 35: case 36: case 37:
color = ansi_colors[esc_arg1 - 30];
attrib = (attrib & 0xf0) | color;
break;
case 40: case 41: case 42: case 43:
case 44: case 45: case 46: case 47:
color = ansi_colors[esc_arg1 - 40];
attrib = (attrib & 0x0f) | (color << 4);
break;
}
break;
}
if (move)
move_cursor();
goto reset;
case 6:
switch (c) {
case 'H':
case 'f':
pos_y = esc_arg1;
pos_x = esc_arg2;
if (pos_y >= rows)
pos_y = rows - 1;
if (pos_x >= cols)
pos_x = cols - 1;
move_cursor();
break;
case 'R':
/* XXX */
break;
}
goto reset;
default:
goto reset;
}
return 1;
reset:
esc_index = 0;
esc_argc = 0;
return 1;
}