/* read_win_bminfoheader:
* Reads information from a BMP file header.
*/
static int read_win_bminfoheader(ALLEGRO_FILE *f, BMPINFOHEADER *infoheader)
{
WINBMPINFOHEADER win_infoheader;
win_infoheader.biWidth = al_fread32le(f);
win_infoheader.biHeight = al_fread32le(f);
win_infoheader.biPlanes = al_fread16le(f);
win_infoheader.biBitCount = al_fread16le(f);
win_infoheader.biCompression = al_fread32le(f);
win_infoheader.biSizeImage = al_fread32le(f);
win_infoheader.biXPelsPerMeter = al_fread32le(f);
win_infoheader.biYPelsPerMeter = al_fread32le(f);
win_infoheader.biClrUsed = al_fread32le(f);
win_infoheader.biClrImportant = al_fread32le(f);
infoheader->biWidth = win_infoheader.biWidth;
infoheader->biHeight = win_infoheader.biHeight;
infoheader->biBitCount = win_infoheader.biBitCount;
infoheader->biCompression = win_infoheader.biCompression;
infoheader->biClrUsed = win_infoheader.biClrUsed;
if (al_feof(f) || al_ferror(f)) {
ALLEGRO_ERROR("Failed to read file header\n");
return -1;
}
return 0;
}
static ALLEGRO_FILE *get_next_chunk(ALLEGRO_FILE *file)
{
/* Reads the length of the next chunk, and if not at end of file, returns a
slice that represents that portion of the file. */
const uint32_t length = al_fread32le(file);
return !al_feof(file) ? al_fopen_slice(file, length, "rw") : NULL;
}
bool File::eof() const
{
if(!isOpen())
{
return true;
}
else
{
return al_feof(m_file);
}
}
/* read_bmfileheader:
* Reads a BMP file header and check that it has the BMP magic number.
*/
static int read_bmfileheader(ALLEGRO_FILE *f, BMPFILEHEADER *fileheader)
{
fileheader->bfType = al_fread16le(f);
fileheader->bfSize = al_fread32le(f);
fileheader->bfReserved1 = al_fread16le(f);
fileheader->bfReserved2 = al_fread16le(f);
fileheader->bfOffBits = al_fread32le(f);
if (fileheader->bfType != 19778) {
ALLEGRO_ERROR("Not BMP format\n");
return -1;
}
if (al_feof(f) || al_ferror(f)) {
ALLEGRO_ERROR("Failed to read file header\n");
return -1;
}
return 0;
}
ConfigFile::ConfigFile( std::string Filename )
{
ALLEGRO_FILE* fileHnd;
std::string document;
char buf[1024];
fileHnd = al_fopen( Filename.c_str(), "r" );
if( fileHnd != 0 )
{
document.clear();
while( !al_feof( fileHnd ) )
{
al_fgets( fileHnd, (char*)&buf, 1024 );
document.append( (char*)&buf );
memset( (void*)buf, 0, 1024 );
}
ParseFile( document );
al_fclose( fileHnd );
}
}
/* read_os2_bminfoheader:
* Reads information from an OS/2 format BMP file header.
*/
static int read_os2_bminfoheader(ALLEGRO_FILE *f, BMPINFOHEADER *infoheader)
{
OS2BMPINFOHEADER os2_infoheader;
os2_infoheader.biWidth = al_fread16le(f);
os2_infoheader.biHeight = al_fread16le(f);
os2_infoheader.biPlanes = al_fread16le(f);
os2_infoheader.biBitCount = al_fread16le(f);
infoheader->biWidth = os2_infoheader.biWidth;
infoheader->biHeight = os2_infoheader.biHeight;
infoheader->biBitCount = os2_infoheader.biBitCount;
infoheader->biCompression = BIT_RGB;
infoheader->biClrUsed = 0; /* default */
if (al_feof(f) || al_ferror(f)) {
ALLEGRO_ERROR("Failed to read file header\n");
return -1;
}
return 0;
}
ALLEGRO_SAMPLE *_al_load_voc_f(ALLEGRO_FILE *file)
{
AL_VOC_DATA *vocdata;
ALLEGRO_SAMPLE *sample = NULL;
size_t pos = 0; /* where to write in the buffer */
size_t read = 0; /*bytes read during last operation */
char* buffer;
size_t bytestoread = 0;
bool endofvoc = false;
vocdata = al_malloc(sizeof(AL_VOC_DATA));
memset(vocdata, 0, sizeof(*vocdata));
/*
* Open file and populate VOC DATA, then create a buffer for the number of
* samples of the frst block.
* Iterate on the following blocks till EOF or terminator block
*/
vocdata = voc_open(file);
if (!vocdata) return NULL;
ALLEGRO_DEBUG("channels %d\n", vocdata->channels);
ALLEGRO_DEBUG("word_size %d\n", vocdata->sample_size);
ALLEGRO_DEBUG("rate %d\n", vocdata->samplerate);
ALLEGRO_DEBUG("first_block_samples %d\n", vocdata->samples);
ALLEGRO_DEBUG("first_block_size %d\n", vocdata->samples * vocdata->sample_size);
/*
* Let's allocate at least the first block's bytes;
*/
buffer = al_malloc(vocdata->samples * vocdata->sample_size);
if (!buffer) {
return NULL;
}
/*
* We now need to iterate over data blocks till either we hit end of file
* or we find a terminator block.
*/
bytestoread = vocdata->samples * vocdata->sample_size;
while(!endofvoc && !al_feof(vocdata->file)) {
uint32_t blocktype = 0;
uint32_t x = 0, len = 0;
read = al_fread(vocdata->file, buffer, bytestoread);
pos += read;
READNBYTES(vocdata->file, blocktype, 1, NULL); // read next block type
if (al_feof(vocdata->file)) break;
switch (blocktype) {
case 0:{ /* we found a terminator block */
endofvoc = true;
break;
}
case 2:{ /*we found a continuation block: unlikely but handled */
x = 0;
bytestoread = 0;
READNBYTES(vocdata->file, bytestoread, 2, NULL);
READNBYTES(vocdata->file, x, 1, NULL);
bytestoread += x<<16;
/* increase subsequently storage */
buffer = al_realloc(buffer, sizeof(buffer) + bytestoread);
break;
}
case 1: // we found a NEW data block starter, I assume this is wrong
case 8: // and let the so far read sample data correctly in the
case 9:{ // already allocated buffer.
endofvoc = true;
break;
}
case 3: /* we found a pause block */
case 4: /* we found a marker block */
case 5: /* we found an ASCII c-string block */
case 6: /* we found a repeat block */
case 7:{ /* we found an end repeat block */
/* all these blocks will be skipped */
unsigned int ii;
len = 0;
x = 0;
READNBYTES(vocdata->file, len, 2, NULL);
READNBYTES(vocdata->file, x, 1, NULL);
len += x<<16; // this is the length what's left to skip */
for (ii = 0; ii < len ; ++ii) {
al_fgetc(vocdata->file);
}
bytestoread = 0; //should let safely check for the next block */
break;
}
default:
break;
}
}
sample = al_create_sample(buffer, pos, vocdata->samplerate,
_al_word_size_to_depth_conf(vocdata->sample_size),
_al_count_to_channel_conf(vocdata->channels),
true);
if (!sample)
al_free(buffer);
voc_close(vocdata);
return sample;
}
int main(int argc, char **argv)
{
ALLEGRO_AUDIO_RECORDER *r;
ALLEGRO_AUDIO_STREAM *s;
ALLEGRO_EVENT_QUEUE *q;
ALLEGRO_DISPLAY *d;
ALLEGRO_FILE *fp = NULL;
ALLEGRO_PATH *tmp_path = NULL;
int prev = 0;
bool is_recording = false;
int n = 0; /* number of samples written to disk */
(void) argc;
(void) argv;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
if (!al_init_primitives_addon()) {
abort_example("Unable to initialize primitives addon");
}
if (!al_install_keyboard()) {
abort_example("Unable to install keyboard");
}
if (!al_install_audio()) {
abort_example("Unable to initialize audio addon");
}
if (!al_init_acodec_addon()) {
abort_example("Unable to initialize acodec addon");
}
/* Note: increasing the number of channels will break this demo. Other
* settings can be changed by modifying the constants at the top of the
* file.
*/
r = al_create_audio_recorder(1000, samples_per_fragment, frequency,
audio_depth, ALLEGRO_CHANNEL_CONF_1);
if (!r) {
abort_example("Unable to create audio recorder");
}
s = al_create_audio_stream(playback_fragment_count,
playback_samples_per_fragment, frequency, audio_depth,
ALLEGRO_CHANNEL_CONF_1);
if (!s) {
abort_example("Unable to create audio stream");
}
al_reserve_samples(0);
al_set_audio_stream_playing(s, false);
al_attach_audio_stream_to_mixer(s, al_get_default_mixer());
q = al_create_event_queue();
/* Note: the following two options are referring to pixel samples, and have
* nothing to do with audio samples. */
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SAMPLES, 8, ALLEGRO_SUGGEST);
d = al_create_display(320, 256);
if (!d) {
abort_example("Error creating display\n");
}
al_set_window_title(d, "SPACE to record. P to playback.");
al_register_event_source(q, al_get_audio_recorder_event_source(r));
al_register_event_source(q, al_get_audio_stream_event_source(s));
al_register_event_source(q, al_get_display_event_source(d));
al_register_event_source(q, al_get_keyboard_event_source());
al_start_audio_recorder(r);
while (true) {
ALLEGRO_EVENT e;
al_wait_for_event(q, &e);
if (e.type == ALLEGRO_EVENT_AUDIO_RECORDER_FRAGMENT) {
/* We received an incoming fragment from the microphone. In this
* example, the recorder is constantly recording even when we aren't
* saving to disk. The display is updated every time a new fragment
* comes in, because it makes things more simple. If the fragments
* are coming in faster than we can update the screen, then it will be
* a problem.
*/
ALLEGRO_AUDIO_RECORDER_EVENT *re = al_get_audio_recorder_event(&e);
audio_buffer_t input = (audio_buffer_t) re->buffer;
int sample_count = re->samples;
const int R = sample_count / 320;
int i, gain = 0;
/* Calculate the volume, and display it regardless if we are actively
* recording to disk. */
for (i = 0; i < sample_count; ++i) {
if (gain < abs(input[i] - sample_center))
gain = abs(input[i] - sample_center);
}
al_clear_to_color(al_map_rgb(0,0,0));
if (is_recording) {
/* Save raw bytes to disk. Assumes everything is written
* succesfully. */
if (fp && n < frequency / (float) samples_per_fragment *
max_seconds_to_record) {
al_fwrite(fp, input, sample_count * sample_size);
++n;
}
/* Draw a pathetic visualization. It draws exactly one fragment
* per frame. This means the visualization is dependent on the
* various parameters. A more thorough implementation would use this
* event to copy the new data into a circular buffer that holds a
* few seconds of audio. The graphics routine could then always
* draw that last second of audio, which would cause the
* visualization to appear constant across all different settings.
*/
for (i = 0; i < 320; ++i) {
int j, c = 0;
/* Take the average of R samples so it fits on the screen */
for (j = i * R; j < i * R + R && j < sample_count; ++j) {
c += input[j] - sample_center;
}
c /= R;
/* Draws a line from the previous sample point to the next */
al_draw_line(i - 1, 128 + ((prev - min_sample_val) /
(float) sample_range) * 256 - 128, i, 128 +
((c - min_sample_val) / (float) sample_range) * 256 - 128,
al_map_rgb(255,255,255), 1.2);
prev = c;
}
}
/* draw volume bar */
al_draw_filled_rectangle((gain / (float) max_sample_val) * 320, 251,
0, 256, al_map_rgba(0, 255, 0, 128));
al_flip_display();
}
else if (e.type == ALLEGRO_EVENT_AUDIO_STREAM_FRAGMENT) {
/* This event is received when we are playing back the audio clip.
* See ex_saw.c for an example dedicated to playing streams.
*/
if (fp) {
audio_buffer_t output = al_get_audio_stream_fragment(s);
if (output) {
/* Fill the buffer from the data we have recorded into the file.
* If an error occurs (or end of file) then silence out the
* remainder of the buffer and stop the playback.
*/
const size_t bytes_to_read =
playback_samples_per_fragment * sample_size;
size_t bytes_read = 0, i;
do {
bytes_read += al_fread(fp, (uint8_t *)output + bytes_read,
bytes_to_read - bytes_read);
} while (bytes_read < bytes_to_read && !al_feof(fp) &&
!al_ferror(fp));
/* silence out unused part of buffer (end of file) */
for (i = bytes_read / sample_size;
i < bytes_to_read / sample_size; ++i) {
output[i] = sample_center;
}
al_set_audio_stream_fragment(s, output);
if (al_ferror(fp) || al_feof(fp)) {
al_drain_audio_stream(s);
al_fclose(fp);
fp = NULL;
}
}
}
}
else if (e.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
else if (e.type == ALLEGRO_EVENT_KEY_CHAR) {
if (e.keyboard.unichar == 27) {
/* pressed ESC */
break;
}
else if (e.keyboard.unichar == ' ') {
if (!is_recording) {
/* Start the recording */
is_recording = true;
if (al_get_audio_stream_playing(s)) {
al_drain_audio_stream(s);
}
/* Reuse the same temp file for all recordings */
if (!tmp_path) {
fp = al_make_temp_file("alrecXXX.raw", &tmp_path);
}
else {
if (fp) al_fclose(fp);
fp = al_fopen(al_path_cstr(tmp_path, '/'), "w");
}
n = 0;
}
else {
is_recording = false;
if (fp) {
al_fclose(fp);
fp = NULL;
}
}
}
else if (e.keyboard.unichar == 'p') {
/* Play the previously recorded wav file */
if (!is_recording) {
if (tmp_path) {
fp = al_fopen(al_path_cstr(tmp_path, '/'), "r");
if (fp) {
al_set_audio_stream_playing(s, true);
}
}
}
}
}
}
/* clean up */
al_destroy_audio_recorder(r);
al_destroy_audio_stream(s);
if (fp)
al_fclose(fp);
if (tmp_path) {
al_remove_filename(al_path_cstr(tmp_path, '/'));
al_destroy_path(tmp_path);
}
return 0;
}
/**
Checks if the EOF indicator has been set.
@return true if set.
*/
bool isEOF() const {
return al_feof(get());
}
/* get_xdg_path - locate an XDG user dir
*/
static ALLEGRO_PATH *_get_xdg_path(const char *location)
{
ALLEGRO_PATH *location_path = NULL;
ALLEGRO_PATH *xdg_config_path = NULL;
ALLEGRO_FILE *xdg_config_file = NULL;
const char *xdg_config_home = getenv("XDG_CONFIG_HOME");
int fd;
if (xdg_config_home) {
/* use $XDG_CONFIG_HOME since it exists */
xdg_config_path = al_create_path_for_directory(xdg_config_home);
}
else {
/* the default XDG location is ~/.config */
xdg_config_path = al_get_standard_path(ALLEGRO_USER_HOME_PATH);
if (!xdg_config_path) return NULL;
al_append_path_component(xdg_config_path, ".config");
}
al_set_path_filename(xdg_config_path, "user-dirs.dirs");
fd = open(al_path_cstr(xdg_config_path, '/'), O_RDONLY);
if (fd != -1) {
xdg_config_file = al_fopen_fd(fd, "r");
}
al_destroy_path(xdg_config_path);
if (!xdg_config_file) return NULL;
while (!al_feof(xdg_config_file)) {
char line[XDG_MAX_PATH_LEN]; /* one line of the config file */
const char *p = line; /* where we're at in the line */
char component[XDG_MAX_PATH_LEN]; /* the path component being parsed */
int i = 0; /* how long the current component is */
al_fgets(xdg_config_file, line, XDG_MAX_PATH_LEN);
/* skip leading white space */
while (*p == ' ' || *p == '\t') p++;
/* skip the line if it does not begin with XDG_location_DIR */
if (strncmp(p, "XDG_", 4)) continue;
p += 4;
if (strncmp(p, location, strlen(location))) continue;
p += strlen(location);
if (strncmp(p, "_DIR", 4)) continue;
p += 4;
/* skip past the =", allowing for white space */
while (*p == ' ' || *p == '\t') p++;
if (*p++ != '=') continue;
while (*p == ' ' || *p == '\t') p++;
if (*p++ != '"') continue;
/* We've found the right line. Now parse it, basically assuming
that it is in a sane format.
*/
if (!strncmp(p, "$HOME", 5)) {
/* $HOME is the only environment variable that the path is
allowed to use, and it must be first, by specification. */
location_path = al_get_standard_path(ALLEGRO_USER_HOME_PATH);
p += 5;
}
else {
location_path = al_create_path("/");
}
while (*p) {
if (*p == '"' || *p == '/') {
/* add the component (if non-empty) to the path */
if (i > 0) {
component[i] = 0;
al_append_path_component(location_path, component);
i = 0;
}
if (*p == '"') break;
}
else {
if (*p == '\\') {
/* treat any escaped character as a literal */
p++;
if (!*p) break;
}
component[i++] = *p;
}
p++;
}
/* Finished parsing the path. */
break;
}
al_fclose(xdg_config_file);
return location_path;
}
void WorldStage::LoadMapFromFileOrCreateNewMap()
{
const int MAP_WIDTH = 80;
const int MAP_HEIGHT = 80;
const int ARBITRARY_NUMBER_OF_WALLS = 20;
const int VALID_VERSION = 0;
currentMap = new RegionalMap();
currentMap->InitToField(MAP_WIDTH, MAP_HEIGHT, 0);
//Determine map player is on
int mapX = 0, mapY = 0;
auto player = actorList.GetActor(1);
if(player)
{
mapX = player->x/MAP_WIDTH;
mapY = player->y/MAP_HEIGHT;
}
//Load that one
std::stringstream ss;
ss << "region." << mapX << "." << mapY;
//Try to load the region by that name
ALLEGRO_FILE *file = al_fopen(ss.str().c_str(), "r");
if(file)
{
const int BUF_SIZE = 512;
char buffer[BUF_SIZE];
bool isValid = true;
if(!al_fgets(file, buffer, BUF_SIZE))
{
std::string str = buffer;
if(!str.empty() && str[str.length()-1] == '\n') str.erase(str.length()-1);
if(strcmp(str.c_str(), "b272bda9bf0c1cdcba614b5ed99c4d62") != 0)
{
isValid = false;
}
}
if(isValid && !al_fgets(file, buffer, BUF_SIZE))
{
std::string str = buffer;
if(!str.empty() && str[str.length()-1] == '\n') str.erase(str.length()-1);
if(strcmp(str.c_str(), "0") != 0)
{
isValid = false;
}
}
if(isValid)
{
for(int y = 0; y < MAP_HEIGHT; y++) for(int x = 0; x < MAP_WIDTH; x++)
{
//returns bytes read, 32bits = 4 bytes
int material = al_fread32le(file);
if(!al_feof(file))
{
currentMap->tile[x][y].materialTypeIndex = material;
}
}
//Get actor IDs
int actorId = al_fread32le(file);
while(!al_feof(file))
{
currentMap->actorIDs.push_back(actorId);
actorId = al_fread32le(file);
}
}
al_fclose(file);
}
else //no file
{
for(int nWalls = 0; nWalls < ARBITRARY_NUMBER_OF_WALLS; nWalls++)
{
//Manually place down some walls to run into
int x = rng::Rand(MAP_WIDTH);
int y = rng::Rand(MAP_HEIGHT);
currentMap->tile[x][y].materialTypeIndex = 1;
}
}
}