Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

Funktionen
void	HelloWorld ()

void	setFancy ()

void	initBuffer ()

void	startBuffer (int maxTextLength)

void	flushBuffer ()

int	copyChar (char src, char dst)

int	output (const char *input,...)

struct LineItem *	insertNewLineItem (struct LineItem prev, struct LineItem next, int maxTextLength)

void	deleteLineItem (struct LineItem *line, int deleteAllBelow)

void	setLineAlign (int align)

void	consoleClear ()

void	printfBanner (int width, int startAt)

void	animateBanner (int slideIn)

void	printEmptyBox (int w, int h)

void	animateBox (int wFrom, int hFrom, int wTo, int hTo)

void	strcatRepeat (char target, const char source, unsigned int howOften)

char	lower_to_upper (char ch1)

void	drawMainMenu ()

int	mainMenu ()

void	mainMenuReactToEnter (int pPos)

void	drawLeftArrow (char *menu, int pPos)

void	drawRightArrow (char *menu, int pPos)

void	showHallOfShame (int highlight, int startFrom)

int	updateSaveHoS (char victor, char victim, int moves)

int	extractMoves (char *line)

int	getOldFileLength ()

int	newBoard (struct board *target, unsigned int width, unsigned int height)

void	clearBoard (struct board *target)

char *	calcFieldAddress (struct board *target, int x, int y)

char	getField (struct board *target, int x, int y)

void	setField (struct board *target, int x, int y, char value)

void	freeBoard (struct board *target)

void	drawBoard (struct board *target)

void	gameFunction ()

void	playerAction ()

void	drawCoin (int pos, char CoinType)

void	throwCoin (int pos, char player)

void	startGame ()

int	neighbourRow (int x, int y, int xMovement, int yMovement, char player)

char	checkForWinner (int x, int y, char player)

void	clearAll ()

int	checkDraw ()

int	irand (int a, int e)

void	animateFalling (struct board *currBoard, unsigned int yPos, char CoinType)

void	showRules ()

void	showCredits ()

Dokumentation der Funktionen

void animateBanner ( int slideIn )

Animate ASCII art logo.

Parameter

slideIn Set to 1 for slide in from top, 0 for slide out.

Definiert in Zeile 378 der Datei system.c.

Benutzt consoleBufferWidth, consoleClear() und printfBanner().

Wird benutzt von mainMenu().

                                {
     int i = (slideIn ? 5 : 0);
     while(i >= 0 && i <=5){
         consoleClear();
         printfBanner(consoleBufferWidth,i);
         Sleep(50);
         i += (slideIn ? -1 : +1);
     }
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void animateBox	(	int	wFrom,
		int	hFrom,
		int	wTo,
		int	hTo
	)

Change the horizontal align of the current line within the buffer box

Parameter

align Left align (-1), centered (0) or right align (+1).

Definiert in Zeile 392 der Datei system.c.

Benutzt printEmptyBox().

Wird benutzt von mainMenu() und showCredits().

                                                        {
     int w = wFrom;
     int h = hFrom;
     while(w < wTo){
         printEmptyBox(w,h);
         w++;
     }
     while(h < hTo){
         printEmptyBox(w,h);
         h++;
     }
     while(h > hTo){
         printEmptyBox(w,h);
         h--;
     }
     while(w > wTo){
         printEmptyBox(w,h);
         w--;
     }
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void animateFalling	(	struct board *	currBoard,
		unsigned int	xPos,
		char	CoinType
	)

this Method animates a falling Coin by moving the coin one field lower than wait and repeat this until there's another coin or it reaches the end of the board This Method fully cleans the board up after finishing–>means: after execution the board will look like nothing ever happened. The animated coin is not saved permanetly saved on the board

Parameter

xPos	the row in which the coin is going to fall
currBoard	the board with the current game state
CoinType	variable to determine if the current Player has 'X' or '0' as Coin

final clean up deleting the last coin if this last part of the code will be deleted the last position of the coin will be permantely saved on the supplied board

Definiert in Zeile 446 der Datei gamefunction.c.

Benutzt calcFieldAddress(), drawBoard(), FIELD_EMPTY, FIELD_PLAYER1 und board::height.

                                                                             {
     //determing which type of coin is going to fall
     char coin;
     if(CoinType == FIELD_PLAYER1){
         coin='X';
     }else{
         coin='O';
     }
 
 
 
 
 
     unsigned int currY=currBoard->height-1;
     char* old;
     //(getField(currBoard,xPos,currY)!=FIELD_EMPTY)&&
     while((currY!=0)){
         //no deletions possible at first run of loop
         if(currY!=currBoard->height-1){
             //delete coin one field above
             old=calcFieldAddress(currBoard,xPos,currY+1);
             old=&FIELD_EMPTY;
         }
         //setting coin one field lower
         char* curr=calcFieldAddress(currBoard,xPos,currY);
             curr=&coin;
         currY--;
 
         drawBoard(currBoard);
         //improvised wait Method
         int x=0;
         for(x=0;x<1000000;x++){
             //funny nothing will ever happen here :D
             x=x;
         };
 
 
     }
     old=calcFieldAddress(currBoard,xPos,currY);
 //  &old=FIELD_EMPTY;
     old=FIELD_EMPTY;
     //return;
 
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

char* calcFieldAddress	(	struct board *	target,
		int	x,
		int	y
	)

Internal helper method to calculate the data offset of a given field on the board

Parameter

target	Board to base calculations on.
x	X-coordinate.
y	Y-coordinate.

Rückgabe: Pointer to requested field.

Definiert in Zeile 60 der Datei board.c.

Benutzt board::content und board::width.

Wird benutzt von animateFalling(), getField() und setField().

                                                            {
     int offset = y*(target->width) + x;
     return (target->content + offset);
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int checkDraw ( )

Checks if the board is full. Only possible if nobody has won earlier.

Rückgabe: 1 for game can go on - 0 for game ended with a draw

Definiert in Zeile 419 der Datei gamefunction.c.

Benutzt FIELD_EMPTY, gameField, gameFieldHeigth, gameFieldWidth und getField().

Wird benutzt von gameFunction().

                {
     int i =0;
     for(i=0;i<gameFieldWidth;i++){
         if(getField(&gameField,i,gameFieldHeigth-1) == FIELD_EMPTY){
             return 1;
         }
     }
     return 0;
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

char checkForWinner	(	int	x,
		int	y,
		char	player
	)

Look for a winner of the current game. First vertically, then horizontally and then the 2 diagonal rows. lineCount is the number of Coins which are neighbours.

Parameter

x	X-Position of last dropped coin.
y	Y-Position of last dropped coin.
player	The last coin which was dropped to the game, as the starting point of this algorithm.

Rückgabe: The winnig coin type is returned X or O.

Definiert in Zeile 356 der Datei gamefunction.c.

Benutzt FIELD_EMPTY und neighbourRow().

Wird benutzt von throwCoin().

                                               {
      // horizontal check first right then left summarized together
      int lineCount = 0;
      lineCount = 1 + neighbourRow(x+1,y,+1,0,player) + neighbourRow(x-1,y,-1,0,player);
      if(lineCount >= 4){
         return player;
      }
      else{
         lineCount=0;
      }
 
      // vertical check first up and then down summarized together
      lineCount = 1 + neighbourRow(x,y+1,0,1,player) + neighbourRow(x,y-1,0,-1,player);
      if(lineCount >= 4){
         return player;
      }
      else{
         lineCount=0;
      }
 
      // diagonal checks
 
      // first variant /
      lineCount = 1 + neighbourRow(x-1,y+1,-1,1,player) + neighbourRow(x+1,y-1,1,-1,player);
      if(lineCount >= 4){
         return player;
      }
      else{
         lineCount=0;
      }
      //second variant
      lineCount = 1 + neighbourRow(x+1,y+1,1,1,player) + neighbourRow(x-1,y-1,-1,-1,player);
      if(lineCount >= 4){
         return player;
      }
      else{
         lineCount=0;
      }
     return FIELD_EMPTY;
 
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void clearAll ( )

Clears all elements which are used within the gameflow Board, loop condition, positions

Rückgabe: no return because of void

Definiert in Zeile 171 der Datei gamefunction.c.

Benutzt clearBoard(), coinPosition, end, freeBoard(), gameField, gameFieldCreated, playersTurn und victor.

Wird benutzt von gameFunction().

                 {
     //clear board
     clearBoard(&gameField);
     freeBoard(&gameField);
     end = 0;
     //reset some variables
     victor = '\0';
     gameFieldCreated = 0; //set to 0, because board was deleted
     playersTurn = 0; //player1 starts the game
     coinPosition = 1; //where the coin is actually placed
     return;
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void clearBoard ( struct board * target )

Removes all chips from the board

Parameter

target Already existing board.

Definiert in Zeile 43 der Datei board.c.

Benutzt board::content, FIELD_EMPTY und board::numberOfFields.

Wird benutzt von clearAll() und newBoard().

                                       {
     //fills the whole board with space chars
     int i;
     for (i = 0; i < target->numberOfFields; i++) {
         *((target->content) + i) = FIELD_EMPTY;
     }
     //add null terminator which allows direct board content debug output
     *(target->content + i) = '\0';
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void consoleClear ( )

Clears the console

Definiert in Zeile 428 der Datei system.c.

Wird benutzt von animateBanner(), flushBuffer() und gameFunction().

                    {
     //should clear the console on most plattforms
     #ifdef _WIN32
     //detected windows System (both 32 and 64bit)-->use windows clear
         system("CLS");
     #else
     //detected other (non windows) System-->unse Unix-clear
         system("clear");
     #endif
 
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int copyChar	(	char *	src,
		char *	dst
	)

Copy one character (UTF8-aware) from the source string to the target string and append a null byte afterwards

Parameter

src	Source string pointer.
dst	Destination string pointer.

Rückgabe: Returns how many bytes were copied

Definiert in Zeile 114 der Datei system.c.

Benutzt LineItem::length.

Wird benutzt von output().

                                   {
 
     //determine the length of the string, see http://en.wikipedia.org/wiki/UTF-8#Description
     int bytes = 0;
     char slider = *src;
     while ((slider & 0x80) == 0x80){
         slider<<=1;
         bytes++;
     }
     bytes+=!bytes;
 
     //copy <bytes>-byte long character
     int cursor = 0;
     int length = bytes;
     while (length--){
         dst[cursor] = src[cursor];
         cursor++;
     }
 
     //append null byte and return length of copied data
     dst[cursor] = '\0';
     return bytes;
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void deleteLineItem	(	struct LineItem *	line,
		int	deleteAllBelow
	)

Delete the given line from the buffer

Parameter

line	Pointer to the line struct to delete.
deleteAllBelow	Delete all the following lines as well (1) or just the given line (0).

Definiert in Zeile 84 der Datei system.c.

Benutzt display, OutBuffer::lineCount, LineItem::next, LineItem::prev und LineItem::text.

Wird benutzt von flushBuffer() und startBuffer().

                                                               {
     if (line==NULL){
         return;
     }
 
     if (!deleteAllBelow){
         //fix the chain by connecting the following line to the previous
         if (line->prev!=NULL){
             line->prev->next = line->next;
         }
     } else {
         //recursive delete requested
         if (line->next!=NULL){
             deleteLineItem(line->next,1);
         }
         if (line->prev!=NULL){
             line->prev->next = NULL;
         }
     }
     free(line->text);
     free(line);
     display.lineCount--;
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void drawBoard ( struct board * target )

Outputs a graphical representation of the given board to the console

Parameter

target Board to draw.

Definiert in Zeile 103 der Datei board.c.

Benutzt EXITCODE_OUTOFMEMORY, FIELD_EMPTY, FIELD_PLAYER1, FIELD_PLAYER2, FONT_COIN_EMPTY, FONT_COIN_PLAYER1, FONT_COIN_PLAYER2, FONT_DPIPE_BOTTOM_LEFT, FONT_DPIPE_BOTTOM_RIGHT, FONT_DPIPE_CROSSING, FONT_DPIPE_HORI_BAR, FONT_DPIPE_TBAR_DOWN, FONT_DPIPE_TBAR_LEFT, FONT_DPIPE_TBAR_RIGHT, FONT_DPIPE_TBAR_UP, FONT_DPIPE_TOP_LEFT, FONT_DPIPE_TOP_RIGHT, FONT_DPIPE_VERT_BAR, getField(), board::height, output(), strcatRepeat() und board::width.

Wird benutzt von animateFalling(), gameFunction() und playerAction().

                                      {
     //calculate dimensions of output and reserve memory
     char* canvas;
 
     //4 chars wide per field plus ending bar and newline
     int charsWidth  = target->width*4 + 2;
     //4 chars wide per field plus stand
     int charsHeight = target->height*2 + 3;
     //multiply by 6 for full UTF-8 eventualities plus 1 for string terminator \0
     int totalSize = charsWidth*charsHeight*6 + 1;
 
     canvas = malloc(totalSize * sizeof(char));
 
     if (canvas==NULL) {
         exit(EXITCODE_OUTOFMEMORY);
     }
 
     //writing-to-canvas setup
     canvas[0] = '\0';
 
     int fieldX;
     int fieldY;
 
     //loop over rows and build 2 console lines (grid + values) per loop
     for(fieldY = target->height - 1; fieldY >= 0; fieldY--) {
 
         //grid row
         for(fieldX = 0; fieldX < target->width; fieldX++) {
             if (fieldY == target->height - 1 && fieldX == 0) {
                 strcat(canvas,FONT_DPIPE_TOP_LEFT);
             } else if (fieldY == target->height - 1) {
                 strcat(canvas,FONT_DPIPE_TBAR_DOWN);
             } else if (fieldX == 0) {
                 strcat(canvas,FONT_DPIPE_TBAR_RIGHT);
             } else {
                 strcat(canvas,FONT_DPIPE_CROSSING);
             }
             strcatRepeat(canvas,FONT_DPIPE_HORI_BAR,3);
         }
 
         //end of grid row
         if (fieldY == target->height - 1) {
             strcat(canvas,FONT_DPIPE_TOP_RIGHT);
         } else {
             strcat(canvas,FONT_DPIPE_TBAR_LEFT);
         }
         strcat(canvas,"\n");
 
         //value row
         for(fieldX = 0; fieldX < target->width; fieldX++) {
             strcat(canvas,FONT_DPIPE_VERT_BAR);
             strcat(canvas," ");
             char field = getField(target,fieldX,fieldY);
             if (field==FIELD_EMPTY)   strcat(canvas,FONT_COIN_EMPTY);
             if (field==FIELD_PLAYER1) strcat(canvas,FONT_COIN_PLAYER1);
             if (field==FIELD_PLAYER2) strcat(canvas,FONT_COIN_PLAYER2);
             strcat(canvas," ");
         }
 
         //finish value row
         strcat(canvas,FONT_DPIPE_VERT_BAR);
         strcat(canvas,"\n");
 
     }
 
     //build stand
     for(fieldX = 0; fieldX < target->width; fieldX++) {
         if (fieldX == 0) {
             strcat(canvas,FONT_DPIPE_TBAR_RIGHT);
             strcatRepeat(canvas,FONT_DPIPE_HORI_BAR,3);
         } else {
             strcat(canvas,FONT_DPIPE_TBAR_UP);
             strcatRepeat(canvas,FONT_DPIPE_HORI_BAR,3);
         }
     }
     strcat(canvas,FONT_DPIPE_TBAR_LEFT);
     strcat(canvas,"\n");
     for(fieldX = 0; fieldX < target->width; fieldX++) {
         if (fieldX == 0) {
             strcat(canvas,FONT_DPIPE_BOTTOM_LEFT);
             strcatRepeat(canvas,FONT_DPIPE_HORI_BAR,3);
         } else {
             strcatRepeat(canvas,FONT_DPIPE_HORI_BAR,4);
         }
     }
     strcat(canvas,FONT_DPIPE_BOTTOM_RIGHT);
     strcat(canvas,"\n");
 
     //we're done, output the whole thing
     output("%s",canvas);
     free(canvas);
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void drawCoin	(	int	pos,
		char	CoinType
	)

Draws the Coin above the board

Parameter

pos	which position should the coin be drawn to.
coinType	which coin should be drawn.

Rückgabe: no return because of void

Definiert in Zeile 291 der Datei gamefunction.c.

Benutzt EXITCODE_OUTOFMEMORY, FIELD_PLAYER1, FONT_COIN_PLAYER1, FONT_COIN_PLAYER2, gameFieldWidth und output().

Wird benutzt von playerAction().

                                      {
     int i;
     char *canvas;
     canvas = malloc((gameFieldWidth * 4) * sizeof(char));
     //if alloc failed return
     if (canvas==NULL) {
         exit(EXITCODE_OUTOFMEMORY);
     }
     //writing-to-canvas setup (clear string)
     canvas[0] = '\0';
     //keep boundaries
     if (pos < gameFieldWidth || pos > 1) {
         strcat(canvas,"(");
         for(i = 1; i <= gameFieldWidth; i++) {
             //if the coin should be placed draw it
             if (i == pos) {
                 strcat(canvas," ");
                 if(CoinType == FIELD_PLAYER1){
                     strcat(canvas,FONT_COIN_PLAYER1);
                 }else{
                     strcat(canvas,FONT_COIN_PLAYER2);
                 }
 
                 strcat(canvas," ");
             }else{
                 //draw empty
                 strcat(canvas,"    ");
             }
         }
         strcat(canvas,")\n");
         //we're done, output the whole thing
         output("%s",canvas);
     }
     //free memory
     free(canvas);
     return;
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void drawLeftArrow	(	char *	menu,
		int	pPos
	)

This method manipulates the array so the left arrow (to indicate the cursor position) is added to the array.

Parameter

menu	contains the pointer to the char-array containing main menu in it's current status
pPos	contains the cursor Position of the cursor

Definiert in Zeile 11 der Datei mainMenu.c.

Wird benutzt von drawMainMenu().

                                        {
 #ifndef DEBUG
             if (pPos>1) pPos--;
 #endif // DEBUG
             menu[pPos*20]='-';
             menu[pPos*20+1]='>';
             menu[pPos*20+2]=' ';
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void drawMainMenu ( )

void drawRightArrow	(	char *	menu,
		int	pPos
	)

This method manipulates the array so the right arrow (to indicate the cursor position) is added to the array.

Parameter

menu	contains the pointer to the char-array containing main menu in it's current status
pPos	contains the cursor Position of the cursor

Definiert in Zeile 24 der Datei mainMenu.c.

Wird benutzt von drawMainMenu().

                                         {
 #ifndef DEBUG
             if (pPos>1) pPos--;
 #endif // DEBUG
             menu[(pPos+1)*20-2]='-';
             menu[(pPos+1)*20-3]='<';
             menu[(pPos+1)*20-4]=' ';
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int extractMoves ( char * line )

This function extracts the number of moves of the parameter line.

Parameter

line	Pointer to char array (string).

Rückgabe: moves Just the moves as an int.

Definiert in Zeile 160 der Datei hallofshame.c.

Benutzt moves.

Wird benutzt von updateSaveHoS().

                             {
     char work[60];
     strcpy(work,line);
     int moves =0;
     char *partOfLine;
     partOfLine = strtok(work, ",");
     int i =0 ;
     while(partOfLine != NULL) {
         switch (i%3) {
         case 2:
             moves = atoi(partOfLine);
             break;
         default:
             break;
         }
         partOfLine = strtok(NULL, ",");
         i++;
     }
     return moves;
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void flushBuffer ( )

Prints the screen (output buffer) and clears the buffer

Definiert in Zeile 188 der Datei system.c.

Benutzt LineItem::align, consoleBufferHeight, consoleBufferWidth, consoleClear(), csbi, deleteLineItem(), display, EXITCODE_BUFFERERROR, EXITCODE_OUTOFMEMORY, FANCY_FONT, OutBuffer::first, FONT_DPIPE_BOTTOM_LEFT, FONT_DPIPE_BOTTOM_RIGHT, FONT_DPIPE_HORI_BAR, FONT_DPIPE_TOP_LEFT, FONT_DPIPE_TOP_RIGHT, FONT_DPIPE_VERT_BAR, OutBuffer::hAlign, initBuffer(), OutBuffer::last, LineItem::length, OutBuffer::lineCount, OutBuffer::maxTextLength, LineItem::next, printfBanner(), strcatRepeat(), LineItem::text, UTF_MULTIPLIER und OutBuffer::vAlign.

Wird benutzt von addFrame(), drawMainMenu(), gameFunction(), mainMenuReactToEnter(), playerAction(), printEmptyBox(), showCredits(), showHallOfShame() und showRules().

                   {
     if (display.first==NULL || display.last==NULL){
         exit(EXITCODE_BUFFERERROR);
     }
 
     if(GetConsoleScreenBufferInfo(GetStdHandle( STD_OUTPUT_HANDLE ),&csbi)) {
         consoleBufferWidth = csbi.dwSize.X;
         consoleBufferHeight = csbi.dwSize.Y;
         if(!FANCY_FONT){
             consoleBufferHeight = 23;
         }
     }
 
     consoleClear();
 
     /*### DEBUGGING START ###*/
 #ifdef DEBUG
 //  static int flushed = 0;
 //  printf("DEBUG: printing %d-line buffer (%d.)",display.lineCount,++flushed);
 //  struct LineItem* debugchain = display.first;
 //  printf(", chain: %d",(int)debugchain);
 //  do {
 //      printf("(%d)->%d",debugchain->length,(int)debugchain->next);
 //      debugchain = debugchain->next;
 //  } while (debugchain!=NULL);
 //  printf(". [END:%d]\n--------------------------------------------------\n",(int)display.last);
 #endif // DEBUG
     /*### DEBUGGING END ###*/
 
     int i;
 
     if (display.vAlign==0){
         int marginTopSize = consoleBufferHeight/2 - display.lineCount/2 -1;
         if (marginTopSize > 5){
             printfBanner(consoleBufferWidth,0);
             marginTopSize -= 5;
         }
         for(i = 0; i < marginTopSize; i++){
             printf("\n");
         }
     }
 
     struct LineItem* current = display.first;
     const int MAX_CHARS_BORDER = 4;
     const int MAX_BYTES_PER_LINE = (display.maxTextLength + MAX_CHARS_BORDER + 1) * sizeof(char) * UTF_MULTIPLIER;
     char* collector = malloc(display.lineCount * MAX_BYTES_PER_LINE + 1);
     if (collector==NULL){
         exit(EXITCODE_OUTOFMEMORY);
     }
     collector[0] = '\0';
 
     //calculate left margin for box position
     int leftMarginSize = 1;
     if (display.hAlign==0){
         leftMarginSize = consoleBufferWidth/2 - display.maxTextLength/2 - 1;
     }
     char* leftMargin = malloc(sizeof(char)*leftMarginSize+1);
     if (leftMargin==NULL){
         exit(EXITCODE_OUTOFMEMORY);
     }
     memset(leftMargin,' ',leftMarginSize);
     leftMargin[leftMarginSize] = '\0';
 
     //draw header line
     strcat(collector,leftMargin);
     strcat(collector,FONT_DPIPE_TOP_LEFT);
     for (i = 0; i < display.maxTextLength; i++){
         strcat(collector,FONT_DPIPE_HORI_BAR);
     }
     strcat(collector,FONT_DPIPE_TOP_RIGHT);
     strcat(collector,"\n");
 
     //temporary:
     printf("%s",collector);
     collector[0] = '\0';
 
     //draw lines
     int leftPaddingSize = 0;
     int rightPaddingSize;
 
     while (current!=NULL){
         //padding calculations
         switch (current->align){
         case -1:
             leftPaddingSize = 0;
             break;
         case 0:
             leftPaddingSize = display.maxTextLength/2 - current->length/2;
             break;
         case +1:
             leftPaddingSize = display.maxTextLength - current->length;
             break;
         }
         rightPaddingSize = display.maxTextLength - current->length - leftPaddingSize;
 
         //left border and left padding
         strcat(collector,leftMargin);
         strcat(collector,FONT_DPIPE_VERT_BAR);
         strcatRepeat(collector," ",leftPaddingSize);
         //text
         strcat(collector,current->text);
         //right padding and right border
         strcatRepeat(collector," ",rightPaddingSize);
         strcat(collector,FONT_DPIPE_VERT_BAR);
         strcat(collector,"\n");
         current = current->next;
         //temporary:
         printf("%s",collector);
         collector[0] = '\0';
     }
     //draw footer line
     strcat(collector,leftMargin);
     strcat(collector,FONT_DPIPE_BOTTOM_LEFT);
     for (i = 0; i < display.maxTextLength; i++){
         strcat(collector,FONT_DPIPE_HORI_BAR);
     }
     strcat(collector,FONT_DPIPE_BOTTOM_RIGHT);
 
     printf("%s",collector);
     collector[0] = '\0';
 
     free(collector);
 
     deleteLineItem(display.first, 1);
     initBuffer();
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void freeBoard ( struct board * target )

Frees memory taken by a board (warning: makes it unusable until newBoard() has been called again)

Parameter

target Board to free memory.

Definiert in Zeile 95 der Datei board.c.

Benutzt board::content.

Wird benutzt von clearAll().

                                      {
     free(target->content);
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void gameFunction ( )

gameFunction first forces users to enter their names and checks them for different mistakes after that startGame() is called within the gameloop, which processes the main game flow last but not least we check for a winner or check for draw and continue to Hall of Shame.

Rückgabe: no return because of void

Definiert in Zeile 28 der Datei gamefunction.c.

Benutzt checkDraw(), clearAll(), consoleClear(), drawBoard(), end, FIELD_PLAYER1, FIELD_PLAYER2, flushBuffer(), gameField, irand(), lower_to_upper(), moves, NO_HIGHLIGHT, output(), player1, player2, playersTurn, showHallOfShame(), startBuffer(), startGame(), updateSaveHoS() und victor.

Wird benutzt von mainMenuReactToEnter().

                    {
     moves = 0;
     playersTurn = irand(0,1);
     char keyStrokeName[2];
     keyStrokeName[1] = '\0';
     player1[0] = '\0';
     player2[0] = '\0';
     /*
         player1 name
         loop as long player did not press enter
     */
     do {
         //check length
         if (strlen(player1)>=19)
             break;
         //buffer
         startBuffer(50);
         output("Please enter a name for Player 1: \n");
         output("> %s_\n", player1);
         //flush buffer
         flushBuffer();
         //wait for a new char and give it to var
         keyStrokeName[0] = getch();
         //check for special inputs
         if ((keyStrokeName[0] == '\b') && (strlen(player1)) > 0) {
             //if backspace was entered
             player1[strlen(player1)-1] = '\0'; //set nilbyte to pointer-1
         }
         else if (keyStrokeName[0] == '\r') {} //if enter do nothing
         else if ((keyStrokeName[0] == '\b') && (strlen(player1)) == 0) {} //if string empty and backspace entered do nothing
         else {
             keyStrokeName[0] = lower_to_upper(keyStrokeName[0]);
             strcat(player1, keyStrokeName);
         }
     } while(((keyStrokeName[0] != '\r') && (player1[0] != '\0') && !(strlen(player1)>15)) || (strlen(player1)<3));
     /*
         player2 name
         loop as long player did not press enter
     */
     do {
         //check length
         if (strlen(player1)>=19)
             break;
         //buffer
         startBuffer(55);
         output("Please enter a name for Player 1: \n");
         output("%s\n\n", player1);
         output("Please enter a name for Player 2: \n");
         output("> %s_\n", player2);
         //flush buffer
         flushBuffer();
         //wait for a new char and give it to var
         keyStrokeName[0] = getch();
         //check for special inputs
         if ((keyStrokeName[0] == '\b') && (strlen(player2)) > 0) {
             //if backspace was entered
             player2[strlen(player2)-1] = '\0'; //set nilbyte to pointer-1
         }
         else if (keyStrokeName[0] == '\r') {} //if enter do nothing
         else if ((keyStrokeName[0] == '\b') && (strlen(player2)) == 0) {} //if string empty and backspace entered do nothing
         else {
             keyStrokeName[0] = lower_to_upper(keyStrokeName[0]);
             strcat(player2, keyStrokeName);
         }
     } while(((keyStrokeName[0] != '\r') && (player2[0] != '\0') && !(strlen(player2)>15)) || (strlen(player2)<3));
     //check that player1 and player2 names are not the same
     if (strcmp(player1, player2)==0) {
         player2[(strlen(player2))] = '1'; // add a symbolic 1 to the end of the name ;-)
         player2[(strlen(player2))+1] = '\0';
     }
     //start buffer for completion
     startBuffer(55);
     output("Thank you %s and %s! The game will start now.\n\nPlease press enter to continue...", player1, player2);
     flushBuffer();
     //wait for a key
     getch();
     //Loop till the game is done
     int winnerLine =NO_HIGHLIGHT;
     while(end == 0){
         // start the game flow
         startGame();
         //check for winners or draw
         if( victor == FIELD_PLAYER1){
             end = 1;
             moves =  (moves/2)+(moves%2);
             consoleClear();
             startBuffer(50);
             drawBoard(&gameField);
             winnerLine = updateSaveHoS(player1,player2,moves);
             //output victor
             output("%s has won!\n\n", player1);
             output("Press any key to continue to Hall of Shame...\n");
             //show all
             flushBuffer();
             //wait for any keystroke
             getch();
             //continue to hall of shame
             showHallOfShame(winnerLine,winnerLine-4);
         }
         else if( victor == FIELD_PLAYER2){
             end = 1;
             moves = (moves/2)+(moves%2);
             consoleClear();
             startBuffer(50);
             drawBoard(&gameField);
             winnerLine = updateSaveHoS(player2,player1,moves);
             //output victor
             output("%s has won!\n\n", player2);
             output("Press any key to continue to Hall of Shame...\n");
             //show all
             flushBuffer();
             //wait for any keystroke
             getch();
             //continue to hall of shame
             showHallOfShame(winnerLine, winnerLine-4);
         }
         if(checkDraw() == 0){
             end = 1;
             consoleClear();
             startBuffer(50);
             drawBoard(&gameField);
             //output draw
             output("Game ended with a draw...\n\n");
             output("Press any key to continue to Hall of Shame...\n");
             //show all
             flushBuffer();
             //wait for any keystroke
             getch();
             //continue to hall of shame
             showHallOfShame(NO_HIGHLIGHT,0);
         }
     }
 
     //free our game-board
     clearAll();
     return;
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

char getField	(	struct board *	target,
		int	x,
		int	y
	)

Gets what is on a given field of the board (returns FIELD_XYZ constant)

Parameter

target	Board to read.
x	X-coordinate.
y	Y-coordinate.

Rückgabe: Value of requested field.

Definiert in Zeile 72 der Datei board.c.

Benutzt calcFieldAddress(), FIELD_OUTOFBOUNDS, board::height und board::width.

Wird benutzt von checkDraw(), drawBoard(), neighbourRow() und throwCoin().

                                                   {
     if (x<0 || y<0 || x>=target->width || y>=target->height)
     {
         return FIELD_OUTOFBOUNDS;
     }
     return *calcFieldAddress(target, x, y);
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int getOldFileLength ( )

Determine the length of the current HallOfShame.dat file.

Rückgabe: len Just the length of the HoS as an int.

Definiert in Zeile 185 der Datei hallofshame.c.

Wird benutzt von updateSaveHoS().

 {
     FILE *f = fopen("HallOfShame.dat", "rb");
 
     if (f == NULL || ferror(f))
     {
         if (f)
             fclose(f);
         return -1;
     }
 
     fseek(f, 0, SEEK_END);
     int len = ftell(f);
     fclose(f);
     return len;
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void HelloWorld ( )

Definiert in Zeile 5 der Datei dummy.c.

Benutzt output() und testerVariable.

 {
     output("Hello World! (%i)\n",testerVariable);
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

void initBuffer ( )

Initializes buffering Warning: Only call once at program start

Definiert in Zeile 15 der Datei system.c.

Benutzt display, OutBuffer::first, OutBuffer::hAlign, OutBuffer::last, OutBuffer::lineCount und OutBuffer::vAlign.

Wird benutzt von flushBuffer().

                  {
     //set text size maximum and insert a first empty line
     display.first = NULL;
     display.last = NULL;
     display.lineCount = 0;
     display.vAlign = 0;
     display.hAlign = 0;
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

struct LineItem* insertNewLineItem	(	struct LineItem *	prev,
		struct LineItem *	next,
		int	maxTextLength
	)

Add a new line to the buffer, may be inserted in the middle or appended to the end Info: Horizontal align is inherited from previous line, default -1. Can be changed with setLineAlign() Warning: Use output() to add text, this method is only used internally

Parameter

prev	Pointer to the previous line struct, NULL appends line to start of buffer.
next	Pointer to the next line struct, NULL if this is the last element (most used case).
align	Text align for the new line, -1 is left aligned, 0 is centered, +1 is right aligned.
maxTextLength	Maximum number of characters for this line.

Rückgabe: Pointer to new created struct.

Definiert in Zeile 34 der Datei system.c.

Benutzt LineItem::align, LineItem::byteSize, display, EXITCODE_OUTOFMEMORY, OutBuffer::first, OutBuffer::last, LineItem::length, OutBuffer::lineCount, LineItem::next, LineItem::prev, LineItem::text und UTF_MULTIPLIER.

Wird benutzt von output() und startBuffer().

                                                                                                    {
 
     //allocate memory for line item
     struct LineItem* newLine = malloc(sizeof(struct LineItem));
     if (newLine==NULL){
         exit(EXITCODE_OUTOFMEMORY);
     }
 
     //allocate memory for text
     newLine->text = malloc(maxTextLength * sizeof(char) * UTF_MULTIPLIER + 1);
     if (newLine->text==NULL){
         exit(EXITCODE_OUTOFMEMORY);
     }
     newLine->text[0] = '\0';
 
     //set line properties
     newLine->align = (prev!=NULL?prev->align:-1);
     newLine->byteSize = 0;
     newLine->length = 0;
 
     //relink previous item if given
     newLine->prev = prev;
     if (prev!=NULL){
         newLine->prev->next = newLine;
     }
 
     //chain to next item if given
     newLine->next = next;
     if (newLine->next!=NULL){
         newLine->next->prev = newLine;
     }
 
     //update buffer's first&last pointers
     if (prev==NULL){
         display.first = newLine;
     }
     if (next==NULL){
         display.last = newLine;
     }
 
     //update line count and return created line
     display.lineCount++;
     return newLine;
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int irand	(	int	a,
		int	e
	)

Get random integer a<=x<=e

Parameter

a	Lowest value for x.
e	Highest value for x.

Rückgabe: Random integer

Definiert in Zeile 433 der Datei gamefunction.c.

Wird benutzt von gameFunction().

                         {
     double r = e - a + 1;
     return a + (int)(r * rand()/(RAND_MAX+1.0));
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

char lower_to_upper ( char ch1 )

convert string to upper string

Parameter

ch1	string to be uppered

Rückgabe: ch2 is upper case char

Definiert in Zeile 444 der Datei system.c.

Wird benutzt von gameFunction().

 {
       char ch2;
 
       if(ch1 >= 'a' && ch1 <= 'z'){
             ch2 = ('A' + ch1 - 'a');
             return ch2;
       }
       else{
             ch2 = ch1;
             return ch2;
       }
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int mainMenu ( )

Parameter

con
pPos

Definiert in Zeile 62 der Datei mainMenu.c.

Benutzt animateBanner(), animateBox(), con, drawMainMenu() und mainMenuReactToEnter().

Wird benutzt von drawMainMenu() und main().

               {
     //describes where the cursor is, default location is 0(NEW GAME)
     int pPos=0;
     //as long as this variable is one the loop won't finish
     con=1;
     animateBanner(1);
     animateBox(1,1,25,8);
     // menu loop
     while(con){
         drawMainMenu(pPos);
         switch(getch()) {
             case 72:    // key up
                 pPos--;
 #ifndef DEBUG
                 if (pPos==1) pPos--; //settings temporarily disabled
 #endif // DEBUG
                 break;
             case 80:    // key down
                 pPos++;
 #ifndef DEBUG
                 if (pPos==1) pPos++; //settings temporarily disabled
 #endif // DEBUG
                 break;
             case 77:    // key right
                 break;
             case 75:    // key left
                 break;
             case 13: // key enter
                 mainMenuReactToEnter(pPos);
                 break;
             case 27: //escape
             //  exit(0);
                 con=0;
                 break;
         }
         fflush(stdin);
         if(pPos>5){
             //cursor is "below" the menu-->get him back
             pPos=0;
         } else if(pPos<0){
             //cursor is the "over" the menu-->get him back
             pPos=5;
         }
 
     }
     animateBox(25,8,1,1);
     animateBanner(0);
     return 0;
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void mainMenuReactToEnter ( int pPos )

this method handles the game flow by calling the function corresponding to the cursor posotion within the menu

Parameter

pPos	contains the current position (0:Top,4:bottom)

Definiert in Zeile 115 der Datei mainMenu.c.

Benutzt con, flushBuffer(), gameFunction(), NO_HIGHLIGHT, output(), showCredits(), showHallOfShame(), showRules() und startBuffer().

Wird benutzt von mainMenu().

                                    {
     switch(pPos){
         case 0:
             gameFunction();
             break;
         case 1:
             startBuffer(60);
             output("Settings Menu(Dummy)\nPress any key to return to main\n");
             flushBuffer();
             getch();
             break;
         case 2:
             showRules();
             break;
         case 3:
             showHallOfShame(NO_HIGHLIGHT,0);
             break;
         case 4:
             showCredits();
             break;
         case 5:
             //end game
             con=0;
             //exit(0);
     }
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int neighbourRow	(	int	x,
		int	y,
		int	xMovement,
		int	yMovement,
		char	player
	)

Recursive function to sum up the coins which are connected in a row.

Parameter

x	X-Position of last dropped coin.
y	Y-Position of last dropped coin.
xMovement	This is used to build a "vector"
yMovement	This is used to build a "vector"
player	The cointype to count in a row.

Rückgabe: Number of coins which are connected.

Definiert in Zeile 406 der Datei gamefunction.c.

Benutzt gameField, getField() und neighbourRow().

Wird benutzt von checkForWinner() und neighbourRow().

                                                                          {
     if (getField(&gameField,x,y) == player){
         return 1 + neighbourRow(x+xMovement,y+yMovement,xMovement,yMovement,player);
     }
     else{
         return 0;
     }
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int newBoard	(	struct board *	target,
		unsigned int	width,
		unsigned int	height
	)

Creates new clean and usable board (including memory allocation) Warning: To resize an existing board call freeBoard() before to prevent memory leak

Parameter

target	Pointer to a fresh board structure.
width	Board width (>=4).
height	Board height (>=4).

Rückgabe: 1 on success, otherwise 0.

Definiert in Zeile 15 der Datei board.c.

Benutzt clearBoard(), board::content, EXITCODE_OUTOFMEMORY, board::height, board::numberOfFields und board::width.

Wird benutzt von startGame().

 {
     //sanity check
     if (width<4 || height<4) {
         return 0;
     }
 
     //Initialize board
     target->width = width;
     target->height = height;
     target->numberOfFields = width*height;
     target->content = malloc(target->numberOfFields * sizeof(char) + 1);
 
     //abort if memory allocation failed
     if (target->content == NULL) {
         exit(EXITCODE_OUTOFMEMORY);
     }
 
     //board is ready, now clear it
     clearBoard(target);
 
     return 1;
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int output	(	const char *	input,
			...
	)

Add text to output buffer, use EXACTLY like printf()

Parameter

input	Format string, see printf().
...	Parameters, see printf().

Rückgabe: Return value of internal vsnprintf().

Definiert in Zeile 144 der Datei system.c.

Benutzt LineItem::byteSize, copyChar(), display, EXITCODE_BUFFERERROR, OutBuffer::first, insertNewLineItem(), OutBuffer::last, LineItem::length, OutBuffer::maxTextLength, LineItem::next, OUTPUT_MAXBUFFER und LineItem::text.

Wird benutzt von addFrame(), drawBoard(), drawCoin(), drawMainMenu(), gameFunction(), HelloWorld(), mainMenuReactToEnter(), playerAction(), printEmptyBox(), showCredits(), showHallOfShame() und showRules().

                                   {
     if (display.first==NULL || display.last==NULL){
         exit(EXITCODE_BUFFERERROR);
     }
 
     int result;
     va_list args;
     va_start(args, input);
     va_end(args);
 
     //writing to string buffer
     char buffer[OUTPUT_MAXBUFFER+1];
     buffer[0] = '\0';
     result = vsnprintf(buffer, OUTPUT_MAXBUFFER+1, input, args);
 
     //keep track of string buffer position and the current line to write to
     int i = 0;
     struct LineItem* current = display.last;
 
     //loop through buffer and copy to lines
     while(buffer[i]!='\0'){
         if (current->length < display.maxTextLength && buffer[i]!='\n'){
             //line not full yet, copy char
             int increase = copyChar(buffer+i, current->text+current->byteSize);
             i += increase;
             current->byteSize += increase;
             current->length++;
         } else {
             //end line in input: start new line
             if (buffer[i]=='\n'){
                 i++;
             }
             //end line or line full, create new one
             current->next = insertNewLineItem(current, NULL, display.maxTextLength);
             current = current->next;
         }
     }
 
     return result;
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void playerAction ( )

playerAction()

checks which player's turn it is
shows X or O for a game-chip
- player1 (X) or player2 (O) can move the coin to the left or right (check boundaries, also if row is full) and let it fall (space)
- stop coin at highest existing coin
- check if any user has won (function needs to be implemented) according to https://github.com/wagnst/4-gewinnt/issues/10
  Rückgabe
  no return because of void

Definiert in Zeile 194 der Datei gamefunction.c.

Benutzt coinPosition, drawBoard(), drawCoin(), end, EXITCODE_OUTOFMEMORY, FIELD_PLAYER1, FIELD_PLAYER2, flushBuffer(), gameField, gameFieldWidth, moves, output(), player1, player2, playersCoin, playersTurn, setLineAlign(), startBuffer(), throwCoin() und userInput.

Wird benutzt von startGame().

                     {
     char *spaceBetweenNames;
     spaceBetweenNames = malloc((gameFieldWidth * 3) * sizeof(char));
     //if alloc failed return
     if (spaceBetweenNames==NULL) {
         exit(EXITCODE_OUTOFMEMORY);
     }
     //check which players turn it is and sets the coin
     playersCoin = '\0';
     //output buffer
     startBuffer(50);
     if (playersTurn == 0) {
         setLineAlign(-1);
         output("%s's turn\n\n", player1);
         playersCoin = FIELD_PLAYER1;
     }else{
         setLineAlign(+1);
         output("%s's turn\n\n", player2);
         playersCoin = FIELD_PLAYER2;
     }
     setLineAlign(0);
     //draw the coin
     drawCoin(coinPosition, playersCoin);
     //draw the board
     drawBoard(&gameField);
     //end buffer
     flushBuffer();
     userInput = getch();
     switch(userInput){
         //dummy for key left
         case 75: //left
             if (coinPosition > 1)
                 coinPosition--;
             break;
         //dummy for key right
         case 77: //right
             if (coinPosition < gameFieldWidth)
                 coinPosition++;
             break;
         case 27: //escape
             //go back to menu
             end = 1;
             break;
         //let coin fall
         case 13: //enter key
             throwCoin(coinPosition, playersCoin);
             moves++;
             break;
     }
     free(spaceBetweenNames);
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void printEmptyBox	(	int	w,
		int	h
	)

Print an empty buffer box with the given size

Parameter

w	Width.
h	Height.

Definiert in Zeile 418 der Datei system.c.

Benutzt flushBuffer(), output() und startBuffer().

Wird benutzt von animateBox().

                                 {
     int i;
     startBuffer(w);
     for (i = 0; i < h; i++) output("\n");
     flushBuffer();
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void printfBanner	(	int	width,
		int	startAt
	)

Printf-s ASCII art logo

Parameter

width	Width for padding with spaces.
startAt	Value between 0 and 4 for partial display, see animateBanner().

Definiert in Zeile 356 der Datei system.c.

Benutzt LineItem::length und strcatRepeat().

Wird benutzt von animateBanner() und flushBuffer().

                                          {
     int length = 57;
     char* banner[5];
     banner[0] = "_________                              _____     _____ __\n";
     banner[1] = "__  ____/________________________________  /_    __  // /\n";
     banner[2] = "_  /    _  __ \\_  __ \\_  __ \\  _ \\  ___/  __/    _  // /_\n";
     banner[3] = "/ /___  / /_/ /  / / /  / / /  __/ /__ / /_      /__  __/\n";
     banner[4] = "\\____/  \\____//_/ /_//_/ /_/\\___/\\___/ \\__/        /_/   \n";
     int i;
     char* bannerBuffer = malloc(sizeof(char)*(width+1)*5);
     bannerBuffer[0] = '\0';
     for(i = startAt; i<5; i++){
         strcatRepeat(bannerBuffer," ",width/2-length/2-1);
         strcat(bannerBuffer,banner[i]);
     }
     printf("%s",bannerBuffer);
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void setFancy ( )

void setField	(	struct board *	target,
		int	x,
		int	y,
		char	value
	)

Sets what is on a given field of the board (see FIELD_XYZ constants)

Parameter

target	Board to change.
x	X-coordinate.
y	Y-coordinate.
value	Field value (FIELD_EMPTY/FIELD_PLAYER1/FIELD_PLAYER2).

Definiert in Zeile 87 der Datei board.c.

Benutzt calcFieldAddress().

Wird benutzt von throwCoin().

                                                               {
     *calcFieldAddress(target, x, y) = value;
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void setLineAlign ( int align )

Change the horizontal align of the current line within the buffer box

Parameter

align Left align (-1), centered (0) or right align (+1).

Definiert in Zeile 344 der Datei system.c.

Benutzt LineItem::align, display, EXITCODE_BUFFERERROR und OutBuffer::last.

Wird benutzt von drawMainMenu(), playerAction(), showCredits(), showHallOfShame() und showRules().

                             {
     if(display.last==NULL){
         exit(EXITCODE_BUFFERERROR);
     }
     display.last->align = align;
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void showCredits ( )

Show program credits

Definiert in Zeile 6 der Datei credits.c.

Benutzt animateBox(), flushBuffer(), output(), setLineAlign() und startBuffer().

Wird benutzt von mainMenuReactToEnter().

                    {
     animateBox(25,8,66,17);
     startBuffer(66);
     setLineAlign(0);
     output("____ ____ ____ ___  _ ___ ____ \n|    |__/ |___ |  \\ |  |  [__  \n|___ |  \\ |___ |__/ |  |  ___] \n\n");
     setLineAlign(-1);
     output("  Niko Berkmann | @n2code\n    n2code@users.noreply.github.com\n");
     setLineAlign(+1);
     output("Steffen Wagner | @wagnst  \nmail@wagnst.de    \n");
     setLineAlign(-1);
     output("  Marvin Klose | @marvinklose\n    marvinklose@gmx.net\n");
     setLineAlign(+1);
     output("Michael Wieneke | @momoxd  \nmail@momoxd.de    \n");
     setLineAlign(-1);
     output("  Inga Miadowicz | @IngaMiad\n    inga.miadowicz@gmx.de\n");
     setLineAlign(0);
     output("\nPress any key to return to main menu.\n");
     flushBuffer();
     getch();
     animateBox(66,17,25,8);
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void showHallOfShame	(	int	highlight,
		int	startFrom
	)

This function prints a certain number (c.f. HOS_LINES) of lines of the HallOfShame.dat to the console.

Parameter

highlight	Highlight a special line with "-> "
startFrom	The output is reduced to a constant number of lines (c.f. variables.h HOS_LINES). The parameter controls which lines actually are printed.

Definiert in Zeile 13 der Datei hallofshame.c.

Benutzt flushBuffer(), HOS_LINES, moves, output(), setLineAlign(), startBuffer(), userInput und victor.

Wird benutzt von gameFunction() und mainMenuReactToEnter().

                                                  {
     int viewHoS = 1;
     // correct the argument if necessary
     startFrom = startFrom > 0 ? startFrom : 0;
     while(viewHoS){
             //decalartions
         startBuffer(64);
         FILE *fh;
         char victor[20];
         char victim[20];
         char moves[4];
         //counting the lines
         int lineCounter = 0;
         //open file in read mode
         //or leave loop
         fh = fopen("HallOfShame.dat", "r");
         if (fh == NULL || ferror(fh)){
             if (fh){
                 fclose(fh);
                 break;
             }
         }
 
         setLineAlign(0);
         output("[ HALL OF SHAME ]\n\nWelcome to our Hall of Shame...\n");
         setLineAlign(-1);
         // notice if HoS is empty
         int somethingPrinted =0;
         while((fscanf(fh,"%19[^,],%19[^,],%2[^,^\n]",victor,victim,moves)) != EOF ) {
 
             while (victor[0] == '\n'){
                 memmove(victor, victor+1, strlen(victor));
             }
             if(lineCounter>=startFrom && lineCounter<=startFrom+HOS_LINES && strlen(victor)>0 && strlen(victim)>0){
                 if(highlight==lineCounter){
                 output("-->%d. %s busted %s with %s moves\n",lineCounter+1,victor,victim,moves);
                 somethingPrinted =1;
                 }
                 else{
                 output(" %d.   %s busted %s with %s moves\n",lineCounter+1,victor,victim,moves);
                 somethingPrinted =1;
                 }
             }
 
             lineCounter++;
         }
         fclose(fh);
         if(somethingPrinted == 0){
             output("   No entries.");
         }
         output("\n");
         setLineAlign(0);
         output("[...Press up/down for scrolling...]\n");
         output("[...Press  Enter/Escape to exit...]\n");
         flushBuffer();
         fflush(stdin);
         char userInput = getch();
         switch(userInput) {
                 case 72:    // key up
                     startFrom = startFrom-1 > 0 ? startFrom-1 : 0;
                     break;
                 case 80:    // key down
                     startFrom = startFrom+1 < lineCounter-HOS_LINES ? startFrom+1 : startFrom;
                     break;
 
                 case 13: // key enter
                     viewHoS=0;
                 break;
                 case 27: //escape
                     viewHoS =0;
                 //default:
                 //  viewHoS=0;
         }
         fflush(stdin);
     }
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void showRules ( )

Method to show the rules.User can leave this screen by pressing any key

Definiert in Zeile 35 der Datei rules.c.

Benutzt flushBuffer(), output(), setLineAlign() und startBuffer().

Wird benutzt von mainMenuReactToEnter().

                 {
     startBuffer(70);
     setLineAlign(0);
     output("[ RULES ]\n\n");
     setLineAlign(-1);
     output("This a implementation of the famous two player game \"Connect Four\".\nSo you'll need a friend to play this game :) To win you simply have to\nconnect four of your chips in a row. This row can be horizontal,\nvertical or diagonal,it doesn't matter as long as there are no \"enemy\"\nchips between your chips.\nThe game will automatically end if one you won and take you to the\n\"Hall of Shame\"\n\n");
     setLineAlign(0);
     output("[ Press any key to return to main menu ]\n");
     flushBuffer();
     getch();
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void startBuffer ( int maxTextLength )

Starts a new screen and sets line limit, empties the buffer

Parameter

maxTextLength See initBuffer().

Definiert in Zeile 319 der Datei system.c.

Benutzt consoleBufferWidth, deleteLineItem(), display, EXITCODE_BUFFERERROR, EXITCODE_WINDOWERROR, OutBuffer::first, insertNewLineItem(), OutBuffer::last, OutBuffer::lineCount und OutBuffer::maxTextLength.

Wird benutzt von drawMainMenu(), gameFunction(), mainMenuReactToEnter(), playerAction(), printEmptyBox(), showCredits(), showHallOfShame() und showRules().

                                    {
     if (display.first!=NULL || display.last!=NULL){
         //display not initialized
         exit(EXITCODE_BUFFERERROR);
     }
 
     if (maxTextLength>consoleBufferWidth-4){
         //requested buffer too large for window size
         exit(EXITCODE_WINDOWERROR);
     }
 
     if (maxTextLength<1){
         exit(EXITCODE_BUFFERERROR);
     }
 
     display.maxTextLength = maxTextLength;
     deleteLineItem(display.first, 1);
     display.lineCount = 0;
     display.first = insertNewLineItem(NULL,NULL,maxTextLength);
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void startGame ( )

Function will create a new Board, clears it and calls playerAction()

Rückgabe: no return because of void

Definiert in Zeile 333 der Datei gamefunction.c.

Benutzt gameField, gameFieldCreated, gameFieldHeigth, gameFieldWidth, newBoard() und playerAction().

Wird benutzt von gameFunction().

                 {
     //checks if field already exists
     if (gameFieldCreated == 0) {
         //create new game board (includes clear)
         if (newBoard(&gameField,gameFieldWidth,gameFieldHeigth)) {
             //set gameFieldCreated to 1
             gameFieldCreated = 1;
         }
     }
     //call playerAction to let game begin
     playerAction();
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void strcatRepeat	(	char *	target,
		const char *	source,
		unsigned int	howOften
	)

Definiert in Zeile 458 der Datei system.c.

Wird benutzt von drawBoard(), flushBuffer() und printfBanner().

                                                                           {
     int c;
     for(c = 0; c < howOften; c++){
         strcat(target,source);
     }
 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void throwCoin	(	int	pos,
		char	player
	)

Checks if a row is full, otherwise throw coin

Parameter

pos	position of where coin should be placed (board begins at 0 and coinpos at 1!)
player	Char which contains X oder O according to the player

Rückgabe: no return because of void

Definiert in Zeile 252 der Datei gamefunction.c.

Benutzt checkForWinner(), FIELD_EMPTY, FIELD_PLAYER1, FIELD_PLAYER2, gameField, gameFieldHeigth, getField(), playersTurn, setField() und victor.

Wird benutzt von playerAction().

                                      {
     int lowestCoin = 0, i;
     //get the lowest field
     // LOOP DOWN if found, set lowestCoin
     for(i = 0; i <= gameFieldHeigth-1; i++) {
         // if we found an empty field, leave this loop and set lowest coin
         // to the found field, so that game flow can set the next coin here
         if (getField(&gameField,pos-1,i) == FIELD_EMPTY){
             lowestCoin = i;
             break;
         }
     }
     //check if most upper field is filled with coin
     if (getField(&gameField,pos-1,gameFieldHeigth-1)==FIELD_PLAYER2 || getField(&gameField,pos-1,gameFieldHeigth-1)==FIELD_PLAYER1) {
         return;
     }else{
         //set the coin for player 1 or 2 to the lowest possible column
         if(player == FIELD_PLAYER1){
             setField(&gameField,pos-1,lowestCoin,FIELD_PLAYER1);
             //added looking for winner here
             victor = checkForWinner(pos-1, lowestCoin,FIELD_PLAYER1);
         }else if(player == FIELD_PLAYER2){ //if player 2
             setField(&gameField,pos-1,lowestCoin,FIELD_PLAYER2);
             victor = checkForWinner(pos-1, lowestCoin,FIELD_PLAYER2);
         }
     }
     //switch to player 2 or back to 1
     if (playersTurn == 1)
         playersTurn = 0;
     else playersTurn = 1;
     return;
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int updateSaveHoS	(	char *	victor,
		char *	victim,
		int	moves
	)

This functions uses the 3 parameters to update and save the Hall of Shame. The 3 parameters will be interpreted as a line which has to be inserted to the HallOfShame.dat document. A kind of Insertion Sort is used to put the line on the right place.

Parameter

victor	Name of player who won the game.
vicitim	Name of player who lost.
moves	Number of steps after the game has finished.

Rückgabe: The line number of the inserted one.

Definiert in Zeile 101 der Datei hallofshame.c.

Benutzt EXITCODE_OUTOFMEMORY, extractMoves() und getOldFileLength().

Wird benutzt von gameFunction().

                                                       {
     char line[60];
     FILE *fh;
     char* buffer = malloc((getOldFileLength()+strlen(victor)+strlen(victim))*sizeof(char)+3);
     int insertedLineNumber = 0;
     if(buffer == NULL){
         exit(EXITCODE_OUTOFMEMORY);
     }
     buffer[0]='\0';
 
 
     int inserted =0;
     fh = fopen("HallOfShame.dat", "r");
     // while End-Of-File not reached line per line
     while((fscanf(fh,"%59[^\n]\n",line)) != EOF ) {
 
         int currentMoves = extractMoves(line);
         // compare both
         if(currentMoves <= moves){
             strcat(line,"\n");
             strcat (buffer,line);
             insertedLineNumber++;
         }else{
             if(inserted==0){
                 char insertLine[120];
 
                 sprintf(insertLine,"%s,%s,%d\n%s\n",victor,victim,moves,line);
                 strcat (buffer,insertLine);
                 inserted = 1;
             }
             else{
                 strcat(line,"\n");
                 strcat (buffer,line);
             }
         }
     }
     char lastLine[60];
     // this is the case when the new lines goes at the end
     if(inserted ==0){
         sprintf(lastLine,"%s,%s,%d\n",victor,victim,moves);
         strcat(buffer,lastLine);
     }
     //close the current file mode just for reading
     fclose(fh);
     //open file again in new mode, dat will be blank at the opening moment
     //so everything will be overwritten
     fh = fopen("HallOfShame.dat","w");
     fprintf(fh,buffer);
     fclose(fh);
     //do not forget to free your allocated memory
     free(buffer);
     return insertedLineNumber;
 }

Hier ist ein Graph, der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird: