Reading through lines of a txt file containing words - c

Question

Currently in school, I am working on a game, arcade-like, project. I have this idea to put a random name on the level each time we proceed to the next one instead of just "Level 1", "Level 2", etc...
So I was wondering how could I do that using fscanf or fgets or something like that? I got my text file containing 70 lines with different names.
Thanks already :D

Answer 1

If it's just one name per line, then use fgets().
/******************************************************************************************
* This function reads a file line by line putting each line as a C-sting in an array
******************************************************************************************/
void read_names(char **names_table, int *n_names)
{
FILE *fp = fopen(<filename>, "r");
int i = 0;
for(i = 0; i < MAX_N_NAMES; ++i){
char *name = malloc(MAX_NAME_LENGTH);
fgets(name, MAX_NAME_LENGTH, fp);
if(name == NULL)
break;
name_table[i] = name;
}
*n_names = i; // There's a gotcha here
}
This way, you would call your function once and I leave it to you to decide where your array should live (where in memory, who owns and manages it). Then I would, using rand() % n_names to select a random index of that array for the level.
Somewhere in your program, you should have
enum NameParams { MAX_N_NAMES = 80, MAX_NAME_LENGTH = 20 };
(I like this better than #defines because the debugger will show you the names of the constants.)
This should get you started, one thing you might want to do is mark the names that you have used so as to not use them for two levels. I would do this with another array of ints (C doesn't have bools) where you mark a level as used. This has the problem that you'll have to do rand() % n_names until you find an unused name.
Or you could shuffle your name_table once and use name_table[i] for level i.
void swap_indices(char **array, int i, int j)
{
char *tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
void shuffle(char **array, int length)
{
// Do a bunch of swaps, depending on how much you care about randomness,
// you might want to look up shuffling algorithms or see if some already
// exist that you could use, but if you don't care that much, just
// do a bunch of swaps.
}
Finally, I would suggest a standalone C-file (a module) that would manage a struct like this as a global variable. Your .h file could look like this (you include it in other files and it will give you access to the public interface of your module).
#ifndef _LEVEL_NAMES_H_
#define _LEVEL_NAMES_H_
enum NameErrorCodes { ERR_NONE = 0, ERR_FILE, ERR_OTHER};
int names_init(char *filename);
char *get_name();
#endif
Then your c-file could look like this:
#include "LevelNames.h"
struct LevelNames{
int n_names;
char * names[MAX_N_NAMES];
};
static struct LevelNames level_names; // static makes this global variable
// accessible only from this file
// It does the same thing for functions
static int read_names(char *filename);
static void swap_indices(char **array, int i, int j);
static void shuffle_names();
/*******************************************************************************
*
*******************************************************************************/
int names_init(char *filename)
{
int err = 0;
err = read_names(filename);
if( err != ERR_NONE )
return err;
shuffle_names();
}
/*******************************************************************************
*
*******************************************************************************/
char *get_name(int level)
{
if(level >= level_names.n_names || level < 0)
return NULL;
return level_names.names[i];
}
/*******************************************************************************
*
*******************************************************************************/
static int read_names(char *filename)
{
FILE *fp = fopen(<filename>, "r");
if( fp == NULL )
return ERR_FILE;
int i;
for(i = 0; i < MAX_N_NAMES; ++i){
char *name = malloc(MAX_NAME_LENGTH);
fgets(name, MAX_NAME_LENGTH, fp);
if(name == NULL)
break;
level_names.names[i] = name;
}
level_names. = i; // There's a gotcha here
return ERR_NONE;
}
/*******************************************************************************
*
*******************************************************************************/
static void swap_indices(char **array, int i, int j)
{
...
}
/*******************************************************************************
*
*******************************************************************************/
static void shuffle_names()
{
...
}
That's what I would do. And don't forget about that gotcha in read_names.
I want to end with a discussion of global variables. You may have been told in school, as I was, that you should never use global variables. There are many reasons for this. They are good reasons and you should listen to people who say this to you.
However, I have a module whose sole purpose is to manage an array of names. Therefore it makes sense that THIS MODULE has a global variable. Also, it is crucial that this variable be static. This way, clients of your module don't know about your global variable (which they shouldn't).
Many modules of C's standard library have a static global variable that they manage. If you want to use a global variable because you don't know how something should be passed from function to function, then figure it out and don't use a global variable. If you want to imitate the behavior of a static class in C++ or Java, then it's legit to do it this way.