/*

* app_video_lib.c

*

* Created: 2014/10/8 18:23:55

* Author: leo20_000

*/

#include "functions.h"

#include "app_fontset.h"

#include <avr/pgmspace.h>

#include <stdint.h>

#include <stdio.h>

#include <util/delay.h>

#define maxkeys 16

#define PORTDIR DDRB

#define PORTDATA PORTB

#define PORTIN PINB

#define right 20

#define down 30

#define left 40

#define cw 50

#define ccw 60

char str;

uint8_t screen[screen_array_size];

//One bit masks

uint8_t pos[8] = {0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};

int cri; //change to floats

int no_syl;

int syl_dur;

int sri;

int bf;

int dc;

int calc_val[8];

int index;

int cnt;

int fp;

//timeout value for LCD task

#define t2 100

// The raw keyscan

unsigned char key, debounce_key ;

// The decoded button number

unsigned char butnum ;

int enter;

int butval;

//*************************************************

// Draw and Delete Squares

//*************************************************

void draw_square(int x, int y) {

int new_x = x * 10;

int new_y = y * 10;

video_line(new_x, new_y, new_x + 9, new_y, 1);

video_line(new_x + 9, new_y, new_x + 9, new_y + 9, 1);

video_line(new_x + 9, new_y + 9, new_x, new_y + 9, 1);

video_line(new_x, new_y + 9, new_x, new_y, 1);

}

void draw_square_tp(int x, int y) {

int new_x = x * 6;

int new_y = y * 6;

video_line(new_x, new_y, new_x + 5, new_y, 1);

video_line(new_x + 5, new_y, new_x + 5, new_y + 5, 1);

video_line(new_x + 5, new_y + 5, new_x, new_y + 5, 1);

video_line(new_x, new_y + 5, new_x, new_y, 1);

}

void delete_square(int x, int y) {

int new_x = x * 10;

int new_y = y * 10;

video_line(new_x, new_y, new_x + 9, new_y, 0);

video_line(new_x + 9, new_y, new_x + 9, new_y + 9, 0);

video_line(new_x + 9, new_y + 9, new_x, new_y + 9, 0);

video_line(new_x, new_y + 9, new_x, new_y, 0);

}

void delete_square_tp(int x, int y) {

int new_x = x * 6;

int new_y = y * 6;

video_line(new_x, new_y, new_x + 5, new_y, 0);

video_line(new_x + 5, new_y, new_x + 5, new_y + 5, 0);

video_line(new_x + 5, new_y + 5, new_x, new_y + 5, 0);

video_line(new_x, new_y + 5, new_x, new_y, 0);

}

space spin_shape(int x, int y, int rand, int spin)

{

space s;

if( rand == 0 ){

if (spin == 0 || spin == 2)

{

s.a[0][0]= x - 2;

s.a[1][0] = y;

s.a[0][1] = x - 1;

s.a[1][1] = y;

s.a[0][2] = x;

s.a[1][2] = y;

s.a[0][3] = x + 1;

s.a[1][3] = y;

s.r_wall = 1;

s.l_wall = 2;

s.floor = 0;

}

else

{

s.a[0][0]= x;

s.a[1][0] = y - 2;

s.a[0][1] = x;

s.a[1][1] = y - 1;

s.a[0][2] = x;

s.a[1][2] = y;

s.a[0][3] = x;

s.a[1][3] = y + 1;

s.r_wall = 0;

s.l_wall = 0;

s.floor = 1;

}

}//if (rand == 0)

else if ( rand == 1 ) {

s.a[0][0] = x - 1;

s.a[1][0] = y;

s.a[0][1] = x;

s.a[1][1] = y;

s.a[0][2] = x;

s.a[1][2] = y + 1;

s.a[0][3] = x - 1;

s.a[1][3] = y + 1;

s.r_wall = 0;

s.l_wall = 1;

s.floor = 1;

}//else if (rand == 1)

else if ( rand == 2 ) {

if(spin == 0)

{

s.a[0][0] = x;

s.a[1][0] = y;

s.a[0][1] = x - 1;

s.a[1][1] = y;

s.a[0][2] = x + 1;

s.a[1][2] = y;

s.a[0][3] = x;

s.a[1][3] = y + 1;

s.r_wall = 1;

s.l_wall = 1;

s.floor = 1;

}

else if (spin == 1)

{

s.a[0][0] = x;

s.a[1][0] = y;

s.a[0][1] = x;

s.a[1][1] = y - 1;

s.a[0][2] = x - 1;

s.a[1][2] = y;

s.a[0][3] = x;

s.a[1][3] = y + 1;

s.r_wall = 0;

s.l_wall = 1;

s.floor = 1;

}

else if(spin == 2)

{

s.a[0][0] = x;

s.a[1][0] = y;

s.a[0][1] = x - 1;

s.a[1][1] = y;

s.a[0][2] = x + 1;

s.a[1][2] = y;

s.a[0][3] = x;

s.a[1][3] = y - 1;

s.r_wall = 1;

s.l_wall = 1;

s.floor = 0;

}

else if (spin == 3)

{

s.a[0][0] = x;

s.a[1][0] = y;

s.a[0][1] = x;

s.a[1][1] = y - 1;

s.a[0][2] = x + 1;

s.a[1][2] = y;

s.a[0][3] = x;

s.a[1][3] = y + 1;

s.r_wall = 1;

s.l_wall = 0;

s.floor = 1;

}

}//else if (rand == 2)

else if ( rand == 3 ) {

if (spin == 0)

{

s.a[0][0] = x - 1;

s.a[1][0] = y;

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

s.a[0][2] = x - 1;

s.a[1][2] = y + 2;

s.a[0][3] = x;

s.a[1][3] = y + 2;

s.r_wall = 0;

s.l_wall = 1;

s.floor = 2;

}

if (spin == 1)

{

s.a[0][0] = x;

s.a[1][0] = y + 1;

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

s.a[0][2] = x - 2;

s.a[1][2] = y + 1;

s.a[0][3] = x - 2;

s.a[1][3] = y + 2;

s.r_wall = 0;

s.l_wall = 2;

s.floor = 2;

}

if (spin == 2)

{

s.a[0][0] = x - 1;

s.a[1][0] = y;

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

s.a[0][2] = x - 1;

s.a[1][2] = y + 2;

s.a[0][3] = x - 2;

s.a[1][3] = y;

s.r_wall = -1;

s.l_wall = 2;

s.floor = 2;

}

else if (spin == 3)

{

s.a[0][0] = x;

s.a[1][0] = y + 1;

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

s.a[0][2] = x - 2;

s.a[1][2] = y + 1;

s.a[0][3] = x;

s.a[1][3] = y;

s.r_wall = 0;

s.l_wall = 2;

s.floor = 1;

}

}//else if (rand == 3)

else if ( rand == 4 ) {

if (spin == 0)

{

s.a[0][0] = x - 1;

s.a[1][0] = y;

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

s.a[0][2] = x - 1;

s.a[1][2] = y + 2;

s.a[0][3] = x - 2;

s.a[1][3] = y + 2;

s.r_wall = -1;

s.l_wall = 2;

s.floor = 2;

}

if (spin == 1)

{

s.a[0][0] = x;

s.a[1][0] = y + 1;

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

s.a[0][2] = x - 2;

s.a[1][2] = y + 1;

s.a[0][3] = x - 2;

s.a[1][3] = y;

s.r_wall = 0;

s.l_wall = 2;

s.floor = 1;

}

if (spin == 2)

{

s.a[0][0] = x - 1;

s.a[1][0] = y;

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

s.a[0][2] = x - 1;

s.a[1][2] = y + 2;

s.a[0][3] = x;

s.a[1][3] = y;

s.r_wall = 0;

s.l_wall = 1;

s.floor = 2;

}

else if (spin == 3)

{

s.a[0][0] = x;

s.a[1][0] = y + 1;

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

s.a[0][2] = x - 2;

s.a[1][2] = y + 1;

s.a[0][3] = x;

s.a[1][3] = y + 2;

s.r_wall = 0;

s.l_wall = 2;

s.floor = 2;

}

}//else if (rand == 4)

else if ( rand == 5 ) {

if (spin == 0 || spin == 2)

{

s.a[0][0] = x;

s.a[1][0] = y;

s.a[0][1] = x + 1;

s.a[1][1] = y;

s.a[0][2] = x;

s.a[1][2] = y - 1;

s.a[0][3] = x - 1;

s.a[1][3] = y - 1;

s.r_wall = 1;

s.l_wall = 1;

s.floor = 0;

}

else

{

s.a[0][0] = x;

s.a[1][0] = y;

s.a[0][1] = x + 1;

s.a[1][1] = y;

s.a[0][2] = x;

s.a[1][2] = y - 1;

s.a[0][3] = x + 1;

s.a[1][3] = y + 1;

s.r_wall = 1;

s.l_wall = 0;

s.floor = 1;

}

}//else if (rand ==5)

else if ( rand == 6 ) {

if (spin == 0 || spin == 2)

{

s.a[0][0] = x;

s.a[1][0] = y;

s.a[0][1] = x - 1;

s.a[1][1] = y;

s.a[0][2] = x;

s.a[1][2] = y + 1;

s.a[0][3] = x + 1;

s.a[1][3] = y + 1;

s.r_wall = 1;

s.l_wall = 1;

s.floor = 1;

}

else

{

s.a[0][0] = x;

s.a[1][0] = y;

s.a[0][1] = x + 1;

s.a[1][1] = y;

s.a[0][2] = x;

s.a[1][2] = y + 1;

s.a[0][3] = x + 1;

s.a[1][3] = y - 1;

s.r_wall = 1;

s.l_wall = 0;

s.floor = 1;

}

}//else if (rand == 6)

return s;

}//space spin_shape(...

space draw_shape(int x, int y, int rand, int spin, int two_player) {

space s;

if(!two_player)

{

if( rand == 0 ){

s = draw_four_by_one(x, y, spin);

}

else if ( rand == 1 ) {

s = draw_two_by_two (x, y);

}

else if ( rand == 2 ) {

s = draw_T(x, y, spin);

}

else if ( rand == 3 ) {

s = draw_L(x, y, spin);

}

else if ( rand == 4 ) {

s = draw_backward_L(x, y, spin);

}

else if ( rand == 5 ) {

s = draw_s(x, y, spin);

}

else if ( rand == 6 ) {

s = draw_z(x, y, spin);

}

return s;

}

else

{

if( rand == 0 ){

s = draw_four_by_one_tp(x, y, spin);

}

else if ( rand == 1 ) {

s = draw_two_by_two_tp (x, y);

}

else if ( rand == 2 ) {

s = draw_T_tp(x, y, spin);

}

else if ( rand == 3 ) {

s = draw_L_tp(x, y, spin);

}

else if ( rand == 4 ) {

s = draw_backward_L_tp(x, y, spin);

}

else if ( rand == 5 ) {

s = draw_s_tp(x, y, spin);

}

else if ( rand == 6 ) {

s = draw_z_tp(x, y, spin);

}

return s;

}

}//space draw_shape(...

//*************************************************

// One Player Shapes

//*************************************************

space draw_four_by_one(int x, int y, int spin) {

space s;

if (spin == 0 || spin == 2)

{

draw_square(x - 2, y);

s.a[0][0]= x - 2;

s.a[1][0] = y;

draw_square(x - 1, y);

s.a[0][1] = x - 1;

s.a[1][1] = y;

draw_square(x, y);

s.a[0][2] = x;

s.a[1][2] = y;

draw_square(x + 1, y);

s.a[0][3] = x + 1;

s.a[1][3] = y;

s.r_wall = 1;

s.l_wall = 2;

s.floor = 0;

}

else

{

draw_square(x, y - 2);

s.a[0][0]= x;

s.a[1][0] = y - 2;

draw_square(x, y - 1);

s.a[0][1] = x;

s.a[1][1] = y - 1;

draw_square(x, y);

s.a[0][2] = x;

s.a[1][2] = y;

draw_square(x, y + 1);

s.a[0][3] = x;

s.a[1][3] = y + 1;

s.r_wall = 0;

s.l_wall = 0;

s.floor = 1;

}

return s;

}

space draw_two_by_two(int x, int y) {

space s;

draw_square(x - 1, y );

s.a[0][0] = x - 1;

s.a[1][0] = y;

draw_square(x, y );

s.a[0][1] = x;

s.a[1][1] = y;

draw_square(x, y + 1);

s.a[0][2] = x;

s.a[1][2] = y + 1;

draw_square(x - 1, y + 1);

s.a[0][3] = x - 1;

s.a[1][3] = y + 1;

s.r_wall = 0;

s.l_wall = 1;

s.floor = 1;

return s;

}

space draw_T(int x, int y, int spin) {

space s;

if(spin == 0)

{

draw_square(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square(x - 1, y );

s.a[0][1] = x - 1;

s.a[1][1] = y;

draw_square(x + 1, y );

s.a[0][2] = x + 1;

s.a[1][2] = y;

draw_square(x , y + 1);

s.a[0][3] = x;

s.a[1][3] = y + 1;

s.r_wall = 1;

s.l_wall = 1;

s.floor = 1;

}

else if (spin == 1)

{

draw_square(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square(x , y - 1);

s.a[0][1] = x;

s.a[1][1] = y - 1;

draw_square(x - 1, y );

s.a[0][2] = x - 1;

s.a[1][2] = y;

draw_square(x , y + 1);

s.a[0][3] = x;

s.a[1][3] = y + 1;

s.r_wall = 0;

s.l_wall = 1;

s.floor = 1;

}

else if(spin == 2)

{

draw_square(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square(x - 1, y );

s.a[0][1] = x - 1;

s.a[1][1] = y;

draw_square(x + 1, y );

s.a[0][2] = x + 1;

s.a[1][2] = y;

draw_square(x , y - 1);

s.a[0][3] = x;

s.a[1][3] = y - 1;

s.r_wall = 1;

s.l_wall = 1;

s.floor = 0;

}

else if (spin == 3)

{

draw_square(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square(x , y - 1);

s.a[0][1] = x;

s.a[1][1] = y - 1;

draw_square(x + 1, y );

s.a[0][2] = x + 1;

s.a[1][2] = y;

draw_square(x , y + 1);

s.a[0][3] = x;

s.a[1][3] = y + 1;

s.r_wall = 1;

s.l_wall = 0;

s.floor = 1;

}

return s;

}

space draw_L(int x, int y, int spin) {

space s;

if (spin == 0)

{

draw_square(x - 1, y );

s.a[0][0] = x - 1;

s.a[1][0] = y;

draw_square(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square(x - 1, y + 2);

s.a[0][2] = x - 1;

s.a[1][2] = y + 2;

draw_square(x , y + 2);

s.a[0][3] = x;

s.a[1][3] = y + 2;

s.r_wall = 0;

s.l_wall = 1;

s.floor = 2;

}

if (spin == 1)

{

draw_square(x , y + 1);

s.a[0][0] = x;

s.a[1][0] = y + 1;

draw_square(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square(x - 2, y + 1);

s.a[0][2] = x - 2;

s.a[1][2] = y + 1;

draw_square(x - 2, y + 2);

s.a[0][3] = x - 2;

s.a[1][3] = y + 2;

s.r_wall = 0;

s.l_wall = 2;

s.floor = 2;

}

if (spin == 2)

{

draw_square(x - 1, y );

s.a[0][0] = x - 1;

s.a[1][0] = y;

draw_square(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square(x - 1, y + 2);

s.a[0][2] = x - 1;

s.a[1][2] = y + 2;

draw_square(x - 2, y );

s.a[0][3] = x - 2;

s.a[1][3] = y;

s.r_wall = -1;

s.l_wall = 2;

s.floor = 2;

}

else if (spin == 3)

{

draw_square(x , y + 1);

s.a[0][0] = x;

s.a[1][0] = y + 1;

draw_square(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square(x - 2, y + 1);

s.a[0][2] = x - 2;

s.a[1][2] = y + 1;

draw_square(x , y );

s.a[0][3] = x;

s.a[1][3] = y;

s.r_wall = 0;

s.l_wall = 2;

s.floor = 1;

}

return s;

}

space draw_backward_L(int x, int y, int spin) {

space s;

if (spin == 0)

{

draw_square(x - 1, y );

s.a[0][0] = x - 1;

s.a[1][0] = y;

draw_square(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square(x - 1, y + 2);

s.a[0][2] = x - 1;

s.a[1][2] = y + 2;

draw_square(x - 2, y + 2);

s.a[0][3] = x - 2;

s.a[1][3] = y + 2;

s.r_wall = -1;

s.l_wall = 2;

s.floor = 2;

}

if (spin == 1)

{

draw_square(x , y + 1);

s.a[0][0] = x;

s.a[1][0] = y + 1;

draw_square(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square(x - 2, y + 1);

s.a[0][2] = x - 2;

s.a[1][2] = y + 1;

draw_square(x - 2, y );

s.a[0][3] = x - 2;

s.a[1][3] = y;

s.r_wall = 0;

s.l_wall = 2;

s.floor = 1;

}

if (spin == 2)

{

draw_square(x - 1, y );

s.a[0][0] = x - 1;

s.a[1][0] = y;

draw_square(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square(x - 1, y + 2);

s.a[0][2] = x - 1;

s.a[1][2] = y + 2;

draw_square(x , y );

s.a[0][3] = x;

s.a[1][3] = y;

s.r_wall = 0;

s.l_wall = 1;

s.floor = 2;

}

else if (spin == 3)

{

draw_square(x , y + 1);

s.a[0][0] = x;

s.a[1][0] = y + 1;

draw_square(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square(x - 2, y + 1);

s.a[0][2] = x - 2;

s.a[1][2] = y + 1;

draw_square(x , y + 2);

s.a[0][3] = x;

s.a[1][3] = y + 2;

s.r_wall = 0;

s.l_wall = 2;

s.floor = 2;

}

return s;

}

space draw_s(int x, int y, int spin) {

space s;

if (spin == 0 || spin == 2)

{

draw_square(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square(x - 1, y );

s.a[0][1] = x - 1;

s.a[1][1] = y;

draw_square(x , y - 1);

s.a[0][2] = x;

s.a[1][2] = y - 1;

draw_square(x + 1, y - 1);

s.a[0][3] = x + 1;

s.a[1][3] = y - 1;

s.r_wall = 1;

s.l_wall = 1;

s.floor = 0;

}

else

{

draw_square(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square(x + 1, y );

s.a[0][1] = x + 1;

s.a[1][1] = y;

draw_square(x , y - 1);

s.a[0][2] = x;

s.a[1][2] = y - 1;

draw_square(x + 1, y + 1);

s.a[0][3] = x + 1;

s.a[1][3] = y + 1;

s.r_wall = 1;

s.l_wall = 0;

s.floor = 1;

}

return s;

}

space draw_z(int x, int y, int spin) {

space s;

if (spin == 0 || spin == 2)

{

draw_square(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square(x - 1, y );

s.a[0][1] = x - 1;

s.a[1][1] = y;

draw_square(x , y + 1);

s.a[0][2] = x;

s.a[1][2] = y + 1;

draw_square(x + 1, y + 1);

s.a[0][3] = x + 1;

s.a[1][3] = y + 1;

s.r_wall = 1;

s.l_wall = 1;

s.floor = 1;

}

else

{

draw_square(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square(x + 1, y );

s.a[0][1] = x + 1;

s.a[1][1] = y;

draw_square(x , y + 1);

s.a[0][2] = x;

s.a[1][2] = y + 1;

draw_square(x + 1, y - 1);

s.a[0][3] = x + 1;

s.a[1][3] = y - 1;

s.r_wall = 1;

s.l_wall = 0;

s.floor = 1;

}

return s;

}

//*************************************************

// Two Player Shapes

//*************************************************

space draw_four_by_one_tp(int x, int y, int spin) {

space s;

if (spin == 0 || spin == 2)

{

draw_square_tp(x - 2, y);

s.a[0][0]= x - 2;

s.a[1][0] = y;

draw_square_tp(x - 1, y);

s.a[0][1] = x - 1;

s.a[1][1] = y;

draw_square_tp(x, y);

s.a[0][2] = x;

s.a[1][2] = y;

draw_square_tp(x + 1, y);

s.a[0][3] = x + 1;

s.a[1][3] = y;

s.r_wall = 1;

s.l_wall = 2;

s.floor = 0;

}

else

{

draw_square_tp(x, y - 2);

s.a[0][0]= x;

s.a[1][0] = y - 2;

draw_square_tp(x, y - 1);

s.a[0][1] = x;

s.a[1][1] = y - 1;

draw_square_tp(x, y);

s.a[0][2] = x;

s.a[1][2] = y;

draw_square_tp(x, y + 1);

s.a[0][3] = x;

s.a[1][3] = y + 1;

s.r_wall = 0;

s.l_wall = 0;

s.floor = 1;

}

return s;

}

space draw_two_by_two_tp(int x, int y) {

space s;

draw_square_tp(x - 1, y );

s.a[0][0] = x - 1;

s.a[1][0] = y;

draw_square_tp(x, y );

s.a[0][1] = x;

s.a[1][1] = y;

draw_square_tp(x, y + 1);

s.a[0][2] = x;

s.a[1][2] = y + 1;

draw_square_tp(x - 1, y + 1);

s.a[0][3] = x - 1;

s.a[1][3] = y + 1;

s.r_wall = 0;

s.l_wall = 1;

s.floor = 1;

return s;

}

space draw_T_tp(int x, int y, int spin) {

space s;

if(spin == 0)

{

draw_square_tp(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square_tp(x - 1, y );

s.a[0][1] = x - 1;

s.a[1][1] = y;

draw_square_tp(x + 1, y );

s.a[0][2] = x + 1;

s.a[1][2] = y;

draw_square_tp(x , y + 1);

s.a[0][3] = x;

s.a[1][3] = y + 1;

s.r_wall = 1;

s.l_wall = 1;

s.floor = 1;

}

else if (spin == 1)

{

draw_square_tp(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square_tp(x , y - 1);

s.a[0][1] = x;

s.a[1][1] = y - 1;

draw_square_tp(x - 1, y );

s.a[0][2] = x - 1;

s.a[1][2] = y;

draw_square_tp(x , y + 1);

s.a[0][3] = x;

s.a[1][3] = y + 1;

s.r_wall = 0;

s.l_wall = 1;

s.floor = 1;

}

else if(spin == 2)

{

draw_square_tp(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square_tp(x - 1, y );

s.a[0][1] = x - 1;

s.a[1][1] = y;

draw_square_tp(x + 1, y );

s.a[0][2] = x + 1;

s.a[1][2] = y;

draw_square_tp(x , y - 1);

s.a[0][3] = x;

s.a[1][3] = y - 1;

s.r_wall = 1;

s.l_wall = 1;

s.floor = 0;

}

else if (spin == 3)

{

draw_square_tp(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square_tp(x , y - 1);

s.a[0][1] = x;

s.a[1][1] = y - 1;

draw_square_tp(x + 1, y );

s.a[0][2] = x + 1;

s.a[1][2] = y;

draw_square_tp(x , y + 1);

s.a[0][3] = x;

s.a[1][3] = y + 1;

s.r_wall = 1;

s.l_wall = 0;

s.floor = 1;

}

return s;

}

space draw_L_tp(int x, int y, int spin) {

space s;

if (spin == 0)

{

draw_square_tp(x - 1, y );

s.a[0][0] = x - 1;

s.a[1][0] = y;

draw_square_tp(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square_tp(x - 1, y + 2);

s.a[0][2] = x - 1;

s.a[1][2] = y + 2;

draw_square_tp(x , y + 2);

s.a[0][3] = x;

s.a[1][3] = y + 2;

s.r_wall = 0;

s.l_wall = 1;

s.floor = 2;

}

if (spin == 1)

{

draw_square_tp(x , y + 1);

s.a[0][0] = x;

s.a[1][0] = y + 1;

draw_square_tp(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square_tp(x - 2, y + 1);

s.a[0][2] = x - 2;

s.a[1][2] = y + 1;

draw_square_tp(x - 2, y + 2);

s.a[0][3] = x - 2;

s.a[1][3] = y + 2;

s.r_wall = 0;

s.l_wall = 2;

s.floor = 2;

}

if (spin == 2)

{

draw_square_tp(x - 1, y );

s.a[0][0] = x - 1;

s.a[1][0] = y;

draw_square_tp(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square_tp(x - 1, y + 2);

s.a[0][2] = x - 1;

s.a[1][2] = y + 2;

draw_square_tp(x - 2, y );

s.a[0][3] = x - 2;

s.a[1][3] = y;

s.r_wall = -1;

s.l_wall = 2;

s.floor = 2;

}

else if (spin == 3)

{

draw_square_tp(x , y + 1);

s.a[0][0] = x;

s.a[1][0] = y + 1;

draw_square_tp(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square_tp(x - 2, y + 1);

s.a[0][2] = x - 2;

s.a[1][2] = y + 1;

draw_square_tp(x , y );

s.a[0][3] = x;

s.a[1][3] = y;

s.r_wall = 0;

s.l_wall = 2;

s.floor = 1;

}

return s;

}

space draw_backward_L_tp(int x, int y, int spin) {

space s;

if (spin == 0)

{

draw_square_tp(x - 1, y );

s.a[0][0] = x - 1;

s.a[1][0] = y;

draw_square_tp(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square_tp(x - 1, y + 2);

s.a[0][2] = x - 1;

s.a[1][2] = y + 2;

draw_square_tp(x - 2, y + 2);

s.a[0][3] = x - 2;

s.a[1][3] = y + 2;

s.r_wall = -1;

s.l_wall = 2;

s.floor = 2;

}

if (spin == 1)

{

draw_square_tp(x , y + 1);

s.a[0][0] = x;

s.a[1][0] = y + 1;

draw_square_tp(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square_tp(x - 2, y + 1);

s.a[0][2] = x - 2;

s.a[1][2] = y + 1;

draw_square_tp(x - 2, y );

s.a[0][3] = x - 2;

s.a[1][3] = y;

s.r_wall = 0;

s.l_wall = 2;

s.floor = 1;

}

if (spin == 2)

{

draw_square_tp(x - 1, y );

s.a[0][0] = x - 1;

s.a[1][0] = y;

draw_square_tp(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square_tp(x - 1, y + 2);

s.a[0][2] = x - 1;

s.a[1][2] = y + 2;

draw_square_tp(x , y );

s.a[0][3] = x;

s.a[1][3] = y;

s.r_wall = 0;

s.l_wall = 1;

s.floor = 2;

}

else if (spin == 3)

{

draw_square_tp(x , y + 1);

s.a[0][0] = x;

s.a[1][0] = y + 1;

draw_square_tp(x - 1, y + 1);

s.a[0][1] = x - 1;

s.a[1][1] = y + 1;

draw_square_tp(x - 2, y + 1);

s.a[0][2] = x - 2;

s.a[1][2] = y + 1;

draw_square_tp(x , y + 2);

s.a[0][3] = x;

s.a[1][3] = y + 2;

s.r_wall = 0;

s.l_wall = 2;

s.floor = 2;

}

return s;

}

space draw_s_tp(int x, int y, int spin) {

space s;

if (spin == 0 || spin == 2)

{

draw_square_tp(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square_tp(x + 1, y );

s.a[0][1] = x + 1;

s.a[1][1] = y;

draw_square_tp(x , y - 1);

s.a[0][2] = x;

s.a[1][2] = y - 1;

draw_square_tp(x - 1, y - 1);

s.a[0][3] = x - 1;

s.a[1][3] = y - 1;

s.r_wall = 1;

s.l_wall = 1;

s.floor = 0;

}

else

{

draw_square_tp(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square_tp(x + 1, y );

s.a[0][1] = x + 1;

s.a[1][1] = y;

draw_square_tp(x , y + 1);

s.a[0][2] = x;

s.a[1][2] = y + 1;

draw_square_tp(x + 1, y - 1);

s.a[0][3] = x + 1;

s.a[1][3] = y - 1;

s.r_wall = 1;

s.l_wall = 0;

s.floor = 1;

}

return s;

}

space draw_z_tp(int x, int y, int spin) {

space s;

if (spin == 0 || spin == 2)

{

draw_square_tp(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square_tp(x + 1, y );

s.a[0][1] = x + 1;

s.a[1][1] = y;

draw_square_tp(x , y + 1);

s.a[0][2] = x;

s.a[1][2] = y + 1;

draw_square_tp(x - 1, y + 1);

s.a[0][3] = x - 1;

s.a[1][3] = y + 1;

s.r_wall = 1;

s.l_wall = 1;

s.floor = 1;

}

else

{

draw_square_tp(x , y );

s.a[0][0] = x;

s.a[1][0] = y;

draw_square_tp(x + 1, y );

s.a[0][1] = x + 1;

s.a[1][1] = y;

draw_square_tp(x , y - 1);

s.a[0][2] = x;

s.a[1][2] = y - 1;

draw_square_tp(x + 1, y + 1);

s.a[0][3] = x + 1;

s.a[1][3] = y + 1;

s.r_wall = 1;

s.l_wall = 0;

s.floor = 1;

}

return s;

}

void delete_shape(int x, int y, int rand, int spin, int two_player) {

if(!two_player)

{

if( rand == 0 ){

delete_four_by_one(x, y, spin);

}

else if (rand == 1){

delete_two_by_two (x, y);

}

else if ( rand == 2 ) {

delete_T(x, y, spin);

}

else if ( rand == 3 ) {

delete_L(x, y, spin);

}

else if ( rand == 4 ) {

delete_backward_L(x, y, spin);

}

else if ( rand == 5 ) {

delete_s(x, y, spin);

}

else if ( rand == 6 ) {

delete_z(x, y, spin);

}

}

else

{

if( rand == 0 ){

delete_four_by_one_tp(x, y, spin);

}

else if (rand == 1){

delete_two_by_two_tp (x, y);

}

else if ( rand == 2 ) {

delete_T_tp(x, y, spin);

}

else if ( rand == 3 ) {

delete_L_tp(x, y, spin);

}

else if ( rand == 4 ) {

delete_backward_L_tp(x, y, spin);

}

else if ( rand == 5 ) {

delete_s_tp(x, y, spin);

}

else if ( rand == 6 ) {

delete_z_tp(x, y, spin);

}

}

}

//*************************************************

// Delete One Player Shapes

//*************************************************

void delete_four_by_one(int x, int y, int spin) {

if (spin == 0 || spin == 2)

{

delete_square(x - 2, y);

delete_square(x - 1, y);

delete_square(x, y);

delete_square(x + 1, y);

}

else

{

delete_square(x, y - 2);

delete_square(x, y - 1);

delete_square(x, y);

delete_square(x, y + 1);

}

}

void delete_two_by_two(int x, int y) {

delete_square(x - 1, y );

delete_square(x , y );

delete_square(x , y + 1);

delete_square(x - 1, y + 1);

}

void delete_T(int x, int y, int spin) {

if (spin == 0)

{

delete_square(x , y );

delete_square(x - 1, y );

delete_square(x + 1, y );

delete_square(x , y + 1);

}

if (spin == 1)

{

delete_square(x , y );

delete_square(x , y - 1);

delete_square(x - 1, y );

delete_square(x , y + 1);

}

if (spin == 2)

{

delete_square(x , y );

delete_square(x - 1, y );

delete_square(x + 1, y );

delete_square(x , y - 1);

}

if (spin == 3)

{

delete_square(x , y );

delete_square(x , y - 1);

delete_square(x + 1, y );

delete_square(x , y + 1);

}

}

void delete_L(int x, int y, int spin) {

if (spin == 0)

{

delete_square(x - 1, y );

delete_square(x - 1, y + 1);

delete_square(x - 1, y + 2);

delete_square(x , y + 2);

}

if (spin == 1)

{

delete_square(x , y + 1);

delete_square(x - 1, y + 1);

delete_square(x - 2, y + 1);

delete_square(x - 2, y + 2);

}

if (spin == 2)

{

delete_square(x - 1, y );

delete_square(x - 1, y + 1);

delete_square(x - 1, y + 2);

delete_square(x - 2, y );

}

if (spin == 3)

{

delete_square(x , y + 1);

delete_square(x - 1, y + 1);

delete_square(x - 2, y + 1);

delete_square(x , y );

}

}

void delete_backward_L(int x, int y, int spin) {

if (spin == 0)

{

delete_square(x - 1, y );

delete_square(x - 1, y + 1);

delete_square(x - 1, y + 2);

delete_square(x - 2, y + 2);

}

if (spin == 1)

{

delete_square(x , y + 1);

delete_square(x - 1, y + 1);

delete_square(x - 2, y + 1);

delete_square(x - 2, y );

}

if (spin == 2)

{

delete_square(x - 1, y );

delete_square(x - 1, y + 1);

delete_square(x - 1, y + 2);

delete_square(x , y );

}

if (spin == 3)

{

delete_square(x , y + 1);

delete_square(x - 1, y + 1);

delete_square(x - 2, y + 1);

delete_square(x , y + 2);

}

}

void delete_s(int x, int y, int spin) {

if (spin == 0 || spin == 2)

{

delete_square(x , y );

delete_square(x - 1, y );

delete_square(x , y - 1);

delete_square(x + 1, y - 1);

}

else

{

delete_square(x , y );

delete_square(x + 1, y );

delete_square(x , y - 1);

delete_square(x + 1, y + 1);

}

}

void delete_z(int x, int y, int spin) {

if (spin == 0 || spin == 2)

{

delete_square(x , y );

delete_square(x - 1, y );

delete_square(x , y + 1);

delete_square(x + 1, y + 1);

}

else

{

delete_square(x , y );

delete_square(x + 1, y );

delete_square(x , y + 1);

delete_square(x + 1, y - 1);

}

}

//*************************************************

// Delete Two Player Shapes

//*************************************************

void delete_four_by_one_tp(int x, int y, int spin) {

if (spin == 0 || spin == 2)

{

delete_square_tp(x - 2, y);

delete_square_tp(x - 1, y);

delete_square_tp(x, y);

delete_square_tp(x + 1, y);

}

else

{

delete_square_tp(x, y - 2);

delete_square_tp(x, y - 1);

delete_square_tp(x, y);

delete_square_tp(x, y + 1);

}

}

void delete_two_by_two_tp(int x, int y) {

delete_square_tp(x - 1, y );

delete_square_tp(x , y );

delete_square_tp(x , y + 1);

delete_square_tp(x - 1, y + 1);

}

void delete_T_tp(int x, int y, int spin) {

if (spin == 0)

{

delete_square_tp(x , y );

delete_square_tp(x - 1, y );

delete_square_tp(x + 1, y );

delete_square_tp(x , y + 1);

}

if (spin == 1)

{

delete_square_tp(x , y );

delete_square_tp(x , y - 1);

delete_square_tp(x - 1, y );

delete_square_tp(x , y + 1);

}

if (spin == 2)

{

delete_square_tp(x , y );

delete_square_tp(x - 1, y );

delete_square_tp(x + 1, y );

delete_square_tp(x , y - 1);

}

if (spin == 3)

{

delete_square_tp(x , y );

delete_square_tp(x , y - 1);

delete_square_tp(x + 1, y );

delete_square_tp(x , y + 1);

}

}

void delete_L_tp(int x, int y, int spin) {

if (spin == 0)

{

delete_square_tp(x - 1, y );

delete_square_tp(x - 1, y + 1);

delete_square_tp(x - 1, y + 2);

delete_square_tp(x , y + 2);

}

if (spin == 1)

{

delete_square_tp(x , y + 1);

delete_square_tp(x - 1, y + 1);

delete_square_tp(x - 2, y + 1);

delete_square_tp(x - 2, y + 2);

}

if (spin == 2)

{

delete_square_tp(x - 1, y );

delete_square_tp(x - 1, y + 1);

delete_square_tp(x - 1, y + 2);

delete_square_tp(x - 2, y );

}

if (spin == 3)

{

delete_square_tp(x , y + 1);

delete_square_tp(x - 1, y + 1);

delete_square_tp(x - 2, y + 1);

delete_square_tp(x , y );

}

}

void delete_backward_L_tp(int x, int y, int spin) {

if (spin == 0)

{

delete_square_tp(x - 1, y );

delete_square_tp(x - 1, y + 1);

delete_square_tp(x - 1, y + 2);

delete_square_tp(x - 2, y + 2);

}

if (spin == 1)

{

delete_square_tp(x , y + 1);

delete_square_tp(x - 1, y + 1);

delete_square_tp(x - 2, y + 1);

delete_square_tp(x - 2, y );

}

if (spin == 2)

{

delete_square_tp(x - 1, y );

delete_square_tp(x - 1, y + 1);

delete_square_tp(x - 1, y + 2);

delete_square_tp(x , y );

}

if (spin == 3)

{

delete_square_tp(x , y + 1);

delete_square_tp(x - 1, y + 1);

delete_square_tp(x - 2, y + 1);

delete_square_tp(x , y + 2);

}

}

void delete_s_tp(int x, int y, int spin) {

if (spin == 0 || spin == 2)

{

delete_square_tp(x , y );

delete_square_tp(x + 1, y );

delete_square_tp(x , y - 1);

delete_square_tp(x - 1, y - 1);

}

else

{

delete_square_tp(x , y );

delete_square_tp(x + 1, y );

delete_square_tp(x , y + 1);

delete_square_tp(x + 1, y - 1);

}

}

void delete_z_tp(int x, int y, int spin) {

if (spin == 0 || spin == 2)

{

delete_square_tp(x , y );

delete_square_tp(x + 1, y );

delete_square_tp(x , y + 1);

delete_square_tp(x - 1, y + 1);

}

else

{

delete_square_tp(x , y );

delete_square_tp(x + 1, y );

delete_square_tp(x , y - 1);

delete_square_tp(x + 1, y + 1);

}

}

//Checks if we have hit another piece while falling

int check_matrix(matrix board, space array){

int bottom = 0;

int x;

int y;

for(int i = 0; i < 4; i++){

x = array.a[0][i];

y = array.a[1][i];

if (board.b[y+1][x] == 1){

bottom = 1;

return bottom;

}

}

return bottom;

}

int check_matrix_tp(matrix board, space array){

int bottom = 0;

int x;

int y;

for(int i = 0; i < 4; i++){

x = array.a[0][i] - 16;

y = array.a[1][i];

if (board.b[y+1][x] == 1){

bottom = 1;

return bottom;

}

}

return bottom;

}

//Checks if we will hit another piece while moving left or right

int check_matrix_wall(matrix board, space array, int direction){

int wall = 0;

int x;

int y;

for(int i = 0; i < 4; i++){

x = array.a[0][i];

y = array.a[1][i];

if (board.b[y][x + direction] == 1){

wall = 1;

return wall;

}

}

return wall;

}

int check_matrix_wall_tp(matrix board, space array, int direction){

int wall = 0;

int x;

int y;

for(int i = 0; i < 4; i++){

x = array.a[0][i]-16;

y = array.a[1][i];

if (board.b[y][x + direction] == 1){

wall = 1;

return wall;

}

}

return wall;

}

//Checks if we will hit another stationary piece if we spin

int check_matrix_spin(matrix board, space array, int two_player){

int x;

int y;

int cant_spin = 0;

for(int i = 0; i < 4; i++){

x = array.a[0][i];

y = array.a[1][i];

if (board.b[y][x] == 1){

cant_spin = 1;

return cant_spin;

}

if(!two_player){

if (x <= 5)

{

cant_spin = 2;

return cant_spin;

}

if( x >= 14)

{

cant_spin = 3;

return cant_spin;

}

if ( y >= 18)

{

cant_spin = 4;

return cant_spin;

}

}

else{

if (x <= 0)

{

cant_spin = 2;

return cant_spin;

}

if( x >= 9)

{

cant_spin = 3;

return cant_spin;

}

if ( y >= 25)

{

cant_spin = 4;

return cant_spin;

}

}

}

return cant_spin;

}

int check_matrix_spin_A(matrix board, space array){

int x;

int y;

int cant_spin = 0;

for(int i = 0; i < 4; i++){

x = array.a[0][i];

y = array.a[1][i];

if (board.b[y][x] == 1){

cant_spin = 1;

return cant_spin;

}

if (x <= 0)

{

cant_spin = 2;

return cant_spin;

}

if( x >= 9)

{

cant_spin = 3;

return cant_spin;

}

if ( y >= 25)

{

cant_spin = 4;

return cant_spin;

}

}

return cant_spin;

}

int check_matrix_spin_B(matrix board, space array){

int x;

int y;

int cant_spin = 0;

for(int i = 0; i < 4; i++){

x = array.a[0][i] - 16;

y = array.a[1][i];

if (board.b[y][x] == 1){

cant_spin = 1;

return cant_spin;

}

if (x <= 0)

{

cant_spin = 2;

return cant_spin;

}

if( x >= 9)

{

cant_spin = 3;

return cant_spin;

}

if ( y >= 25)

{

cant_spin = 4;

return cant_spin;

}

}

return cant_spin;

}

//Check if we need to delete a row

row check_matrix_row(matrix board, space array, int two_player){

int block;

int counter;

row deletion;

deletion.clear = 0;

if(!two_player)

{

for(int i = 0; i < 4; i++)

{

counter = 0;

block = array.a[1][i];

for(int j = 5; j < 15; j++)

{

if(board.b[block][j] == 1)

{

counter++;

}

else

{

j = 15;

}

}

if (counter == 10)

{

deletion.c[i] = 1;

deletion.clear = 1;

}

else

{

deletion.c[i] = 0;

}

}

return deletion;

}

else

{

for(int i = 0; i < 4; i++)

{

//draw_square_tp(13, 6);

counter = 0;

block = array.a[1][i];

for(int j = 0; j < 10; j++)

{

if(board.b[block][j] == 1)

{

counter++;

}

else

{

j = 10;

}

}

if (counter == 10)

{

//draw_square_tp(13, 6);

deletion.c[i] = 1;

deletion.clear = 1;

}

else

{

deletion.c[i] = 0;

}

}

return deletion;

}

}

//Delete a row

matrix row_deleter(row deletion, space array, matrix board, int two_player, int player)

{

matrix new_board = board;

int value_array[4] = {100, 100, 100, 100};

int temp;

int skip;

for(int i = 0; i < 4; i++)

{

skip = 0;

int value = array.a[1][i];

for(int d = 0; d < 4; d++)

{

if(value_array[d] == value)

{

skip = 1;

}

}

if(deletion.c[i] == 1 && skip == 0)

{

value_array[i] = value;

if(!two_player)

{

for(int j = 5; j < 15; j++)

{

delete_square(j, array.a[1][i]);

board.b[array.a[1][i]][j] = 0;

}

}

else if (player)

{

for(int j = 0; j < 10; j++)

{

delete_square(j, array.a[1][i]);

board.b[array.a[1][i]][j] = 0;

}

}

else

{

for(int j = 0; j < 10; j++)

{

delete_square(j+15, array.a[1][i]);

board.b[array.a[1][i]][j] = 0;

}

}

}

}

int sorted = 0;

while(sorted == 0)

{

sorted = 1;

for(int e = 0; e < 3; e++)

{

if(value_array[e] > value_array[e+1])

{

temp = value_array[e];

value_array[e] = value_array[e+1];

value_array[e+1] = temp;

sorted = 0;

}

}

}

int k = 0;

int f = 0;

for(k = 0; value_array[k] != 100; k++)

{

for(int g = value_array[k]; g > 0; g--)

{

if(!two_player)

{

for(int d = 5; d < 15; d++)

{

new_board.b[g][d] = new_board.b[g-1][d];

}

}

else

{

for(int d = 0; d < 10; d++)

{

new_board.b[g][d] = new_board.b[g-1][d];

}

f = k+1;

}

}

}

new_board.k = f;

return new_board;

}

//Update matrix with new piece

matrix update_matrix(matrix board, space array, int player){

int x;

int y;

for(int i = 0; i < 4; i++){

if(player == 1)

{

x = array.a[0][i];

y = array.a[1][i];

board.b[y][x] = 1;

}

else

{

x = array.a[0][i]-16;

y = array.a[1][i];

board.b[y][x] = 1;

}

}

return board;

}

//Draw the board over again after we clear or add lines

void draw_board(matrix board, matrix new_board, int two_player)

{

if(!two_player)

{

for(int i = 0; i < 20; i++)

{

for(int j = 5; j < 15; j++)

{

if(board.b[i][j] == 1)

{

delete_square(j, i);

}

if(new_board.b[i][j] == 1)

{

draw_square(j, i);

}

}

}

}

else

{

for(int i = 0; i < 26; i++)

{

for(int j = 0; j < 10; j++)

{

if(board.b[i][j] == 1)

{

delete_square_tp(j, i);

}

if(new_board.b[i][j] == 1)

{

draw_square_tp(j, i);

}

}

}

}

}

void draw_board_tp(matrix board, matrix new_board)

{

for(int i = 0; i < 26; i++)

{

for(int j = 0; j < 10; j++)

{

if(board.b[i][j] == 1)

{

delete_square_tp(j+16, i);

}

if(new_board.b[i][j] == 1)

{

draw_square_tp(j+16, i);

}

}

}

}

//==================================

//plot one point

//at x,y with color 1=white 0=black 2=invert

void video_pt(uint8_t x, uint8_t y, uint8_t c) {

//each line has 18 bytes

//calculate i based upon this and x,y

// the byte with the pixel in it

//int i = (x >> 3) + ((int)y<<4) + ((int)y<<1);

int i = (x >> 3) + (int)y * bytes_per_line ;

if (c==1)

screen[i] = screen[i] | pos[x & 7];

else if (c==0)

screen[i] = screen[i] & ~pos[x & 7];

else

screen[i] = screen[i] ^ pos[x & 7];

}

//==================================

//plot a line

//at x1,y1 to x2,y2 with color 1=white 0=black 2=invert

//NOTE: this function requires signed chars

//Code is from David Rodgers,

//"Procedural Elements of Computer Graphics",1985

void video_line(int x1, int y1, int x2, int y2, int c) {

int e;

int dx,dy,j, temp;

int s1,s2, xchange;

int x,y;

x = x1;

y = y1;

//take absolute value

if (x2 < x1) {

dx = x1 - x2;

s1 = -1;

}

else if (x2 == x1) {

dx = 0;

s1 = 0;

}

else {

dx = x2 - x1;

s1 = 1;

}

if (y2 < y1) {

dy = y1 - y2;

s2 = -1;

}

else if (y2 == y1) {

dy = 0;

s2 = 0;

}

else {

dy = y2 - y1;

s2 = 1;

}

xchange = 0;

if (dy>dx) {

temp = dx;

dx = dy;

dy = temp;

xchange = 1;

}

e = ((int)dy<<1) - dx;

for (j=0; j<=dx; j++) {

video_pt(x,y,c);

if (e>=0) {

if (xchange==1) x = x + s1;

else y = y + s2;

e = e - ((int)dx<<1);

}

if (xchange==1) y = y + s2;

else x = x + s1;

e = e + ((int)dy<<1);

}

}

//==================================

// put a big character on the screen

// c is index into bitmap

void video_putchar(uint8_t x, uint8_t y, uint8_t c) {

uint8_t i;

uint8_t y_pos;

uint8_t j;

for (i=0;i<7;i++) {

y_pos = y + i;

j = pgm_read_byte(((uint16_t)(&ascii[0])) + c*7 + i);

video_pt(x, y_pos, (j & 0x80)==0x80);

video_pt(x+1, y_pos, (j & 0x40)==0x40);

video_pt(x+2, y_pos, (j & 0x20)==0x20);

video_pt(x+3, y_pos, (j & 0x10)==0x10);

video_pt(x+4, y_pos, (j & 0x08)==0x08);

}

}

//==================================

// put a string of big characters on the screen

void video_puts(uint8_t x, uint8_t y, uint8_t *str) {

uint8_t i = 0;

for (i=0; str[i] != 0; i++) {

video_putchar(x,y,str[i]);

x = x+6;

}

}

//==================================

// put a small character on the screen

// x-coord must be on divisible by 4

// c is index into bitmap

void video_smallchar(uint8_t x, uint8_t y, uint8_t c) {

uint8_t mask;

//int i=((int)x>>3) + ((int)y<<4) + ((int)y<<1);

int i=((int)x>>3) + (int)y * bytes_per_line ;

if (x == (x & 0xf8)) mask = 0x0f; //f8

else mask = 0xf0;

uint8_t j = pgm_read_byte(((uint16_t)(smallbitmap)) + c*5);

screen[i] = (screen[i] & mask) | (j & ~mask);

j = pgm_read_byte(((uint16_t)(smallbitmap)) + c*5 + 1);

screen[i+bytes_per_line] = (screen[i+bytes_per_line] & mask) | (j & ~mask);

j = pgm_read_byte(((uint16_t)(smallbitmap)) + c*5 + 2);

screen[i+bytes_per_line*2] = (screen[i+bytes_per_line*2] & mask) | (j & ~mask);

j = pgm_read_byte(((uint16_t)(smallbitmap)) + c*5 + 3);

screen[i+bytes_per_line*3] = (screen[i+bytes_per_line*3] & mask) | (j & ~mask);

j = pgm_read_byte(((uint16_t)(smallbitmap)) + c*5 + 4);

screen[i+bytes_per_line*4] = (screen[i+bytes_per_line*4] & mask) | (j & ~mask);

}

//==================================

// put a string of small characters on the screen

// x-cood must be on divisible by 4

void video_putsmalls(uint8_t x, uint8_t y, uint8_t *str) {

uint8_t i;

x = x & 0b11111100; //make it divisible by 4

for (i = 0; str[i] != 0; i++) {

if (str[i] >= 0x30 && str[i] <= 0x3a)

video_smallchar(x, y, str[i] - 0x30);

else video_smallchar(x, y, str[i] - 0x40 + 12);

x += 4;

}

}

//==================================

//return the value of one point

//at x,y with color 1=white 0=black 2=invert

uint8_t video_set(uint8_t x, uint8_t y) {

//The following construction

//detects exactly one bit at the x,y location

// int i = (x>>3) + ((int)y<<4) + ((int)y<<3);

int i = (x>>3) + (int)y * bytes_per_line ;

return (screen[i] & 1<<(7-(x & 0x7)));

}