//video gen and sound
//D.5 is sync:1000 ohm + diode to 75 ohm resistor
//D.6 is video:330 ohm + diode to 75 ohm resistor 
//B.3 is sound  and should have a 10k resistor to gnd

#pragma regalloc-    //I allocate the registers myself
#pragma optsize-     //optimize for speed
                   
#include <Mega32.h>  
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <delay.h>  

//cycles = 63.625 * 16 Note NTSC is 63.55
//but this line duration makes each frame exactly 1/60 sec
//which is nice for keeping a realtime clock
#define lineTime 1018
 
#define begin {
#define end   }
#define ScreenTop 30
#define ScreenBot 230

//NOTE that v1 to v8 and i must be in registers! 
register char v1 @4;
register char v2 @5;
register char v3 @6;
register char v4 @7;
register char v5 @8;
register char v6 @9;
register char v7 @10;
register char v8 @11;
register int i @12;

#pragma regalloc+

char syncON, syncOFF;
int LineCount;
int time;
char screen[1600];


//All new variables and functions   
int j,k; 
int erasescreen=0;
char top=10;
char bot=99;  
char left=8;
char right=118;            
char player=1;
char col; 
char row=0;    
char win=0;
char temp;
char a,b;    
char tally1=0;
char tally2=0;
char grid[8][9];
char colnum[]="123456789"; 
void initscreen(void);
void initialize(void);
void displayplayer(char p);
char check(char row, char col, char dir);



                
//Point plot lookup table  
//One bit masks
flash char pos[8]={0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};

//define some character bitmaps
//5x7 characters
flash char bitmap[40][7]={
//0
0b01110000,
0b10001000,
0b10011000,
0b10101000,
0b11001000,
0b10001000,
0b01110000,
//1
0b00100000,
0b01100000,
0b00100000,
0b00100000,
0b00100000,
0b00100000,
0b01110000, 
//2
0b01110000,
0b10001000,
0b00001000,
0b00010000,
0b00100000,
0b01000000,
0b11111000,
    //3
0b11111000,
0b00010000,
0b00100000,
0b00010000,
0b00001000,
0b10001000,
0b01110000,
//4
0b00010000,
0b00110000,
0b01010000,
0b10010000,
0b11111000,
0b00010000,
0b00010000,
//5
0b11111000,
0b10000000,
0b11110000,
0b00001000,
0b00001000,
0b10001000,
0b01110000,
//6
0b01000000,
0b10000000,
0b10000000,
0b11110000,
0b10001000,
0b10001000,
0b01110000,
//7
0b11111000,
0b00001000,
0b00010000,
0b00100000,
0b01000000,
0b10000000,
0b10000000,
//8
0b01110000,
0b10001000,
0b10001000,
0b01110000,
0b10001000,
0b10001000,
0b01110000,
//9
0b01110000,
0b10001000,
0b10001000,
0b01111000,
0b00001000,
0b00001000,
0b00010000, 
//A
0b01110000,
0b10001000,
0b10001000,
0b10001000,
0b11111000,
0b10001000,
0b10001000,
//B
0b11110000,
0b10001000,
0b10001000,
0b11110000,
0b10001000,
0b10001000,
0b11110000,
//C
0b01110000,
0b10001000,
0b10000000,
0b10000000,
0b10000000,
0b10001000,
0b01110000,
//D
0b11110000,
0b10001000,
0b10001000,
0b10001000,
0b10001000,
0b10001000,
0b11110000,
//E
0b11111000,
0b10000000,
0b10000000,
0b11111000,
0b10000000,
0b10000000,
0b11111000,
//F
0b11111000,
0b10000000,
0b10000000,
0b11111000,
0b10000000,
0b10000000,
0b10000000,
//G
0b01110000,
0b10001000,
0b10000000,
0b10011000,
0b10001000,
0b10001000,
0b01110000,
//H
0b10001000,
0b10001000,
0b10001000,
0b11111000,
0b10001000,
0b10001000,
0b10001000,
//I
0b01110000,
0b00100000,
0b00100000,
0b00100000,
0b00100000,
0b00100000,
0b01110000,
//J
0b00111000,
0b00010000,
0b00010000,
0b00010000,
0b00010000,
0b10010000,
0b01100000,
//K
0b10001000,
0b10010000,
0b10100000,
0b11000000,
0b10100000,
0b10010000,
0b10001000,
//L
0b10000000,
0b10000000,
0b10000000,
0b10000000,
0b10000000,
0b10000000,
0b11111000,
//M
0b10001000,
0b11011000,
0b10101000,
0b10101000,
0b10001000,
0b10001000,
0b10001000,
//N
0b10001000,
0b10001000,
0b11001000,
0b10101000,
0b10011000,
0b10001000,
0b10001000,
//O
0b01110000,
0b10001000,
0b10001000,
0b10001000,
0b10001000,
0b10001000,
0b01110000,
//P
0b11110000,
0b10001000,
0b10001000,
0b11110000,
0b10000000,
0b10000000,
0b10000000,
//Q
0b01110000,
0b10001000,
0b10001000,
0b10001000,
0b10101000,
0b10010000,
0b01101000,
//R
0b11110000,
0b10001000,
0b10001000,
0b11110000,
0b10100000,
0b10010000,
0b10001000,
//S
0b01111000,
0b10000000,
0b10000000,
0b01110000,
0b00001000,
0b00001000,
0b11110000,
//T
0b11111000,
0b00100000,
0b00100000,
0b00100000,
0b00100000,
0b00100000,
0b00100000,
//U
0b10001000,
0b10001000,
0b10001000,
0b10001000,
0b10001000,
0b10001000,
0b01110000,
//V
0b10001000,
0b10001000,
0b10001000,
0b10001000,
0b10001000,
0b01010000,
0b00100000,
//W
0b10001000,
0b10001000,
0b10001000,
0b10101000,
0b10101000,
0b10101000,
0b01010000,
//X
0b10001000,
0b10001000,
0b01010000,
0b00100000,
0b01010000,
0b10001000,
0b10001000,
//Y
0b10001000,
0b10001000,
0b10001000,
0b01010000,
0b00100000,
0b00100000,
0b00100000,
//Z
0b11111000,
0b00001000,
0b00010000,
0b00100000,
0b01000000,
0b10000000,
0b11111000,
//figure1
0b01110000,
0b00100000,
0b01110000,
0b10101000,
0b00100000,
0b01010000,
0b10001000,
//figure2
0b01110000,
0b10101000,
0b01110000,
0b00100000,
0b00100000,
0b01010000,
0b10001000,


//#38
0b00000000,
0b01110000,
0b11111000,
0b11111000,
0b11111000,
0b01110000,
0b00000000,

//#39
0b00000000,
0b01110000,
0b10001000,
0b10001000,
0b10001000,
0b01110000,
0b00000000
};


//================================
//3x5 font numbers, then letters
//packed two per definition for fast
//copy to the screen at x-position divisible by 4
flash char smallbitmap[39][5]={
//0
    0b11101110,
0b10101010,
0b10101010,
0b10101010,
0b11101110,
//1
0b01000100,
0b11001100,
0b01000100,
0b01000100,
0b11101110,
//2
0b11101110,
0b00100010,
0b11101110,
0b10001000,
0b11101110,
//3
0b11101110,
0b00100010,
0b11101110,
0b00100010,
0b11101110,
//4
0b10101010,
0b10101010,
0b11101110,
0b00100010,
0b00100010,
//5
0b11101110,
0b10001000,
0b11101110,
0b00100010,
0b11101110,
//6
0b11001100,
0b10001000,
0b11101110,
0b10101010,
0b11101110,
//7
0b11101110,
0b00100010,
0b01000100,
0b10001000,
0b10001000,
//8
0b11101110,
0b10101010,
0b11101110,
0b10101010,
0b11101110,
//9
0b11101110,
0b10101010,
0b11101110,
0b00100010,
0b01100110,
//:
0b00000000,
0b01000100,
0b00000000,
0b01000100,
0b00000000,
//=
0b00000000,
0b11101110,
0b00000000,
0b11101110,
0b00000000,
//blank
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
//A
0b11101110,
0b10101010,
0b11101110,
0b10101010,
0b10101010,
//B
0b11001100,
0b10101010,
0b11101110,
0b10101010,
0b11001100,
//C
0b11101110,
0b10001000,
0b10001000,
0b10001000,
0b11101110,
//D
0b11001100,
0b10101010,
0b10101010,
0b10101010,
0b11001100,
//E
0b11101110,
0b10001000,
0b11101110,
0b10001000,
0b11101110,
//F
0b11101110,
0b10001000,
0b11101110,
0b10001000,
0b10001000,
//G
0b11101110,
0b10001000,
0b10001000,
0b10101010,
0b11101110,
//H
0b10101010,
0b10101010,
0b11101110,
0b10101010,
0b10101010,
//I
0b11101110,
0b01000100,
0b01000100,
0b01000100,
0b11101110,
//J
0b00100010,
0b00100010,
0b00100010,
0b10101010,
0b11101110,
//K
0b10001000,
0b10101010,
0b11001100,
0b11001100,
0b10101010,
//L
0b10001000,
0b10001000,
0b10001000,
0b10001000,
0b11101110,
//M
0b10101010,
0b11101110,
0b11101110,
0b10101010,
0b10101010,
//N
0b00000000,
0b11001100,
0b10101010,
0b10101010,
0b10101010,
//O
0b01000100,
0b10101010,
0b10101010,
0b10101010,
0b01000100,
//P
0b11101110,
0b10101010,
0b11101110,
0b10001000,
0b10001000,
//Q
0b01000100,
0b10101010,
0b10101010,
0b11101110,
0b01100110,
//R
0b11101110,
0b10101010,
0b11001100,
0b11101110,
0b10101010,
//S
0b11101110,
0b10001000,
0b11101110,
0b00100010,
0b11101110,
//T
0b11101110,
0b01000100,
0b01000100,
0b01000100,
0b01000100,
//U
0b10101010,
0b10101010,
0b10101010,
0b10101010,
0b11101110,
//V
0b10101010,
0b10101010,
0b10101010,
0b10101010,
0b01000100,
//W
0b10101010,
0b10101010,
0b11101110,
0b11101110,
0b10101010,
//X
0b00000000,
0b10101010,
0b01000100,
0b01000100,
0b10101010,
//Y
0b10101010,
0b10101010,
0b01000100,
0b01000100,
0b01000100,
//Z
0b11101110,
0b00100010,
0b01000100,
0b10001000,
0b11101110
};

//==================================
//This is the sync generator and raster generator. It MUST be entered from
//sleep mode to get accurate timing of the sync pulses
#pragma warn-
interrupt [TIM1_COMPA] void t1_cmpA(void) 
begin

if (erasescreen<=475)
{


  //start the Horizontal sync pulse   
  PORTD = syncON;    
  //update the curent scanline number
  LineCount ++ ;  
  //begin inverted (Vertical) synch after line 247
  if (LineCount==248)
  begin
    syncON = 0b00100000;
    syncOFF = 0;
  end
  //back to regular sync after line 250
  if (LineCount==251)
  begin
    syncON = 0;
    syncOFF = 0b00100000;
  end 
  //start new frame after line 262
  if (LineCount==263)
  begin
     LineCount = 1;
  end 
 
  delay_us(2); //adjust to make 5 us pulses
  //end sync pulse
  PORTD = syncOFF;  
 
  if (LineCount<ScreenBot && LineCount>=ScreenTop)
    begin
      
       //compute byte index for beginning of the next line
       //left-shift 4 would be individual lines
       // <<3 means line-double the pixels
       //The 0xfff8 truncates the odd line bit
       //i=(LineCount-ScreenTop)<<3 & 0xfff8; //
      
       #asm
       push r16
       lds   r12, _LineCount
       lds   r13, _Linecount+1
       ldi   r16, 30
       sub  r12, r16
       ldi  r16,0
       sbc  r13, r16
       lsl  r12
       rol  r13
       lsl  r12
       rol  r13
       lsl  r12   
       rol  r13
       mov  r16,r12
       andi r16,0xf0
       mov  r12,r16
       pop r16
       #endasm
       
       //load 16 registers with screen info
       #asm
       push r14
       push r15
       push r16
       push r17
       push r18
       push r19
       push r26
       push r27
      
       ldi  r26,low(_screen)   ;base address of screen
       ldi  r27,high(_screen)  
       add  r26,r12            ;offset into screen (add i)
       adc  r27,r13
       ld   r4,x+          ;load 16 registers and inc pointer
       ld   r5,x+
       ld   r6,x+ 
       ld   r7,x+
       ld   r8,x+
       ld   r9,x+
       ld   r10,x+ 
       ld   r11,x+
       ld   r12,x+
       ld   r13,x+
       ld   r14,x+ 
       ld   r15,x+
       ld   r16,x+  
       ld   r17,x+ 
       ld   r18,x+
       ld   r19,x
      
       pop  r27
       pop  r26
       #endasm 

       delay_us(4);  //adjust to center image on screen
      
       //blast 16 bytes to the screen  
       #asm
       ;but first a macro to make the code shorter 
       ;the macro takes a register number as a parameter
       ;and dumps its bits serially to portD.6  
       ;the nop can be eliminated to make the display narrower
       .macro videobits ;regnum
        BST  @0,7
IN   R30,0x12
BLD  R30,6
nop
OUT  0x12,R30 

BST  @0,6
IN   R30,0x12
BLD  R30,6
nop
OUT  0x12,R30

BST  @0,5
IN   R30,0x12
BLD  R30,6
nop
OUT  0x12,R30

BST  @0,4
IN   R30,0x12
BLD  R30,6
nop
OUT  0x12,R30

BST  @0,3
IN   R30,0x12
BLD  R30,6
nop
OUT  0x12,R30

BST  @0,2
IN   R30,0x12
BLD  R30,6
nop
OUT  0x12,R30

BST  @0,1
IN   R30,0x12
BLD  R30,6
nop
OUT  0x12,R30

BST  @0,0
IN   R30,0x12
BLD  R30,6
nop
OUT  0x12,R30
       .endm    
       
videobits r4 ;video line -- byte 1
        videobits r5 ;byte 2 
        videobits r6 ;byte 3
        videobits r7 ;byte 4
        videobits r8 ;byte 5
        videobits r9 ;byte 6
        videobits r10 ;byte 7
        videobits r11 ;byte 8
        videobits r12 ;byte 9
        videobits r13 ;byte 10 
        videobits r14 ;byte 11
        videobits r15 ;byte 12
        videobits r16 ;byte 13
        videobits r17 ;byte 14
        videobits r18 ;byte 15
        videobits r19 ;byte 16
clt   ;clear video after the last pixel on the line
IN   R30,0x12
BLD  R30,6
OUT  0x12,R30

       pop r19
       pop r18
       pop r17
       pop r16 
       pop r15
       pop r14
       #endasm
             
    end          
   
   
   

}


end 
#pragma warn+

//==================================
//plot one point
//at x,y with color 1=white 0=black 2=invert
#pragma warn-
void video_pt(char x, char y, char c)
begin  

#asm
;  i=(x>>3) + ((int)y<<4) ;   the byte with the pixel in it

push r16
ldd r30,y+2 ;get x
lsr r30
lsr r30
lsr r30     ;divide x by 8
ldd r12,y+1 ;get y
       lsl r12     ;mult y by 16
       clr r13
lsl r12
rol r13
lsl r12
rol r13
lsl r12
rol r13
add r12, r30     ;add in x/8

;v2 = screen[i];   r5
        ;v3 = pos[x & 7];  r6
;v4 = c            r7
ldi r30,low(_screen)
ldi r31,high(_screen)
add r30, r12
adc r31, r13
ld r5,Z  ;get screen byte
ldd r26,y+2 ;get x
ldi r27,0
andi r26,0x07           ;form x & 7
ldi r30,low(_pos*2) 
ldi r31,high(_pos*2)
add r30,r26
adc r31,r27
lpm r6,Z
ld r16,y ;get c
      
       ;if (v4==1) screen[i] = v2 | v3 ;
       ;if (v4==0) screen[i] = v2 & ~v3;
       ;if (v4==2) screen[i] = v2 ^ v3 ;
      
       cpi r16,1
       brne tst0
       or  r5,r6
       tst0:
       cpi r16,0
       brne tst2
       com r6
       and r5,r6
       tst2:
       cpi r16,2
       brne writescrn
       eor r5,r6
       writescrn:
       ldi r30,low(_screen)
ldi r31,high(_screen)
add r30, r12
adc r31, r13
st Z, r5        ;write the byte back to the screen

pop r16
#endasm
      
end
#pragma warn+

//==================================
// put a big character on the screen
// c is index into bitmap
void video_putchar(char x, char y, char c) 
begin
    v7 = x;
    for (v6=0;v6<7;v6++)
    begin
        v1 = bitmap[c][v6];
        v8 = y+v6;
        video_pt(v7,   v8, (v1 & 0x80)==0x80); 
        video_pt(v7+1, v8, (v1 & 0x40)==0x40);
        video_pt(v7+2, v8, (v1 & 0x20)==0x20);
        video_pt(v7+3, v8, (v1 & 0x10)==0x10);
        video_pt(v7+4, v8, (v1 & 0x08)==0x08);
    end
end

//==================================
// put a string of big characters on the screen
void video_puts(char x, char y, char *str)
begin
char i ;
for (i=0; str[i]!=0; i++)
begin 
if (str[i]>=0x30 && str[i]<=0x3a)
video_putchar(x,y,str[i]-0x30);
else video_putchar(x,y,str[i]-0x40+9);
x = x+6;
end
end
     
//==================================
// put a small character on the screen
// x-cood must be on divisible by 4
// c is index into bitmap
void video_smallchar(char x, char y, char c) 
begin
char mask;
i=((int)x>>3) + ((int)y<<4) ;
if (x == (x & 0xf8)) mask = 0x0f;     //f8
else mask = 0xf0;

screen[i] =    (screen[i] & mask) | (smallbitmap[c][0] & ~mask);
   screen[i+16] = (screen[i+16] & mask) | (smallbitmap[c][1] & ~mask);
        screen[i+32] = (screen[i+32] & mask) | (smallbitmap[c][2] & ~mask);
        screen[i+48] = (screen[i+48] & mask) | (smallbitmap[c][3] & ~mask);
   screen[i+64] = (screen[i+64] & mask) | (smallbitmap[c][4] & ~mask);
end 

//==================================
// put a string of small characters on the screen
// x-cood must be on divisible by 4
void video_putsmalls(char x, char y, char *str)
begin
char i ;
for (i=0; str[i]!=0; i++)
begin 
if (str[i]>=0x30 && str[i]<=0x3a)
video_smallchar(x,y,str[i]-0x30);
else video_smallchar(x,y,str[i]-0x40+12);
x = x+4;
end
end
      
//==================================
//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(char x1, char y1, char x2, char y2, char c)
begin  
int e;
signed char dx,dy,j, temp;
signed char s1,s2, xchange;
        signed char x,y;
       
x = x1;
y = y1;
dx = cabs(x2-x1);
dy = cabs(y2-y1);
s1 = csign(x2-x1);
s2 = csign(y2-y1);
xchange = 0;  
if (dy>dx)
begin
temp = dx;
dx = dy;
dy = temp;
xchange = 1;
end
e = ((int)dy<<1) - dx;  
for (j=0; j<=dx; j++)
begin
video_pt(x,y,c) ;
if (e>=0)
begin
if (xchange==1) x = x + s1;
else y = y + s2;
e = e - ((int)dx<<1);
end
if (xchange==1) y = y + s2;
else x = x + s1;
e = e + ((int)dy<<1);
end
end

//==================================
//return the value of one point
//at x,y with color 1=white 0=black 2=invert
char video_set(char x, char y)
begin
//The following construction
  //detects exactly one bit at the x,y location
i=((int)x>>3) + ((int)y<<4) ; 
    return ( screen[i] & 1<<(7-(x & 0x7)));  
end
 
//===simulation stuff=========================================
//animation
int x, y, vx, vy, g, drag;

//char cu1[]="CORNELL";
//char cu2[]="ECE476";
char title[]="CONNECT4"; 
char playertitle[]="PLAYER";
char turn1[]="1";
char turn2[]="2";
char wintext[]="WINS";

char tally=0;


#define mfix(a,b) ((int)((((long)(a))*((long)(b)))>>8))
//==================================
// set up the ports and timers
void main(void)
begin

  initialize();
 
  //The following loop executes once/video line during lines
  //1-230, then does all of the frame-end processing
  while(1)
  begin
 
    //stall here until next line starts
    //sleep enable; mode=idle 
    //use sleep to make entry into sync ISR uniform time 
    
    #asm ("sleep");
   
    //The following code executes during the vertical blanking
    //Code here can be as long as 
    //a total of 60 lines x 63.5 uSec/line x 8 cycles/uSec
   
    if (LineCount==231)
    begin              
          
 
 if (win==0)
 {
 
         col = PINC - 1;
         if(player==2)
         col=col-0x0B;
        
        //find empty row. if none, let row==9
for(row=0; row<8 && grid[row][col]!=0 ;row++)
{}

//if empty row exists, draw and inform next player
if (col<9 && col >=0 && row<8)
{
grid[row][col]=player;
    video_putchar(col*12+12,(8-row)*10+11,37+player);
    if (player==1)
    {
    player=2;
    displayplayer(2);
    }
    else
    {
    player=1;
    displayplayer(1);
    }
   
   
   
   
    temp=grid[row][col];
   
    //test for direction (/)
    tally1=0;
    tally2=0;
    for(a=row,b=col;;a++,b++)
    {
tally1++;
if(a==7 || b==8 || grid[a][b]!=temp) break;

   
    }
    if(grid[a][b]!=temp)tally1--;
    for(a=row,b=col;;a--,b--)
    {
tally2++;
if(a==0 || b==0 || grid[a][b]!=temp) break;

   
    }
    if(grid[a][b]!=temp)tally2--;
            if(tally1+tally2-1>=4)win=1;


    //test for direction (\)
    tally1=0;
    tally2=0;
    for(a=row,b=col;;a++,b--)
    {
tally1++;
if(a==7 || b==0 || grid[a][b]!=temp) break;

   
    }
    if(grid[a][b]!=temp)tally1--;
    for(a=row,b=col;;a--,b++)
    {
tally2++;
if(a==0 || b==8 || grid[a][b]!=temp) break;

   
    }
    if(grid[a][b]!=temp)tally2--;
            if(tally1+tally2-1>=4)win=1;


    //test for direction (-)
    tally1=0;
    tally2=0;
    a=row;
    for(b=col;;b++)
    {
tally1++;
if(b==8 || grid[a][b]!=temp) break;

   
    }
    if(grid[a][b]!=temp)tally1--;
    for(b=col;;b--)
    {
tally2++;
if(b==0 || grid[a][b]!=temp) break;

   
    }
    if(grid[a][b]!=temp)tally2--;
            if(tally1+tally2-1>=4)win=1;

           
    //test for direction (|)
    tally1=0;
    tally2=0;
    b=col;
    for(a=row;;a--)
    {
tally1++;
if(a==0 || grid[a][b]!=temp) break;

   
    }
    if(grid[a][b]!=temp)tally1--;
            if(tally1>=4)win=1;








}
       
//communicate with IR decoder MCU
//--if button received, indicate by A.1=1
//--if no button given, indicate by A.1=0
        if (PINC==0x00)
        {
            PORTA=0x00;
           
        }   
        else          
        {
        PORTA=0x01;
       
    }

   
 }  
 else
{   

  if(erasescreen<=126)
{
video_line(erasescreen, 0, erasescreen, 99, 0);
}                  
else if (erasescreen==127)
{
video_line(j, 25, j, 55, 0);
video_puts(38,30,playertitle);
if(player==1)
{
video_puts(78,30,turn2);
//player=2;
}

if(player==2)
{
video_puts(78,30,turn1);
//player=1;
}
video_puts(48,40,wintext);

}
else if(erasescreen>=300 && erasescreen<=426)
{
video_line(erasescreen-300, 0, erasescreen-300, 99, 0);
}
else if (erasescreen==476)
{
win=0;
initscreen();
erasescreen=0-1;
displayplayer(player);
                }

erasescreen++;


}   
   
   
   
                        
     end  //line 231
  end  //while
end  //main

//used for diplaying number for player with having turn
void displayplayer(char p)
{               
if(p==1)
video_puts(115,2,turn1);

if(p==2)
video_puts(115,2,turn2);

}
                        
//Checks for 4 in a row, dir refers direction to check,
// clockwise, starting from 12 O'clock position
char check(char row, char col, char dir)
{







}



void initscreen()
{
    //Print "CONNECT4"
  video_puts(5,2,title);
  //Print "PLAYER"
  video_puts(75,2,playertitle);
  displayplayer(player); 
 
  //side lines
  #define width 126
  video_line(0,0,0,99,1);
  video_line(width,0,width,99,1);
 
  //top line & bottom lines
  video_line(0,0,width,0,1);
  video_line(0,99,width,99,1);
  video_line(0,10,width,10,1);   
 
  //Label column
  for(j=0;j<9;j++)
  {
  video_smallchar(12+j*12,top+3,j+1);
  }
 
  //Draw grid
  //vertical lines
  video_line(left,top,left,bot,1);
  video_line(left+12,top,left+12,bot,1);
  video_line(left+24,top,left+24,bot,1); 
  video_line(left+36,top,left+36,bot,1);
  video_line(left+48,top,left+48,bot,1);
  video_line(left+60,top,left+60,bot,1);
  video_line(left+72,top,left+72,bot,1);
  video_line(left+84,top,left+84,bot,1);
  video_line(left+96,top,left+96,bot,1);
  video_line(left+108,top,left+108,bot,1);


  //horizontal lines
  video_line(left,top+10-1,left+108,top+10-1,1);
  video_line(left,top+20-1,left+108,top+20-1,1);
  video_line(left,top+30-1,left+108,top+30-1,1);
  video_line(left,top+40-1,left+108,top+40-1,1);
  video_line(left,top+50-1,left+108,top+50-1,1);
  video_line(left,top+60-1,left+108,top+60-1,1);
  video_line(left,top+70-1,left+108,top+70-1,1);
  video_line(left,top+80-1,left+108,top+80-1,1);

  //initialize grid
  for(j=0;j<8;j++)
  for(k=0;k<9;k++)
grid[j][k]=0; 
   
  for(j=7;j>=0;j--)
  for(k=0;k<9;k++)
{
if(grid[j][k]==1)
{ //video_putchar(j*12+12,k*10+11,39);
video_putchar(k*12+12,(8-j)*10+11,39);
        }

if(grid[j][k]==2)
{ //video_putchar(j*12+12,k*10+11,38);
video_putchar(k*12+12,(8-j)*10+11,38);
}
  }
}







void initialize()
{
  //init timer 1 to generate sync
  OCR1A = lineTime; //One NTSC line
  TCCR1B = 9; //full speed; clear-on-match
  TCCR1A = 0x00; //turn off pwm and oc lines
  TIMSK = 0x10; //enable interrupt T1 cmp
 
  //init ports
  DDRD = 0xf0; //video out and switches
  DDRA = 0xFF;
  DDRC = 0x00;
  PORTA=0x00;
 
  //D.5 is sync:1000 ohm + diode to 75 ohm resistor
  //D.6 is video:330 ohm + diode to 75 ohm resistor
 
  //initialize synch constants
  LineCount = 1;
  syncON = 0b00000000;
  syncOFF = 0b00100000; 
 
  initscreen();
 
  //enable sleep mode
  MCUCR = 0b10000000;
  #asm ("sei");


}