listing.txt

/**********************************************************************
  Module: console.c
  Author: Jim Young
  Date:   2017 May 3

  Purpose: see console.h

  Changes: 
    2017 May 3 [ Jim Young ]

  NOTES: none
**********************************************************************/

#include "console.h"
#include <curses.h>
#include <string.h>
#include <time.h>        /*for nano sleep */
#include <stdbool.h>


static int CON_WIDTH, CON_HEIGHT;
static int consoleLock = false;
static int MAX_STR_LEN = 256; /* for strlen checking */

/* Local functions */

static bool checkConsoleSize(int reqHeight, int reqWidth) 
{

	if ( (reqWidth > COLS) || (reqHeight > LINES) ) 
 	{
    		fprintf(stderr, "\n\n\rSorry, your window is only %ix%i. \n\r%ix%i is required. Sorry.\n\r", COLS, LINES, reqWidth, reqHeight);
    		return (false);
  	}

  return(true);
}

bool consoleInit(int height, int width, char *image[])  /* assumes image height/width is same as height param */
{
	bool status;

	initscr();
	crmode();
	noecho();
	clear();

	CON_HEIGHT = height;  CON_WIDTH = width;
	status = checkConsoleSize(CON_HEIGHT, CON_WIDTH);

	if (status) 
	{
		consoleDrawImage(0, 0, image, CON_HEIGHT);
		consoleRefresh();
	}

	return(status);
}

void consoleDrawImage(int row, int col, char *image[], int height) 
{
	int i, length;
	int newLeft, newRight, newOffset, newLength;

	if (consoleLock) return;

	newLeft  = col < 0 ? 0 : col;
	newOffset = col < 0 ? -col : 0;

	for (i = 0; i < height; i++) 
	{
		if (row+i < 0 || row+i >= CON_HEIGHT)
			continue;
		length = strnlen(image[i], MAX_STR_LEN);
		newRight = col+length >= CON_WIDTH ? CON_WIDTH-1 : col+length;
		newLength = newRight - newLeft + 1;
		if (newOffset >= length || newLength <= 0)
		  continue;

		if (mvaddnstr(row+i, newLeft, image[i]+newOffset, newLength) == ERR)
			fprintf(stderr, "ERROR drawing to screen"); /* smarter handling is needed */
	}
}

void consoleClearImage(int row, int col, int height, int width) 
{
	int i, j;
	if (consoleLock) return;

	if (col+width > CON_WIDTH)
		width = CON_WIDTH-col;
	if (col < 0) 
	{
		width += col; /* -= -col */
		col = 0;
	}

	if (width < 1 || col >= CON_WIDTH) /* nothing to clear */
		return;

	for (i = 0; i < height; i++) 
	{
		if (row+i < 0 || row+i >= CON_HEIGHT)
			continue;
		move(row+i, col);
		for (j = 0; j < width; j++)
	    		addch(' ');
	}
}

void consoleRefresh(void)
{
	if (!consoleLock) 
	{
	    move(LINES-1, COLS-1);
	    refresh();
	}
}

void consoleFinish(void) 
{
    endwin();
}

void putBanner(const char *str) 
{
  if (consoleLock) return;
  int len;

  len = strnlen(str,MAX_STR_LEN);
  
  move (CON_HEIGHT/2, (CON_WIDTH-len)/2);
  addnstr(str, len);

  consoleRefresh();
}

void putString(char *str, int row, int col, int maxlen) 
{
  if (consoleLock) return;
  move(row, col);
  addnstr(str, maxlen);
}


/* setup to work in USECS, reduces risk of overflow */
/* 10000 usec = 10 ms, or 100fps */
#define TIMESLICE_USEC 10000
#define TIME_USECS_SIZE 1000000
#define USEC_TO_NSEC 1000  
struct timespec getTimeout(int ticks) 
{
  struct timespec rqtp;

  /* work in usecs at first */
  rqtp.tv_nsec = TIMESLICE_USEC * ticks;

  /* handle usec overflow */
  rqtp.tv_sec = rqtp.tv_nsec / TIME_USECS_SIZE;
  rqtp.tv_nsec %= TIME_USECS_SIZE;

  rqtp.tv_nsec *= USEC_TO_NSEC;  /*convert to nsecs */
  return rqtp;
}

void sleepTicks(int ticks) 
{

  if (ticks <= 0)
    return;

  struct timespec rqtp = getTimeout(ticks);
  nanosleep(&rqtp, NULL);
}

#define FINAL_PAUSE 2 
void finalKeypress() 
{
	flushinp();
	sleepTicks(FINAL_PAUSE);
    	move(LINES-1, COLS-1);
	getch(); /* wait for user to press a character, blocking. */
}

void disableConsole(int disabled) 
{
	consoleLock = disabled;
}
/* COMP 3430
 * PROF: JIM YOUNG
 * REBECCA TIESSEN
 *
 * This file takes care of the main game logic, and setting up initializer 
 * methods. It also keeps track of player lives
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

#include "console.h"
#include "frogger.h"
#include "threadwrappers.h"
#include "player.h"
#include "gameglobals.h"
#include "log.h"
#include "llist.h"

//-------------------------------------------------------------------//
int main(int argc, char**argv) {
  startGame();
  printf("done!\n");
}

void startGame(){
   //initialize all mutexes and condLock
   initLocks();
   if(drawScreen()){
      createThread(&tids[getThreadCount()], updateLives, NULL);
      createThread(&tids[getThreadCount()], refreshScreen, NULL);
      initializePlayer();
      initializeLogs();

      lockMutex(&mainLock);
      while(!isGameOver()){
         pthread_cond_wait(&condLock, &mainLock);
      }
      unlockMutex(&mainLock);
   }
   finalKeypress();
   int i;
   for(i = 0; i < getThreadCount(); i++){
      joinThread(tids[i]);
   }
   destroyLocks();
   free(getFrog());
   deleteList();
   consoleFinish();
}

void *refreshScreen(){
   while(!isGameOver()){
      lockMutex(&screenLock);
      consoleRefresh();
      unlockMutex(&screenLock);
      sleepTicks(1); 
   }
   pthread_exit(NULL);
}

void *updateLives(){
   Frog *frog = getFrog();
   int lifeCount = MAX_LIVES;
   char strLives[2];

   while(frog == NULL){
      frog = getFrog(); //deals with initialization of thread before frog is created
   }
   while(!isGameOver()){
      if(frog->dead){
         lifeCount--;
         sprintf(strLives, "%d", lifeCount);
         lockMutex(&screenLock);
         putString(strLives, 0, 42, 1);
         unlockMutex(&screenLock);

	 lockMutex(&playerLock);
	 frog->dead = false;
	 unlockMutex(&playerLock);
      }
      sleepTicks(1);
      if(lifeCount <= 0){
	 endGame("GAME OVER");
      }
   }
   pthread_exit(NULL);
}

void endGame(char *endMsg){
   lockMutex(&screenLock);
   putBanner(endMsg);
   disableConsole(1);
   unlockMutex(&screenLock);

   lockMutex(&mainLock);
   setGameOver();
   pthread_cond_signal(&condLock);
   unlockMutex(&mainLock);
}
/* COMP 3430
 * PROF: JIM YOUNG
 * REBECCA TIESSEN
 * 
 * This file includes methods used by all files in order to check for game over, thread count, and setting up locks.
 *
 */

#include <pthread.h>
#include <stdbool.h>
#include "gameglobals.h"
#include "console.h"

static bool gameOver = false;
static int threadCount = 0;
char *GAME_BOARD[] = {
"                                   Lives: 4",
"/------\\          /------\\          /------\\          /------\\          /------\\",
"|      |          |      |          |      |          |      |          |      |",
"+      +----------+      +----------+      +----------+      +----------+      +",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"",
"",
"",
"" };

bool drawScreen(){
   return consoleInit(GAME_ROWS, GAME_COLS, GAME_BOARD);
}

void initLocks(){
   // Mutex locks
   pthread_mutex_init(&screenLock, NULL);
   pthread_mutex_init(&playerLock, NULL);
   pthread_mutex_init(&mainLock, NULL);
   pthread_mutex_init(&threadCountLock, NULL);
   pthread_mutex_init(&listLock, NULL);
   // Conditional variable lock
   pthread_cond_init(&condLock, NULL);
}

void destroyLocks(){
   pthread_mutex_destroy(&screenLock);
   pthread_mutex_destroy(&playerLock);
   pthread_mutex_destroy(&mainLock);
   pthread_mutex_destroy(&threadCountLock);
   pthread_mutex_destroy(&listLock);

   pthread_cond_destroy(&condLock);

}

void setGameOver(){
   gameOver = true;
}

bool isGameOver(){
   return gameOver;
}

int getThreadCount(){
   return threadCount;
}

void incrementThreadCount(i){
   threadCount++;
}

void decrementThreadCount(){
   threadCount--;
}

void sleepLoop(int numTicks){
   int i;
   for(i = 0; i < numTicks && !isGameOver(); i++){
      sleepTicks(i);
   }
}
/* COMP 3430
 * PROF: JIM YOUNG
 * REBECCA TIESSEN
 *
 * This file holds the linked list that the logs are stored in when created. There are standard insert and search/delete methods,
 * as well as traversals that use a static Node to keep track of the current place in the list. 
 *
 */

#include <stdlib.h>
#include <stdbool.h>
#include <stdio.h>
#include "log.h"
#include "llist.h"

static Node *top = NULL;
static Node *traverseNode = NULL;
static Node *toDelete = NULL;
static int logCount = 0;

bool insert(Log *newLog){
   bool success = false;
   Node *newNode = NULL;

   if(newLog != NULL){
      newNode = (Node *)malloc(sizeof(Node));
      if(newNode != NULL){
         newNode->log = newLog;
         newNode->next = top;
	 top = newNode;

	 logCount++;
	 success = true;
      }
      else{
         free(newNode);
         newNode = NULL;
      }
   }
   return success;
}

bool searchAndRemove(Log *log){ 
   bool deleted = false;
   Node *curr = top;
   Node *prev = NULL;

   if(curr != NULL){
      while(curr != NULL && curr->log != log){
         prev = curr;
	 curr = curr->next;
      }
      if(curr != NULL){
         if(prev != NULL){
	    prev->next = curr->next;
	 }
	 else{
	   top = curr->next;
	 }
	 free(curr->log);
	 curr->log = NULL;
	 free(curr);
	 curr = NULL;
	 deleted = true;
	 logCount--;
      }
   }
   return deleted;
}

Log *firstItem(){
   Log *first = NULL;
   if(top != NULL){
      traverseNode = top->next;
      first = top->log;
   }
   return first;
}

Log *nextAvailableLog(){ //for frog search method 
   Log *next = NULL;

   if(traverseNode != NULL){
      next = traverseNode->log;
      traverseNode = traverseNode->next;
   }
   return next;
}

bool listIsEmpty(){
   return top == NULL;
}

Log *cleanupNextLog(){ //for cleanupLogs method
   Log *potentialDelete = NULL;
   if(toDelete == NULL){
      toDelete = top;
   }
   if(toDelete != NULL){
      potentialDelete = toDelete->log;
      toDelete = toDelete->next;
   }
   return potentialDelete;
}

void deleteList(){
   Node *temp = NULL;
   while(top != NULL){
      temp = top;
      top = top->next;
      free(temp->log);
      free(temp);

   }
}
/* COMP 3430
 * PROF: JIM YOUNG
 * REBECCA TIESSEN
 *
 * This file takes care of animating, moving, and spawning logs. The frog is allowed to jump on the logs to get to the home bank.
 *
*/

#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#include "log.h"
#include "console.h"
#include "threadwrappers.h"
#include "gameglobals.h"
#include "llist.h"
#include "player.h"

#define LOG_ANIM_TILES 2 
#define LOG_HEIGHT 4
#define NUM_ROWS 4

Frog *frog;
static int log_width;
static char* LOG_GRAPHIC[LOG_ANIM_TILES][LOG_HEIGHT+1] = {
   {"/======================\\",
    "|                      |",
    "|                      |",
   "\\======================/"},
   {"/======================\\",
    "-                      +",
    "+                      -",
   "\\======================/"}
};
//---PROTOTYPES------------------------------------------------//
static void drawLog();
static void setLogWidth();
//---METHODS---------------------------------------------------//
void initializeLogs(){
   frog = getFrog();
   setLogWidth();

   enum row rows[] = {one, two, three, four};
   int i;
   for(i = 0; i < NUM_ROWS; i++){
      void *row = malloc(sizeof(int));
      *((int*)row) = rows[i];
      createThread(&tids[getThreadCount()], runLogs, (void *)row);
   }

   createThread(&tids[getThreadCount()], cleanUpLogs, NULL);
}

void *runLogs(void *startRow){
   int *row = (int *)startRow;
   while(!isGameOver()){
      Log *newLog = (Log *)malloc(sizeof(Log));
      logStartup(newLog, row);
      lockMutex(&listLock);
      insert(newLog);
      unlockMutex(&listLock);

      createLogThread(&(newLog->threadID), logController, (void *)newLog);
      sleepTicks((rand()%200)+150); //random log generation speed
     }
   pthread_exit(NULL);
}

void *logController(void *currLog){
   Log *log = (Log *)currLog; 
   while(!isGameOver() && !log->dead){
      if(log->hasFrog){
	 moveFrogAndLog(log);
	 moveFrogAndLog(log);
      }
      else{
         moveLog(log);
         moveLog(log);
         animateLog(log);
      }
      sleepTicks(log->speed);
   }
   pthread_exit(NULL);
}

void moveLog(Log *log){
   if(log->direction == left){
      log->prevCol = log->currCol;
      log->currCol--;
   }
   else{
      log->prevCol = log->currCol;
      log->currCol++;
   }
   drawLog(log);
   checkIsDead(log);
}

void animateLog(Log *log){
   if(log->animateState == first)
      log->animateState = second;
   else
      log->animateState = first;
   drawLog(log);
}

static void drawLog(Log *log){
   char** tile = LOG_GRAPHIC[log->animateState];
   
   lockMutex(&screenLock);
   consoleClearImage(log->startRow, log->prevCol, LOG_HEIGHT, log_width);
   consoleDrawImage(log->startRow, log->currCol, tile, LOG_HEIGHT);
   unlockMutex(&screenLock);
}

void moveFrogAndLog(Log *log){
   moveLog(log);
   animateLog(log);
   if(log->direction == left)
      moveFrog(LEFT_KEY);
   else
      moveFrog(RIGHT_KEY);
}

void *cleanUpLogs(){
   Log *curr = NULL;
   Log *logToDelete = NULL;
   while(!isGameOver()){
      lockMutex(&listLock);
      curr = cleanupNextLog();
      unlockMutex(&listLock);
      while(curr != NULL && !isGameOver()){
         if(curr->dead){
            joinLogThread(curr->threadID);
            logToDelete = curr;
         }

         if(logToDelete != NULL){
            lockMutex(&listLock);
            searchAndRemove(logToDelete);
            unlockMutex(&listLock);
            logToDelete = NULL;
         }
         lockMutex(&listLock);
         curr = cleanupNextLog();
         unlockMutex(&listLock);
	 sleepTicks(1);
      }
      unlockMutex(&listLock);
      sleepLoop(100);
   }
   pthread_exit(NULL);
}

void logStartup(Log *log, int *startRow){ 
   log->startRow = (enum row)*startRow;
   setLogSpeed(log, startRow);
   setDirection(log);
   log->width = log_width;
   log->height = LOG_HEIGHT;
   log->animateState = first;

   if(log->direction == left){
      log->prevCol = log->currCol = RIGHT_EDGE;
   }
   else{
      log->prevCol = log->currCol = LEFT_EDGE-log->width;
   }
   log->dead = false;
   log->hasFrog = false;
}

void setDirection(Log *log){
   if(log->startRow%8 == 0) //alternate every other row
      log->direction = left;
   else
      log->direction = right;
}

void setLogSpeed(Log *log, int *startRow){
   enum row currRow = (enum row)*startRow;
   if(currRow == one)
      log->speed = 5;
   else if(currRow == two)
      log->speed = 7;
   else if(currRow == three)
      log->speed = 10; 
   else
      log->speed = 12;
}

void checkIsDead(Log *log){
   if(log->currCol > RIGHT_EDGE || log->currCol < LEFT_EDGE-log->width){
      log->dead = true;
   }
}

void setLogWidth(){
   char **tile = LOG_GRAPHIC[0];
   log_width = strlen(tile[0]);
}

/* COMP 3430
 * PROF: JIM YOUNG
 * REBECCA TIESSEN
 * 
 * Player.c includes all the logic required for the frog to move around, animate, and die if it hits the water. 
 * It also keeps track of the number of safe pods you've made it to.
 *
 */

#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/select.h> //for keyboard functinonality
#include <stdlib.h>

#include "player.h"
#include "threadwrappers.h"
#include "console.h"
#include "gameglobals.h"
#include "log.h"
#include "llist.h"
#include "frogger.h"

#define PLAYER_ANIM_TILES 2
#define PLAYER_HEIGHT 2
#define F_START_ROW 21
#define F_START_COL 40
#define VERTICAL_JUMP 4
#define SIDE_JUMP 1
#define HOME_JUMP 3

static char* PLAYER_GRAPHIC[PLAYER_ANIM_TILES][PLAYER_HEIGHT+1] = {
  {"@@",
   "<>"},
  {"--",
   "<>"}
};
static const int SAFE_POD_1 = 0;
static const int SAFE_POD_2 = 18;
static const int SAFE_POD_3 = 36;
static const int SAFE_POD_4 = 54;
static const int SAFE_POD_5 = 72;

Frog *frog; //global frog

//---PROTOTYPES---------------------------------------------------------
static void updatePrevious();
static void drawFrog();
//---METHODS------------------------------------------------------------//

void initializePlayer(){
   frog = (Frog *)malloc(sizeof(Frog));
   createFrog();
   createThread(&tids[getThreadCount()], animateFrog, NULL);
   createThread(&tids[getThreadCount()], initMovement, NULL);
} 

void *animateFrog(){
   while(!isGameOver()){
      lockMutex(&playerLock);
      if(frog->animateState == first)
         frog->animateState = second;
      else
         frog->animateState = first;
      unlockMutex(&playerLock);
      drawFrog();
      sleepTicks(frog->blinkSpeed); 
   }
   pthread_exit(NULL);
}

void *initMovement(){
   fd_set set;

   while(!isGameOver()){
      FD_ZERO(&set);
      FD_SET(STDIN_FILENO, &set);
      struct timespec timeout = getTimeout(1); /* duration of one tick */
      int ret = pselect(FD_SETSIZE, &set, NULL, NULL, &timeout, NULL);
 
      if(ret == -1){
         exit(1);
      }
      else if(ret == 0){
         continue; //pselect timed out, no chars were entered
      }
      else{
         char c = getchar();
         if(c == QUIT){
	    endGame("quitters never prosper");
	 }
	 else{
	    moveFrog(c);
	 }
      }
      sleepTicks(1);
   }
   pthread_exit(NULL);
}

void moveFrog(char c){
   if(c == LEFT_KEY && frog->currPos[1] > LEFT_EDGE){
      lockMutex(&playerLock);
      updatePrevious();
      frog->currPos[1] -= SIDE_JUMP;
      unlockMutex(&playerLock);

   }else if(c == RIGHT_KEY && frog->currPos[1] < RIGHT_EDGE-frog->width){ //screen size - width of frog
      lockMutex(&playerLock);
      updatePrevious();
      frog->currPos[1] += SIDE_JUMP;
      unlockMutex(&playerLock);

   }else if(c == UP_KEY && homeFree()){ //safe!!
      lockMutex(&playerLock);
      updatePrevious();
      frog->currPos[0] -= HOME_JUMP;
      unlockMutex(&playerLock);
      sleepTicks(10);
      drawFrog();
      sleepTicks(10);
      moveHome();
      checkWin();

   }else if(c == DOWN_KEY && frog->currPos[0] < F_START_ROW-frog->height){
      lockMutex(&playerLock);
      updatePrevious();
      frog->currPos[0] += VERTICAL_JUMP;
      unlockMutex(&playerLock);
      
   }else if(c == UP_KEY && frog->currPos[0] > 8){
      lockMutex(&playerLock);
      updatePrevious();
      frog->currPos[0] -= VERTICAL_JUMP;
      unlockMutex(&playerLock);
   }
   
   drawFrog();
   isFrogOnAnyLog();
   checkDead();
}

void moveHome(){
   char **tile = PLAYER_GRAPHIC[frog->animateState];
   setHomePosition();
   lockMutex(&screenLock);
   consoleDrawImage(frog->currPos[0], frog->currPos[1], tile, frog->height);
   unlockMutex(&screenLock);
   drawFrog();
}

bool homeFree(){
   int podLocations[] = {SAFE_POD_1, SAFE_POD_2, SAFE_POD_3, SAFE_POD_4, SAFE_POD_5};
   bool home = false;
   int i;
   int podCount = 0;
   for(i = 0; i < NUM_PODS && !home; i++){
      if(frog->currPos[0] == 5 && frog->currPos[1] > podLocations[i] && frog->currPos[1] < podLocations[i] + POD_WIDTH - frog->width && 
        !frog->podFull[podCount]){
         home = true;
	 frog->podFull[i] = true;
      }
   }
   return home;
}

void isFrogOnAnyLog(){
   Log *currLog = NULL;
   bool onLog = false;

   lockMutex(&listLock);
   lockMutex(&playerLock);
   while(!isGameOver() && currLog == NULL){
      currLog = firstItem();
   }
   while(!isGameOver() && currLog != NULL){
      if((frog->currPos[0] > currLog->startRow) && ((frog->currPos[0]+frog->height) < currLog->startRow+currLog->height) &&
       ((frog->currPos[1]+frog->width) < (currLog->currCol+currLog->width)) && (frog->currPos[1] > currLog->currCol)){
	 currLog->hasFrog = true;
	 frog->onLog = true;
	 onLog = true;
      }
      else{
         currLog->hasFrog = false;
      }
      currLog = nextAvailableLog();
   }
   unlockMutex(&playerLock);
   unlockMutex(&listLock);

   lockMutex(&playerLock);
   if(!onLog){
      frog->onLog = false;
   }
   unlockMutex(&playerLock);
}

static void drawFrog(){
   char **tile = PLAYER_GRAPHIC[frog->animateState];
   lockMutex(&screenLock);
   lockMutex(&playerLock);
   consoleClearImage(frog->prevPos[0], frog->prevPos[1], frog->height, frog->width);
   consoleDrawImage(frog->currPos[0], frog->currPos[1], tile, frog->height);
   unlockMutex(&playerLock);
   unlockMutex(&screenLock);
}

void setHomePosition(){
   frog->prevPos[0] = frog->currPos[0] = F_START_ROW;
   frog->prevPos[1] = frog->currPos[1] = F_START_COL;
}

void checkWin(){
   int winCount = 0;
   int i;
   for(i = 0; i < NUM_PODS; i++){
      if(frog->podFull[i])
         winCount++;
   }
   if(winCount == NUM_PODS){ //all spaces are filled
      endGame("you're a champ");
   }
}

void checkDead(){
   if(!inSafeZone()){
      lockMutex(&playerLock);
      frog->dead = true;
      unlockMutex(&playerLock);
   }

   if(frog->dead){
      sleepTicks(10);
      moveHome();
      lockMutex(&playerLock);
      frog->dead = false;
      unlockMutex(&playerLock);
   }
}

bool inSafeZone(){
   bool safe = false;
   if(frog->onLog || frog->currPos[0] > START_BANK || frog->currPos[0] < SAFE_BANK){
      safe = true;
   }
   return safe;
}

void createFrog(){
   char **tile = PLAYER_GRAPHIC[0];
   setHomePosition();

   lockMutex(&playerLock);
   frog->blinkSpeed = 30;
   frog->animateState = first;
   frog->height = PLAYER_HEIGHT;
   frog->width = strlen(tile[0]);
   frog->dead = false;
   frog->onLog = false;
   int i;
   for(i = 0; i < NUM_PODS; i++){
      frog->podFull[i] = false;
   }
   unlockMutex(&playerLock);
}

Frog *getFrog(){
   return frog;
}

static void updatePrevious(){
   frog->prevPos[0] = frog->currPos[0];
   frog->prevPos[1] = frog->currPos[1];
}
/* COMP 3430
 * PROF: JIM YOUNG
 * REBECCA TIESSEN
 *
 * This file is a wrapper for the pthread methods in order to check for errors. An error will print and the program will exit if 
 * a method errors.
*/

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include "threadwrappers.h"
#include "gameglobals.h"

void createThread(pthread_t *thread, void *(*func)(void *), void *param){
   int ret;
   ret = pthread_create(thread, NULL, func, param);
   if(ret){
      printError();
   }
   lockMutex(&threadCountLock);
   incrementThreadCount();
   unlockMutex(&threadCountLock);
}

void joinThread(pthread_t thread){
  int ret;
  ret = pthread_join(thread, NULL);
  if(ret){
     printError();
  }
  lockMutex(&threadCountLock);
  decrementThreadCount();
  unlockMutex(&threadCountLock);
}

void createLogThread(pthread_t *thread, void *(*func)(void *), void *param){
   int ret;
   ret = pthread_create(thread, NULL, func, param);
   if(ret)
      printError();
}

void joinLogThread(pthread_t thread){
   int ret;
   ret = pthread_join(thread, NULL);
   if(ret)
      printError();
}

void lockMutex(pthread_mutex_t *lock){
   int ret;
   ret = pthread_mutex_lock(lock);
   if(ret){
      printError();
   }
}

void unlockMutex(pthread_mutex_t *lock){
   int ret;
   ret = pthread_mutex_unlock(lock);
   if(ret){
      printError();
   }
}

void printError(){
   fprintf(stderr, "THREAD ERROR\n");
   exit(1);
}
/**********************************************************************
  Module: console.h
  Author: Jim Young
  Date:   2017 May 3

  Purpose: Draw 2d images on the screen.  Also, draw main game image.

  Changes: 
    2017 May 3 [ Jim Young ]

  NOTES: none of these functions are re-entrant (they are not thread
	 		safe)
**********************************************************************/

#ifndef CONSOLE_H
#define CONSOLE_H

#include <stdbool.h>

/**************** DRAWING **************************/

/* directions in terms of deltas in x / y dimension */
#define LEFT -1
#define RIGHT 1
#define UP -1
#define DOWN 1

#define SCR_LEFT 0
#define SCR_TOP 0

/* Initialize curses, draw initial gamescreen. Refreshes console to terminal. 
 Also stores the requested dimensions of the consoe and tests the terminal for the
 given dimensions.*/
extern bool consoleInit(int reqHeight, int reqWidth, char *image[]);

/* Draws 2d `image' of `height' rows, at curses coordinates `(row, col)'.
   Note: parts of the `image' falling on negative rows are not drawn; each
   row drawn is clipped on the left and right side of the game console (note
   that `col' may be negative, indicating `image' starts to the left of the
   screen and will thus only be partially drawn. Useful for objects that are
   half off the screen  */
extern void consoleDrawImage(int row, int col, char *image[], int height);

/* Clears a 2d `width'x`height' rectangle with spaces.  Upper left hand
   corner is curses coordinate `(row,col)'. */
extern void consoleClearImage(int row, int col, int width, int height);

/* Moves cursor to bottom right corner and refreshes. If this is not done,
   the curses internal buffer (that you have been drawing to) is not dumped
   to screen. */
extern void consoleRefresh(void);

/*  turns off all updates. Can be used to prevent the screen refresh from working, e.g., at game end while threads are all catching up.*/
extern void disableConsole(int disabled);

/* Terminates curses cleanly. */
extern void consoleFinish(void);

/* Puts the given banner in the center of the screen */
void putBanner(const char *);

/* Draws the given string at the given location  */
void putString(char *, int row, int col, int maxlen);

/* Sleeps the given number of 10ms ticks */
void sleepTicks(int ticks);

/* clears the input buffer and then waits for one more key */
void finalKeypress();

/* gets a timespec that represents the time of one tick */
struct timespec getTimeout(int ticks);

#endif /* CONSOLE_H */
/* The header file for frogger.c
*/

#ifndef FROGGER_H
#define FROGGER_H

#define MAX_LIVES 4

/* Initializes player and logs, as well as the refresh screen and update lives
   methods. Sets a condition variable to wait for gameover */
void startGame();

/* Calls the console refresh method */
void *refreshScreen();

/* Checks if the frog is dead and updates the player lives */
void *updateLives();

/* Displays an end of game message and signals the condition variable, and sets
   game over to true. */
void endGame(char *endMessage);

#endif
/* The header file for gameglobals.c
*/

#ifndef GAMEGLOBALS_H
#define GAMEGLOBALS_H

#include <stdbool.h> 

//---GLOBALS-------------------------------------//
#define GAME_ROWS 24
#define GAME_COLS 80
#define NUM_THREADS 64
#define LEFT_EDGE 0
#define RIGHT_EDGE 80
#define NUM_PODS 5
#define POD_WIDTH 7
#define START_BANK 20
#define SAFE_BANK 4
#define LEFT_KEY 'a'
#define RIGHT_KEY 'd'
#define UP_KEY 'w'
#define DOWN_KEY 's'
#define QUIT 'q'

enum state {first, second};

pthread_cond_t condLock;
pthread_mutex_t refreshLock, screenLock, playerLock, threadCountLock, listLock, mainLock;
pthread_t tids[NUM_THREADS];

/* Draws the initial game screen */
bool drawScreen();

/* Initializes all mutexes and cond variable */
void initLocks();

/* Destroys the mutexes and cond variable */
void destroyLocks();

/* Sets game over to true */
void setGameOver();

/* Checks if game over is true */
bool isGameOver();

/* Returns the current thread count */
int getThreadCount();

/* Increments the number of threads */
void incrementThreadCount();

/*Decrements the number of threads */
void decrementThreadCount();

/* Sleeps */
void sleepLoop(int ticks);

#endif
/* The header file for llist.c
*/

#ifndef LLIST_H
#define LLIST_H
#include <stdbool.h>

typedef struct NODE Node;
struct NODE {
   Log *log;
   Node *next;
};

/* Inserts a log into the list */
bool insert(Log *log);

/* Searches for a log in the list and removes it */
bool searchAndRemove(Log *log);

/* Checks if list is empty */
bool listIsEmpty();

/* Returns the first log in the list to start traversal */
Log *firstItem();

/* Continues traversal with the next available log */ 
Log *nextAvailableLog();

/* Continues a traversal for the log cleanup */
Log *cleanupNextLog();

/* Cleans up log list at end of program */
void deleteList();

#endif

/* The header file for log.c
*/

#ifndef LOG_H
#define LOG_H
#include <stdbool.h>
#include <pthread.h>
#include "gameglobals.h"

enum logDirection {left, right};
enum row {
   one = 4,
   two = 8,
   three = 12,
   four = 16,
};

typedef struct LOG Log;
struct LOG {
   pthread_t threadID;
   int speed;
   int prevCol, currCol;
   bool dead;
   int width;
   bool hasFrog;
   int height;
   enum row startRow;
   enum logDirection direction;
   enum state animateState;
};

/* Creates log spawner for each row */
void initializeLogs();

/* Manages the logs for each row. Adds logs to the list and initializes logs with 
   start values */ 
void *runLogs(void *startRow);

/* Decides whether to move the log by itself or the frog with the log, also sets
   log speed */
void *logController(void *currLog);

/* Moves log in the correct direction and checks if it's offscreen */
void moveLog(Log *log);

/* Sets animate state for the log */
void animateLog(Log *log);

/* Sets up log with default attributes */ 
void logStartup(Log *log, int *startRow);

/* Sets direction of log movement depending on row number */
void setDirection(Log *log);

/* Sets log speed based on current row */
void setLogSpeed(Log *log, int *startRow);

/* Checks if log is offscreen */
void checkIsDead(Log *log);

/* Traverses linked list to check for dead logs and cleans up associated memory.
   Also joins threads before deleting log */
void *cleanUpLogs();

/* Calls moveLog and moveFrog methods together */
void moveFrogAndLog(Log *log);

#endif
/* The header file for player.c
*/

#ifndef PLAYER_H
#define PLAYER_H
#include <stdbool.h>
#include "log.h"
#include "gameglobals.h"

typedef struct FROG Frog;

struct FROG {
int prevPos[2];
int currPos[2];
enum state animateState;
int blinkSpeed;
int height;
int width;
bool onLog;
bool dead;
bool podFull[5];
};

/* Creates threads required for movement and animation of the player */ 
void initializePlayer();

/* Keeps track of current animation state, draws the frog and set blink speed */
void *animateFrog();

/* Uses pselect to either timeout if no chars are entered or gets the character */ 
void *initMovement();

/* Depending on which character was entered, move the frog in 1 of 4 directions.
   If the frog is in the last row and jumps to a safe spot, save the graphic and 
   move the frog back to the beginning. Also checks for frog death and if the frog
   is on any logs. */
void moveFrog(char direction);

/* Sets up the frog's attributes */ 
void createFrog();

/* Goes through the linked list to see if the frog is on any one of the logs on
   screen. This helps the moveFrogWithLog method in the log.c */
void isFrogOnAnyLog();

/* Compares frog position with the safe pod positions to see if the frog has jumped
   to safety. If so, it sets the spot to true in the frog's podFull array.*/
bool homeFree();

/* Draws the frog back at the start bank */
void moveHome();

/* Sets the frog's home coordinates */
void setHomePosition();

/*Checks to make sure frog is on a log or on the home bank */ 
bool inSafeZone();

/* Checks to see if the frog is in a safe zone, and moves to the home
   if frog is dead */ 
void checkDead();

/* Checks to see if the frog has made it to all the safe pods */
void checkWin();

/* Returns the global frog */
Frog *getFrog();

#endif
/* The header file for threadwrappers.c
*/
#ifndef THREADWRAPPERS_H
#define THREADWRAPPERS_H

/*Creates a pthread_t and increments thread count */
void createThread(pthread_t *thread, void *(*func)(void *), void *param);

/* Safely join a pthread_t and decrements thread count*/
void joinThread(pthread_t thread);

/* Safely creates a log pthread_t */
void createLogThread(pthread_t *thread, void *(*func)(void *), void *param);

/* Safely joins a log pthread_t */
void joinLogThread(pthread_t thread);

/* Locks a mutex variable */
void lockMutex(pthread_mutex_t *lock);

/* Unlocks a mutex variable */
void unlockMutex(pthread_mutex_t *lock);

/* Prints error and exits */
void printError();

#endif