/*
* SpaceInvaders.c
*
* Created: 22.05.2014 16:26:08
*  Author: Ehlers
*/


#define F_CPU 1000000UL

/* ---------------------------------------------- */
// Includes
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>
#include <stdlib.h>
#include "avrx.h"
#include "avrxfifo.h"
#include "avrx-io.h"
#include "avrx-signal.h"
#include "hardware.h"
#include "lcd.h"

/* ---------------------------------------------- */
// Definitionen
#define NUMBER_ALIEN_SPECIES 4
#define SYMBOL_SPACESHIP 1
#define SYMBOL_SPACESHIP_FIRE 2
#define SYMBOL_EXPLOSION 3
#define SYMBOL_MISS 4

/* ---------------------------------------------- */
// Globale Variablen
// Position des Aliens in der erste Reihe
uint8_t alienPosition;
// Spezies des Aliens
uint8_t alienSpecies = 5;
// Position des Raumschiffes in der zweiten Reihe
uint8_t spaceshipPosition = 0;
// Fehlschuesse
uint8_t spaceshipRemainingEnergie;
// Punkte des Raumschiffes
uint8_t spaceshipPoints = 0;
// Spielzeit
uint8_t playTime = 60;
// Variablen zur Spielsteuerung
uint8_t gameEnd = 1;
uint8_t fire = 0;
uint8_t alienBlocked = 0;

/* ---------------------------------------------- */
// semaphoreData: Mutual exclusion der globalen Variablen
AVRX_MUTEX(semaphoreData);
// semaphoreStart: Start des Spiels
AVRX_MUTEX(semaphoreStart);

/* ---------------------------------------------- */
// Deklaration der Timer (Ein Timer kann nicht in mehreren Prozessen/Tasks genutzt werden)
TimerControlBlock TickTimerClock;
TimerControlBlock TickTimerAlien;
TimerControlBlock TickTimerSpaceship;
TimerControlBlock TickTimerButton;
TimerControlBlock TickTimerLCD;

/* ---------------------------------------------- */
// Deklaration der Nachrichten und der MessageQueue
MessageControlBlock UpdateDisplay;
MessageQueue LcdQueue;

/* ---------------------------------------------- */
// AD-Wandlung
uint16_t adc_read()
{
	// AD-Wandlung starten
	ADCSRA |= (1<<ADSC);
	// auf Abschluss der Konvertierung warten
	while (ADCSRA & (1<<ADSC));
	// Ergebnis auslesen, umrechnen in Bereich 0-14 und zurückgeben
	return ADCW;
}

/* ---------------------------------------------- */
// Initialisierung des AD Wandlers
void adc_init()
{
	// PINA0 als Eingang festlegen
	DDRA &= ~1;
	// Vcc als Referenzspannung
	ADMUX = (1<<REFS0);
	// Aktivieren und Pre-Scaler auf 128
	ADCSRA = (1<<ADEN) | (1<<ADPS0) | (1<<ADPS1) | (1<<ADPS2);
	// Dummy-Wandlung
	adc_read(0);
}

/* ---------------------------------------------- */
// Interrupt Handler für die Timer
AVRX_SIGINT(TIMER0_OVF_vect)
{
	IntProlog();
	TCNT0 = TCNT0_INIT;
	AvrXTimerHandler();
	Epilog();
}

/* ---------------------------------------------- */
// Initialisierungen 
void init_function()
{
	MCUCR = _BV(SE);
	TCNT0 = TCNT0_INIT;
	TCCR0 = TMC8_CK256;
	TIMSK = _BV(TOIE0);
	
	DDRA  = DDRA  & ~(1 << PINA1);
	PORTA = PORTA |  (1 << PINA1);
}


/* ---------------------------------------------- */
// Zeitmessung
AVRX_GCC_TASKDEF(taskClock, 30, 0)
{
	while (1)
	{
		// warte eine Sekunde
		AvrXDelay(&TickTimerClock, 1000);

		// warte auf die Semaphore
		AvrXWaitSemaphore(&semaphoreData);
		// zaehle die Zeit um eine Sekunde runter
		playTime--;
		// falls die Zeit abgelaufen ist...
		if (playTime == 0)
		{
			// setze das Spiel auf beendet
			gameEnd = 1;
		}
		// das LCD aktualisieren
		AvrXSendMessage(&LcdQueue, &UpdateDisplay);
		// Semaphore freigeben
		AvrXSetSemaphore(&semaphoreData);
	}
}

/* ---------------------------------------------- */
// Steuerung des Aliens
AVRX_GCC_TASKDEF(taskAlien, 60, 0)
{
	while (1)
	{
		// warte 1 Sekunde
		AvrXDelay(&TickTimerAlien, 1000);

		// warte auf die Semaphore
		AvrXWaitSemaphore(&semaphoreData);
		// die Alienposition zufaellig setzen
		alienPosition = rand() % 14;
		alienBlocked = 0;

		// das LCD aktualisieren
		AvrXSendMessage(&LcdQueue, &UpdateDisplay);
		// Semaphore freigeben
		AvrXSetSemaphore(&semaphoreData);
	}
}

/* ---------------------------------------------- */
// Steuerung des Raumschiffes
AVRX_GCC_TASKDEF(taskSpaceship, 60, 0)
{
	uint8_t oldPosition;
	while (1)
	{
		// warte 20 Millisekunden
		AvrXDelay(&TickTimerSpaceship, 20);

		// warte auf die Semaphore
		AvrXWaitSemaphore(&semaphoreData);
		// die alte Position speichern
		oldPosition = spaceshipPosition;
		// die neue Position des Raumschiffes aus dem Wert des AD Wandlers errechnen:
		// 1023 / 74 als Ganzzahl ist 13
		spaceshipPosition = adc_read() / 74;

		// das LCD nur aktualisieren, wenn sich die Position geaendert hat
		if (oldPosition != spaceshipPosition)
		{
			// das LCD aktualisieren
			AvrXSendMessage(&LcdQueue, &UpdateDisplay);
		}
		// Semaphore freigeben
		AvrXSetSemaphore(&semaphoreData);
	}
}

/* ---------------------------------------------- */
// Taster
AVRX_GCC_TASKDEF(taskButton, 60, 0)
{
	uint8_t isPressed = 0;
	while (1)
	{
		// warte 10 Millisekunden
		AvrXDelay(&TickTimerButton, 10);

		// falls der Taster gedrueckt ist...
		if (!(PINA & (1 << PINA1)))
		{
			// ... und vorher noch nicht gedrueckt war
			if (!isPressed)
			{
				// warte auf die Semaphore
				AvrXWaitSemaphore(&semaphoreData);
				// falls das Spiel beendet ist
				if (gameEnd)
				{
					// starte das Spiel neu
					gameEnd = 0;
					playTime = 60;
					spaceshipPoints = 0;
					fire = 0;
					spaceshipRemainingEnergie = 10;

					// setze die Start-Semaphore
					AvrXSetSemaphore(&semaphoreStart);
				}
				else
				{
					// wurde das Alien getroffen?
					if (alienPosition == spaceshipPosition)
					{
						// der Schuss war ein Treffer
						fire = 1;
						// erhoehe die Punktzahl
						spaceshipPoints++;
						// es gibt 2 Energiepunkte - 1 verbrauchten Energiepunkt
						spaceshipRemainingEnergie++;
						// setze die neue Alienspezies auf einen zufaelligen Wert
						alienSpecies = 5 + rand() % NUMBER_ALIEN_SPECIES;
					}
					else
					{
						// der Schuss ging daneben
						fire = 2;
						// ziehe einen Energiepunkt ab
						spaceshipRemainingEnergie--;

						// falls keine Energie mehr ueber ist
						if (!spaceshipRemainingEnergie)
						{
							// das Spiel ist vorbei
							gameEnd = 2;
						}
					}
				}
				// das LCD aktualisieren
				AvrXSendMessage(&LcdQueue, &UpdateDisplay);
				// Semaphore freigeben
				AvrXSetSemaphore(&semaphoreData);

				// speichern, dass der Button gedrueckt wird
				isPressed = 1;
			}
		}
		else
		{
			// der Taster ist nicht gedrueckt
			isPressed = 0;
		}
	}
}

/* ---------------------------------------------- */
// LCD Ansteuerung
AVRX_GCC_TASKDEF(taskLcd, 100, 4)
{
	MessageControlBlock *p;
	while (1)
	{
		// Wait for messages in the message queue
		p = AvrXWaitMessage(&LcdQueue);
		// Is the message the one we are waiting for?
		if (p == &UpdateDisplay)
		{
			if (gameEnd)
			{
				AvrXWaitSemaphore(&semaphoreData);
				lcd_clear();
				char buf[16];
				switch (gameEnd)
				{
					case 1:
						lcd_setcursor(3, 1);
						snprintf(buf, 16, "Time Over!");
						lcd_string(buf);
						break;
					case 2:
						lcd_setcursor(2, 1);
						snprintf(buf, 16, "No Ammo Left!");
						lcd_string(buf);
						break;
				}
				lcd_setcursor(3, 2);
				snprintf(buf, 16, "Points: %u", spaceshipPoints);
				lcd_string(buf);
				
				AvrXDelay(&TickTimerLCD, 2000);
				AvrXSetSemaphore(&semaphoreData);
				
				AvrXWaitSemaphore(&semaphoreStart);
			}
			else
			{
				AvrXWaitSemaphore(&semaphoreData);
				
				lcd_clear();
				lcd_setcursor(14, 1);
				char buf[3];
				if (playTime < 10)
				{
					snprintf(buf, 3, "0%u", playTime);
				}
				else
				{
					snprintf(buf, 3, "%u", playTime);
				}
				lcd_string(buf);
				
				lcd_setcursor(14, 2);
				if (spaceshipRemainingEnergie < 10)
				{
					snprintf(buf, 3, "0%u", spaceshipRemainingEnergie);
				}
				else
				{
					snprintf(buf, 3, "%u", spaceshipRemainingEnergie);
				}
				lcd_string(buf);
				
				if (fire)
				{
					lcd_setcursor(spaceshipPosition, 2);
					lcd_data(SYMBOL_SPACESHIP_FIRE);
					if (fire == 1)
					{
						lcd_setcursor(alienPosition, 1);
						lcd_data(SYMBOL_EXPLOSION);
						alienBlocked = 1;
					}
					else
					{
						lcd_setcursor(alienPosition, 1);
						lcd_data(alienSpecies);
						lcd_setcursor(spaceshipPosition, 1);
						lcd_data(SYMBOL_MISS);
					}
					AvrXDelay(&TickTimerLCD, 250);
					fire = 0;
				}
				else
				{
					if (!alienBlocked)
					{
						lcd_setcursor(alienPosition, 1);
						lcd_data(alienSpecies);
					}
					
					lcd_setcursor(spaceshipPosition, 2);
					lcd_data(SYMBOL_SPACESHIP);
				}
				
				AvrXSetSemaphore(&semaphoreData);
			}
		}
	}
}

/* ---------------------------------------------- */
int main(void)
{
	// Initialisierungen
	
	// Definition des Stack Pointers der main
	AvrXSetKernelStack(0);
	// Initialisierung von AvrX
	init_function();
	// Initialisierung der LEDs
	lcd_init();
	// Initialisierung des ADW
	adc_init();
	
	// Definition und Initialisierung des Raumschiffes und der Aliens
	uint8_t symbols[] = {0x00, 0x00, 0x00, 0x04, 0x0A, 0x0A, 0x1B, 0x15,
		0x04, 0x04, 0x0A, 0x04, 0x0A, 0x0A, 0x1B, 0x15,
		0x0A, 0x00, 0x11, 0x0A, 0x0A, 0x11, 0x00, 0x0A,
		0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00,
		0x00, 0x00, 0x00, 0x0E, 0x15, 0x1B, 0x0E, 0x1B,
		0x00, 0x11, 0x1F, 0x15, 0x1F, 0x0A, 0x0E, 0x0A,
		0x00, 0x00, 0x0E, 0x15, 0x0E, 0x04, 0x0A, 0x11,
		// Die folgende Zeile ersetzen, um den eigenen Alien zu erstellen
		0x04, 0x0A, 0x0E, 0x11, 0x0A, 0x04, 0x0A, 0x11};
	
	for(int i = 0; i < 8; i++)
	{
		lcd_generatechar(i+1, symbols+(i*8));
	}
	
	// Starten des Tasks
	AvrXRunTask(TCB(taskClock));
	AvrXRunTask(TCB(taskAlien));
	AvrXRunTask(TCB(taskSpaceship));
	AvrXRunTask(TCB(taskButton));
	AvrXRunTask(TCB(taskLcd));
	
	// Setzen der Semaphore
	AvrXSetSemaphore(&semaphoreData);

	// Aufrufen des Schedulers
	Epilog();
	while(1);
}