#ifndef F_CPU
/// @brief Die Geschwindigkeit des Mikrocontroller in Hertz, für _delay_ms von Bedeutung
#define F_CPU 1000000UL
#endif

/// @brief Dieser Pin wird als Clock-Signal für die seriellen Daten am 74HC595 benutzt
#define SCK PB4
/// @brief Dieser Pin wird als Clock-Signal zum Schalten der internen Register an die Output-Pins des 74HC595 benutzt
#define OCK PB3
/// @brief Dieser Pin wird zur Übertragung der seriellen Daten zum 74HC595 benutzt
#define DS PB1

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <inttypes.h>
#include <stdlib.h>

/**
 * @file pms_tiny.c
 * @brief Diese Datei enth&auml;lt das gesamte Programm/Spiel für den Mikrocontroller
 */

void clock_serial();
void clock_output();
void shift_high();
void shift_low();
void output(volatile uint8_t*,uint8_t);
void matrix_output();
void matrix_screen_pixel(uint32_t);

void adc_init();
void get_adcval(uint16_t *);
uint8_t getkey();

void timer_init();

void clear_screen();
void start_game();
void game_failed();
void output_game();
void cursor_a_down();
void cursor_a_up();
void cursor_b_down();
void cursor_b_up();

void next_r_ball();
void check_ball_pos();
uint8_t check_ball_coll();

///@brief Diese Variable enth&auml;lt einen freundlichen Smiley zur Ausgabe auf der Punktmatrix
volatile uint8_t friendly_sm[5] PROGMEM = {0x0C,0x12,0x0,0x12,0x0};
///@brief Diese Variable enth&auml;lt einen freundlichen Smiley zur Ausgabe auf der Punktmatrix
volatile uint8_t unfriendly_sm[5] PROGMEM = {0x12,0x0C,0x0,0x12,0x0};
///@brief Diese Variable enth&auml;lt einen das Alphabet und alle Ziffern zur Ausgabe auf der Punktmatrix
volatile uint8_t ansi[37][5] PROGMEM = {
                {0x12,0x12,0x1E,0x12,0x0C}, //A
                {0x0E,0x12,0x0E,0x12,0x0E}, //B
                {0x0C,0x02,0x02,0x02,0x0C}, //C
                {0x0E,0x12,0x12,0x12,0x0E}, //D
                {0x0E,0x02,0x0E,0x02,0x0E}, //E
                {0x0E,0x02,0x0E,0x02,0x02}, //F
                {0x1C,0x12,0x1A,0x02,0x1C}, //G
                {0x12,0x12,0x1E,0x12,0x12}, //H
                {0x0E,0x04,0x04,0x04,0x0E}, //I
                {0x06,0x08,0x08,0x08,0x0E}, //J
                {0x12,0x0A,0x06,0x0A,0x12}, //K
                {0x0E,0x02,0x02,0x02,0x02}, //L
                {0x12,0x12,0x12,0x1E,0x12}, //M
                {0x22,0x32,0x2A,0x26,0x22}, //N
                {0x0C,0x12,0x12,0x12,0x0C}, //O
                {0x04,0x04,0x1C,0x14,0x0C}, //P
                {0x14,0x0A,0x12,0x12,0x0C}, //Q
                {0x14,0x14,0x0C,0x14,0x0C}, //R
                {0x1C,0x10,0x08,0x04,0x1C}, //S
                {0x08,0x08,0x08,0x08,0x1C}, //T
                {0x1C,0x14,0x14,0x14,0x14}, //U
                {0x08,0x14,0x14,0x14,0x14}, //V
                {0x14,0x2A,0x2A,0x22,0x22}, //W
                {0x22,0x14,0x08,0x14,0x22}, //X
                {0x08,0x08,0x08,0x14,0x22}, //Y
                {0x1E,0x04,0x08,0x10,0x1E}, //Z
                {0x0E,0x0A,0x0A,0x0A,0x0E}, //0
                {0x1C,0x08,0x08,0x0C,0x08}, //1
                {0x1E,0x04,0x08,0x12,0x0C}, //2
                {0x0C,0x12,0x08,0x10,0x1E}, //3
                {0x08,0x08,0x0E,0x0A,0x0A}, //4
                {0x0E,0x08,0x0E,0x02,0x0E}, //5
                {0x0E,0x0A,0x0E,0x02,0x0E}, //6
                {0x08,0x08,0x0A,0x0A,0x0E}, //7
                {0x0E,0x0A,0x0E,0x0A,0x0E}, //8
                {0x0E,0x08,0x0E,0x0A,0x0E}, //9
                {0x00,0x40,0x00,0x40,0x00}}; //:


///@brief Diese Variable enth&auml;lt den Cursor des Spielers A. Diese Variable wird ebenfalls zur Kollisionsüberprüfung benutzt.
volatile uint8_t cursor_a[5] = {0x0,0x1,0x1,0x0,0x0};
///@brief Diese Variable enth&auml;lt den Cursor des Spielers B. Diese Variable wird ebenfalls zur Kollisionsüberprüfung benutzt.
volatile uint8_t cursor_b[5] = {0x0,0x00,0x40,0x40,0x00};
///@brief Diese Variable enth&auml;lt den Spielball. Diese Variable wird ebenfalls zur Kollisionsüberprüfung benutzt.
volatile uint8_t ball[5] = {0x0,0x0,0x4,0x0,0x0};

///@brief Diese Variable enth&auml;lten den Video-Buffer für die linke Punktmatrix. Dieser Buffer wird auf der Punktmatrix ausgegeben
volatile uint8_t screen_buffer_first[5];
///@brief Diese Variable enth&auml;lten den Video-Buffer für die rechte Punktmatrix. Dieser Buffer wird auf der Punktmatrix ausgegeben
volatile uint8_t screen_buffer_second[5];

///@brief Diese Variable gibt an, in welche Richtung der Ball steuert. 0 = links, 1 = rechts
volatile uint8_t ball_dir = 0;
///@brief Diese Variable enth&auml;lt eine Zeitverzögerung für die Spielzyklen, damit das Spiel in angenehmer Zeit abläuft. Alle 100 Zählungen, ein Zyklus
volatile uint32_t ball_timer = 0;
///@brief Diese Variable gibt an, ob das Spiel derzeit läuft, oder nicht. 0 = läuft nicht, 1 = läuft
volatile uint8_t game_running = 0;
///@brief Diese Variable gibt an, ob der Ball an einem Rand das Spielfeld verlassen hat. 1 = rechter Rand, 2 = linker Rand
uint8_t game_failed_var = 0x0;
///@brief Diese Variable enth&auml;lt den Spielstand für den Spieler A
uint8_t points_a = 0;
///@brief Diese Variable enth&auml;lt den Spielstand für den Spieler B
uint8_t points_b = 0;

///////////////////////////////////////////////////////////
/**
 * @brief Diese Funktion ist der Einsprungspunkt des Programmes und nimmt alle nötigen Initialisierungen vor
 *
 * Zunächst werden die Pins PB0 (KontrollLED), PB1 (serielle Daten), PB3 (Datenausgabe-Clock) und PB4 (serielle Daten-Clock) auf Ausgang gesetzt,
 * damit man dessen Zustände setzen kann. Danach wird der ADC initialisiert, welcher zum Einlesen der Tasten benötigt wird. Als nächster wird
 * der Timer initialisert, welcher regelmäßig einen Interrupt auslöst, welcher sich dann um die Ausgabe und die Spielzyklen kümmert. Mit der
 * Funktion start_game() werden da die Spieldaten initialisiert und das Spiel gestartet. In der unendlichen Schleife wird für eine bestimmte
 * kurze Zeitdauer abgefragt, ob eine Taste gedrückt wurde. Danach wird überprüft, ob der Ball das Spielfeld inzwischen verlassen hat, wenn nicht
 * wird überprüft, welche Taste gedrückt wurde. Je nach Taste wird die dazu gehörige Funktion ausgeführt. Danach beginnt die Schleife wieder von
 * vorne.
 * @return Der Rückgabewert ist 0, dieser wird jedoch nie erreicht.
 */

int main() {
  uint8_t key = 0;
  DDRB = (1 << PB0) | (1 << PB1)| (1 << PB3) | (1 << PB4);

  adc_init();
  timer_init();
  sei();

  start_game();

  while(1) {
   key = getkey();
   srand(ball_timer);
   if(game_failed_var != 0) game_failed();
   if(key == 1) cursor_a_down();
   if(key == 2) cursor_a_up();
   if(key == 3) cursor_b_down();
   if(key == 4) cursor_b_up();
  }
return 0;
}

///////////////////////////////////////////////////////////
/**
 * @brief Diese Funktion kümmert sich um eine HIGH-LOW-Taktflanke bei dem Clockeingang für die seriellen Daten des 74HC595
 *
 * Dabei wird der dafür benutzte Pin PB4 auf High und danach wieder auf Low gesetzt, indem das entsprechende Bit im PORTB gesetzt und wieder
 * gelöscht wird. Dadurch wird erreicht, dass alle Zustände der internen Register einen Platz weiterrücken (shift) und im ersten Register
 * der anliegende Zustand am seriellen Dateneingang des 74HC595 übernommen wird.
 */

void clock_serial() {
  PORTB |= (1 << SCK);
  PORTB &= ~(1 << SCK);
}

///////////////////////////////////////////////////////////
/**
 * @brief Diese Funktion kümmert sich um eine HIGH-LOW-Taktflanke bei dem Clockeingang des Output der internen Register des 74HC595
 *
 * Dabei wird der dafür benutzte Pin PB3 auf High und danach wieder auf Low gesetzt, indem das entsprechende Bit im PORTB gesetzt und wieder
 * gelöscht wird. Dadurch werden die Zustände der internen Register des 74HC595 auf die Output-Pins gelegt.
 */

void clock_output() {
  PORTB |= (1 << OCK);
  PORTB &= ~(1 << OCK);
}

///////////////////////////////////////////////////////////
/**
 * @brief Diese Funktion schiebt einen HIGH-Zustand in den 74HC595
 *
 * Dabei wird der serielle Datenpin PB1 auf HIGH gesetzt und ein Shift auf dem 74HC595 vollzogen.
 */

void shift_high() {
  PORTB |= (1 << DS);
  clock_serial();
}

///////////////////////////////////////////////////////////
/**
 * @brief Diese Funktion schiebt einen LOW-Zustand in den 74HC595
 *
 * Dabei wird der serielle Datenpin PB1 auf LOW gesetzt und ein Shift auf dem 74HC595 vollzogen.
 */

void shift_low() {
  PORTB &= ~(1 << DS);
  clock_serial();
}

///////////////////////////////////////////////////////////
/**
 * @brief Diese Funktion gibt den übergebenen 5 x 8 Bit großen Speicherbereich aus
 *
 * Dabei wird der  5 x 8 Bit großen Speicherbereich Byte für Byte in den screen_buffer_second kopiert. Der Screen-Buffer enthält die Ausgaben
 * auf der Punktmatrix und wird mit jedem Timer-Interrupt ausgegeben.
 * @param in Dieser Parameter ist der Pointer, der auf den 5 x 8 Bit großen Speicherbereich zeigt
 */

void output(volatile uint8_t* in, uint8_t screen) {
 uint8_t i = 0;
 if(screen == 1) { for(i = 0; i < 5; i++) screen_buffer_first[i] = in[i]; }
 if(screen == 2) { for(i = 0; i < 5; i++) screen_buffer_second[i] = in[i]; }
}

///////////////////////////////////////////////////////////
/**
 * @brief
 *
 *
 */

void matrix_output() {
  uint8_t k,i,j,col,row = 0;
  uint32_t out = 0;

  for(k = 0; k < 2; k++){ //Für beide Punktmatrix
    for(i = 0; i < 5; i++) { //Jede Spalte muss auf Punkte überprüft werden
      if(k == 0) row = screen_buffer_second[i]; //Erst die rechte Punktmatrix
      else row = screen_buffer_first[i]; //Dann die linke Punktmatrix
      for(j = 0; j < 7; j++) { //Dann wird jede Zeile auf ein Punkt überprüft
        if(row & 0x01) { //Wurde einer gefunden,
          out = (1 << j); //muss die jeweilige Zeile aktiviert werden
          out <<=5; //(Die Zeilen stehen in der Ausgabe 5 Bits weiter
          out |= (1 << i); //und es muss die jeweilige Spalte aktiviert werden
          out <<=1; //Welche erst ab Bit 1 anfangen
          if(k == 1) out <<= 16; //Für den linken Bildschirm muss das Ganze 16 Bits verschoben werden (aufgrund der Schieberegister)
          matrix_screen_pixel(out);
        }
        row >>=1; // Das nächste Bit wird überprüft
      }
    }
  }
}

///////////////////////////////////////////////////////////
/**
 * @brief
 *
 *
 */

void matrix_screen_pixel(uint32_t input) {
  uint8_t i = 0;

    for(i = 0; i < 32; i++) {
    if((i < 26 && i > 16) || (i < 10)) {
      if(input & 0x80000000) shift_low();
      else shift_high();
    }
    else {
      if(input & 0x80000000) shift_high();
      else shift_low();
    }
    input <<= 1;
    }
    clock_output();

  PORTB &= ~(1 << DS);
  PORTB &= ~(1 << SCK);
  PORTB &= ~(1 << OCK);

}

///////////////////////////////////////////////////////////
/**
 * @brief Diese Funktion initialisiert den ADC (Analog to Digtial Converter) mit Werten
 *
 * Dabei wird zunächst eine trash-Variable (Müll-Variable, d.h diese Variable wird mit unsinnigen Daten belegt) angelegt, da der ADC am Ende der
 * Initialisierung einen Wert auslesen lassen muss, bevor dieser korrekt funktioniert. Als nächstes wird im Register ADMUX das Bit MUX0 gesetzt,
 * welches bedeutet, das Analog-Daten für die ADC-Konvertierungen aus dem Pin PB2 gelesen werden sollen. Im nächsten Schritt wird im Register
 * DIDR0 das Bit ADC0D gesetzt, womit angewiesen wird, dass aus dem Pin PB2 keine digitalen Daten mehr gelesen werden müssen. Das Register
 * ADCSRA wird mit den Bits ADPS1 und ADPS0 belegt, womit erreicht wird, dass der ADC einen Prescaler von 8 besitzt. Da dieser AVR Atmel Attiny45
 * mit einem Megahertz betrieben wird, wird mit dem Prescaler erreicht, dass die Frequenzahl im Bereich zwischen 50kHz und 200kHz liegt (Hier:
 * 125kHz). Dies wird benötigt, damit der ADC mit genauer Auflösung arbeiten kann. Das Bit ADEN wird gesetzt, damit der ADC angeschaltet wird.
 * Damit startet jedoch noch keine Konvertierung. Im letzten Schritt wird ein ADC-Wert ausgelesen, danach ist der ADC vollständig einsatzbereit.
 */

void adc_init() {
    uint16_t trash;
    ADMUX =  (1 << MUX0); //PB2
    DIDR0 |= (1<<ADC0D); //PB2  (ADC0)
    ADCSRA = (1 << ADPS1) | (1 << ADPS0) | (1 << ADEN); //Division 8
    get_adcval(&trash); //First Conversion
}

///////////////////////////////////////////////////////////
/**
 * @brief Diese Funktion startet den ADC (Analog to Digital Converter)
 *
 * Dabei wird das ADSC Bit im Zustandsregister ADCSRA gesetzt, womit eine ADC-Konvertierung gestartet wird.
 */

void adc_start() {
    ADCSRA |= (1 << ADSC);
}

///////////////////////////////////////////////////////////
/**
 * @brief Diese Funktion liest einen ADC-Wert aus und schreibt diesen in den angegeben 16-Bit-Buffer
 *
 * Dabei wird zunächst mit adc_start() eine ADC-Konvertierung gestartet. Danach wird solange eine Schleife durchlaufen, bis das Bit ADSC im Register
 * ADCSRA nicht mehr gesetzt ist. Ist dies der Fall, bedeutet es, dass die Konvertierung abgeschlossen ist. Danach wird der ausgelesene Wert in
 * den angegebenen 16-Bit-Buffer geschrieben.
 * @param val Dieser Parameter enthält die Adresse des 16-Bit-Buffer, in dem der ausgelesene ADC-Wert gespeichert werden soll
 */

void get_adcval(uint16_t *val) {
  adc_start();
  while(ADCSRA & (1 << ADSC));
  *val = ADCW;
}

///////////////////////////////////////////////////////////
/**
 * @brief Diese Funktion wartet auf eine Tasteneingabe
 *
 * Dabei wird der an dem Pin 2 angelegten Spannungswert über die get_adcval-Funktion ausgelesen. Handelt es sich um einen in Referenz zu 5V
 * angelegten Wert von 50 oder weniger, ist die Taste 4 gedrückt worden. Zwischen 51 und 280 liegt die Taste 3, die Taste 2 hat einen Wertebereich
 * von 281 bis 540. Die Taste 1 ist gedrückt worden, wenn der Wert 790 bis 1023 beträgt. Alles über diesen Werte ist keine angeschlossene Taste.
 * Wurde nach zehn Auslese- und Verarbeitungsvorgängen keine gültige Taste gedrückt oder wurde eine Taste gedrückt, wird die Schleife beendet und
 * die angegebene Taste zurückgegeben. Bei keiner gültigen Taste wird 0 zurückgegeben.
 * @return Der Rückgabewert ist die gedrückte Taste
 */

uint8_t getkey() {
  uint8_t key = 0;
  uint16_t adc_wert = 0;
  uint16_t zaehl = 0;
  while(1) {
    get_adcval(&adc_wert);
    zaehl++;
    if(adc_wert <= 50) { //Taste 4 von links
        key = 4;
        break;
    }
    else if(adc_wert <= 280 ) { //Taste 3 von links
        key = 3;
        break;
    }
    else if(adc_wert <= 540) { //Taste 2 von links
        key = 2;
        break;
    }// bis hier
    else if (adc_wert <= 790){ //Taste 1 von links
        key = 1;
        break;
    }

    else if(adc_wert <= 1024) { //keine Taste
        key = 0;
    }
    if(zaehl >= 10) break;
 }
 return key;
}

///////////////////////////////////////////////////////////
/**
 * @brief In dieser Funktion wird der Timer initialisiert
 *
 * Dabei wird zunächst mit dem TOIE0-Bit im TIMSK-Register erreicht, dass bei einem Timer-Overflow Interrupts ausgelöst werden. Mit dem
 * CS01-Bit im TCCR0B-Register wird der Prescaler auf 8 gesetzt, sodass nur bei jedem achten Taktzyklus der Timer inkrementiert. Mit dem Wert
 * 0x0 im TCNT0-Register wird der Startwert des Timer0 gesetzt.
 */

void timer_init() {
  TIMSK |= (1 << TOIE0);
  TCCR0B |= (1 << CS01); //Prescaler 8
  TCNT0 = 0x0;  //Startwert 1
}

///////////////////////////////////////////////////////////
/**
 * @brief Diese Funktion bildet die anzuspringende Interrupt-Funktion bei einem Timer0-Overflow
 *
 * Während dieser Funktion werden verschiedene Aufgaben erledigt. Zum einem wird die Bildschirmausgabe aktualisiert, solange das Spiel
 * am Laufen ist, zum anderen aktualisiert diese Funktion bei allen hundert Timer0-Overflows die Ballposition.
 * @param TIMER0_OVF_vect Dieser Parameter gibt den Typ des Interrupt an, bei dem diese Funktion angesprungen werden soll
 */

ISR(TIMER0_OVF_vect) { //Bildschirmausgabe
  if(game_running) output_game();
  matrix_output();
  ball_timer++;
  if(ball_timer >= 100) {
    ball_timer = 0;
    next_r_ball();
  }
}

///////////////////////////////////////////////////////////
/**
 * @brief Diese Funktion dient zur Löschung der Punktmatrix
 *
 * Dabei wird der screen_buffer_second, der als Ausgabebereich für die Punktmatrix definiert ist, mit 0x0 überschrieben.
 */

void clear_screen() {
  uint8_t i = 0;
  for(i = 0; i < 5; i++) screen_buffer_second[i]= 0x0;
  for(i = 0; i < 5; i++) screen_buffer_first[i] = 0x0;
}

///////////////////////////////////////////////////////////
/**
 * @brief
 *
 *
 */

void start_game() {
  uint8_t i = 0;
  game_failed_var = 0x0;
  for(i = 0; i < 5; i++) cursor_a[i] = 0x0;
  for(i = 0; i < 5; i++) cursor_b[i] = 0x0;
  cursor_a[1] = 0x1;
  cursor_a[2] = 0x1;
  cursor_b[2] = 0x40;
  cursor_b[3] = 0x40;
  for(i = 0; i < 5; i++) ball[i]= 0x0;
  ball[2]= 0x4;
  ball_dir = 0;
  game_running = 1;
  output_game();
}

///////////////////////////////////////////////////////////
/**
 * @brief
 *
 *
 */

void output_game() {
  uint8_t i = 0;
  clear_screen();

  for(i = 0; i < 5; i++) screen_buffer_second[i]|= cursor_a[i];
  for(i = 0; i < 5; i++) screen_buffer_second[i] |= cursor_b[i];
  for(i = 0; i < 5; i++) screen_buffer_second[i] |= ball[i];
}

///////////////////////////////////////////////////////////
/**
 * @brief
 *
 *
 */

void cursor_a_down() {
 uint8_t i = 0;
 if(cursor_a[0]== 0x01) return;
 else {
  for(i = 0; i < 4; i++) cursor_a[i]= cursor_a[i+1];
  cursor_a[4] = 0x0;
 }
}

///////////////////////////////////////////////////////////
/**
 * @brief
 *
 *
 */

void cursor_a_up() {
 uint8_t i = 0;
 if(cursor_a[4]== 0x01) return;
 else {
  for(i = 4; i > 0; i--) cursor_a[i]= cursor_a[i-1];
  cursor_a[0]= 0x0;
 }
}

///////////////////////////////////////////////////////////

void cursor_b_down() {
 uint8_t i = 0;
 if(cursor_b[0] == 0x40) return;
 else {
  for(i = 0; i < 4; i++) cursor_b[i]= cursor_b[i+1];
  cursor_b[4] = 0x0;
 }
}

///////////////////////////////////////////////////////////
/**
 * @brief
 *
 *
 */

void cursor_b_up() {
 uint8_t i = 0;
 if(cursor_b[4] == 0x40) return;
 else {
  for(i = 4; i > 0; i--) cursor_b[i] = cursor_b[i-1];
  cursor_b[0] = 0x0;
 }
}

///////////////////////////////////////////////////////////
/**
 * @brief
 *
 *
 */

void next_r_ball() {
  uint8_t col = 0;
  uint8_t i = 0;

  i = check_ball_coll();


  if(i != 0) {
      if(i % 2) {  //Rechte Seite aufgeschlagen
    i = rand() % 4;
    if(i == 1) i = 0;
      }
      else {    //Linke Seite aufgeschlagen
    i = rand() % 4;
    if(i == 0) i = 1;
    else i += 2;
      }
        ball_dir = i;
  }

  for(i = 0; i < 5; i++) { if(ball[i] != 0) col = i; }

  switch(ball_dir) {

    case 0x0: //links
      ball[col] <<= 1;
      break;
    case 0x1: //rechts
      ball[col] >>= 1;
      break;
    case 0x2: //links-hoch

      if(col == 4) { ball_dir = 3; break; }
      ball[col+1] = ball[col] << 1;
      ball[col] = 0x0;
      break;
    case 0x3: //links-runter
      if(col == 0) { ball_dir = 2; break; }
      ball[col-1] = ball[col] << 1;
      ball[col] = 0x0;
      break;
    case 0x4: //rechts-hoch
      if(col == 4) { ball_dir = 5; break; }
      ball[col+1] = ball[col] >> 1;
      ball[col] = 0x0;
      break;
    case 0x5: //rechts-runter
      if(col == 0) { ball_dir = 4; break; }
      ball[col-1] = ball[col] >> 1;
      ball[col] = 0x0;
      break;
    default:
      break;

  }
}


///////////////////////////////////////////////////////////
/**
 * @brief
 *
 *
 */

uint8_t check_ball_coll() {
  uint8_t temp_coll[5] = {0x0,0x0,0x0,0x0,0x0};
  uint8_t col = 0;
  uint8_t i = 0;
  uint8_t col_point = 0;

  for(i = 0; i < 5; i++) temp_coll[i] |= cursor_a[i];
  for(i = 0; i < 5; i++) temp_coll[i] |= cursor_b[i];

  for(i = 0; i < 5; i++) { if(ball[i] != 0) col = i; }

  if( (temp_coll[col] << 1 ) & ball[col] && col == 2) col_point = 1; //Rechte Seite
  if( (temp_coll[col] >> 1 ) & ball[col] && col == 2) col_point = 2; //Linke Seite
  if( (temp_coll[col] << 1 ) & ball[col] && col < 2) col_point = 3;
  if( (temp_coll[col] >> 1 ) & ball[col] && col > 2) col_point = 4;
  if( (temp_coll[col] << 1 ) & ball[col] && col < 2) col_point = 5;
  if( (temp_coll[col] >> 1 ) & ball[col] && col > 2) col_point = 6;


  if(ball[col] == 0x80) game_failed_var = 0x1; // Bei B-Spieler raus
  if(ball[col] == 0x0)  game_failed_var = 0x2; //Bei A-Spieler raus
  if(ball[col] != 0x80 && ball[col] != 0x0) game_failed_var = 0x0;
  return col_point;
}


///////////////////////////////////////////////////////////
/**
 * @brief
 *
 *
 */

void game_failed() {
  uint8_t temp_show[5] = {0,0,0,0,0};
  uint8_t i = 0;

  game_running = 0;
  clear_screen();

  for(i = 0; i < 5; i++) temp_show[i] = pgm_read_byte(&unfriendly_sm[i]);
  output(temp_show,2);
  _delay_ms(1);
  clear_screen();

  if(game_failed_var == 2) { //B hat ein Punkt gemacht
    for(i = 0; i < 5; i++) temp_show[i] = pgm_read_byte(&ansi[0][i]);
    points_b++;
  }
  else if(game_failed_var == 1) { //A hat ein Punkt gemacht
    for(i = 0; i < 5; i++) temp_show[i] = pgm_read_byte(&ansi[1][i]);
    points_a++;
  }
  output(temp_show,2);
  _delay_ms(1);

  clear_screen();
  for(i = 0; i < 5; i++) temp_show[i] = pgm_read_byte(&ansi[26+points_a][i]);
  for(i = 0; i < 5; i++) temp_show[i] |= pgm_read_byte(&ansi[36][i]);
  output(temp_show,1);
  for(i = 0; i < 5; i++) temp_show[i] = pgm_read_byte(&ansi[26+points_b][i]);
  output(temp_show,2);

   _delay_us(300);
  start_game();

}