space_game/src/main.c

#include <SDL2/SDL_audio.h>
#include <SDL2/SDL_mutex.h>
#include <SDL2/SDL_scancode.h>
#include <SDL2/SDL_mixer.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <SDL2/SDL.h>
#include <string.h>
#include <time.h>
#include <stdbool.h>
#include <math.h>

// only for mkdirat lol
#include <fcntl.h> 
#include <sys/stat.h>

#include "logger.h"
#include "game.h" 
#include "draw.h" 
#include "garbo.h" 
#include "types.h"

const int screen_width = 800;
const int screen_height = 600;
SDL_AudioSpec audio_format = {.freq = 8000, .format = AUDIO_U8,.channels = 2, .samples=128};

#define G_AUDIO_SFREQ 8000
#define G_AUDIO_BSIZE 512

SDL_sem *resume;

struct game_sounds {
    unsigned int t;
    Mix_Chunk *collision;
    Mix_Chunk *rope_attach;
    Mix_Chunk *rope_pull;
    /* Looping samples (need backbuffer to fill while playing ) */
    Mix_Chunk *menu;
};

struct game_sounds game_sounds;


struct SDL_Window* make_window(void) {
    if (SDL_Init(SDL_INIT_EVERYTHING) != 0) { 
        printf("error initializing SDL: %s\n", SDL_GetError()); 
    } 


    return SDL_CreateWindow("space_game", 
                                       SDL_WINDOWPOS_CENTERED, 
                                       SDL_WINDOWPOS_CENTERED, 
                                       0, 0, 
                                       SDL_WINDOW_FULLSCREEN_DESKTOP); 
}

void callbackfn(void *unused, Uint8 *stream, int len);
void callbackfn2(void *unused, Uint8 *stream, int len);
void callbackfn3(void *unused, Uint8 *stream, int len);


unsigned int func1(int t) {
    int note = 10;
    if (!(t % 8000)) {
        note = (1 + rand()) % 10 + 5;
        printf("%d %d\n", t, note);
    }
    return ((t & 110) % 73 | (t % 1711));
}


Uint8 big_hum(unsigned int t) {
    return ( (sin(t*2*3.14159265/16000*200)+1) * 20) + ( (sin(t*2*3.14159265/16000*110)+1) * 20) + ( (sin(t*2*3.14159265/16000*230)+1) * 20) + ( (sin((t % 80)*2*3.14159265/16000 * 6)+1) * 12);
}

unsigned int sine_wave_sound(int t) {
    const double R=8000; // sample rate (samples per second)
    const double C=261.625565; // frequency of middle-C (hertz)
    const double F=R/256; // bytebeat frequency of 1*t due to 8-bit truncation (hertz)
    const double V=127; // a volume constant
    return (sin(t*2*M_PI/R*C)+1)*V;
}

unsigned int winch_sound(int t) {
    return (t % 80) | (t % 36) | (6 * (t % 6));
}

unsigned int beat_2(int t) {
    return ((((t % 250) / 2)) | (t % 129)) % 110;
}

Uint8 func0(int t) {
    int note = 18;
    if (t % 1240) {
        note = (1 + rand()) % 18 + 1;
    }

    fflush(stdout);
    return (t % note);
}

 void fill_audio(void *func, Uint8 *stream, int len) {
     Uint8 (*wavegen)(int) = func;

    static int t = 1;
    for(int i = 0; i < len; i++,t++) {
        stream[i] = wavegen(t);
    }
}



void generate_audio(void) {

    const int sfx_len_ms = 2000;
    unsigned int sfx_len = (G_AUDIO_SFREQ/1000) * G_AUDIO_BSIZE * sfx_len_ms;
    Uint8 raw_data[sfx_len]; // 10 seconds

    fill_audio(winch_sound, raw_data, sfx_len);
    game_sounds.rope_pull = Mix_QuickLoad_RAW(raw_data, sfx_len);
    fill_audio(beat_2, raw_data, sfx_len);
    game_sounds.collision = Mix_QuickLoad_RAW(raw_data, sfx_len);
}

void play_sound(Mix_Chunk *chunk, int times) {
    Mix_PlayChannel(-1, chunk, times - 1);
}


void callbackfn3(void *unused, Uint8 *stream, int len) {
    static int t = 1;
    for(int i = 0; i < len; i++,t++) {
        stream[i] = big_hum(t);
        stream[i] = 0; 
    }
}

void start_audio(void) {
 
    audio_format.callback = callbackfn3;
    /* just for playing background music 
    if (SDL_OpenAudio(&audio_format, NULL)) {
        fprintf(stderr, "Unable to open audio: %s\n", SDL_GetError());
        exit(1);
    }
    */
    //SDL_PauseAudio(0);
    if (Mix_OpenAudio(G_AUDIO_SFREQ,AUDIO_U8,1,G_AUDIO_BSIZE) < 0) {
        fprintf(stderr, "Unable to open audio: %s\n", SDL_GetError());
        exit(1);
    }
    generate_audio();
    Mix_Resume(-1);
}

void stop_audio(void) {
    SDL_CloseAudio();
}


void callbackfn2(void *unused, Uint8 *stream, int len) {
    static int t = 1;
    int i;
    int yeet = rand();
    for(i=0; i < len; i++,t++) {
        stream[i] = func0(t);
    }
}


void callbackfn(void *unused, Uint8 *stream, int len)
{
    static int t = 0;
    int i;
    int yeet = rand();
    for( i=0; i < len; i++,t++) {
    /*
            stream[i] = (t*5&(t>>7))|(t*3&(t>>8));
    */
    //stream[i] = (( t >> 10 ) & 42) * t;
    stream[i] = (t & yeet) % 73;
    }
}

void redraw(struct SDL_Renderer * ren) {
    SDL_RenderClear(ren);
    redraw_buffer(ren);
    SDL_RenderPresent(ren);
}

int physics_loop(void *ptr) {
    game_paused = 1;
    SDL_Delay(1000);
    game_paused = 0;
    while (1) {
        if (step())  {
            // display end level screen
            game_paused = true;
            SDL_Delay(1000);
            Mix_Pause(-1);
            in_game = false;
            SDL_SemWait(resume);
            add_time(level_time);

            SDL_LockMutex(player.physics->lock);
            game_paused = true;
            next_level();
            in_game = true;
            SDL_UnlockMutex(player.physics->lock);
            SDL_Delay(1000);
            game_paused = 0;
            Mix_Resume(-1);
        }
    }
}

void play_game_sound(Mix_Chunk *chunk, int len, int channel) {
    if (Mix_Playing(channel)) {
        return;
    }
    Mix_FadeInChannelTimed(channel, chunk, -1, 1, len);
}

void synthplay_now(Uint8 (*bbgen)(unsigned int t), int len) {
    static Mix_Chunk *new_chunk = NULL;

    if (Mix_Playing(1)) {
        return;
    }

    if (new_chunk)
        Mix_FreeChunk(new_chunk);

    int generate_len = len * (512) * 8;

    Uint8 raw_data[generate_len];
    fill_audio(bbgen, raw_data, generate_len);

    new_chunk = Mix_QuickLoad_RAW(raw_data, generate_len);
    Mix_PlayChannelTimed(1, new_chunk, -1, -1);
}

int game(void) {
    LOGLEVEL = DEBUG;
    STDOUTLEVEL = DEBUG;

    //SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "2" );

    logwrite(INFO, "Starting\n");
    SDL_Window * win = make_window();
    SDL_Renderer * ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED);
//            | SDL_RENDERER_PRESENTVSYNC);

    queue_for_cleanup(win, WINDOW);
    queue_for_cleanup(ren, RENDERER);

    in_game = true;
    resume = SDL_CreateSemaphore(0);

  //  IMG_Init(IMG_INIT_PNG | IMG_INIT_JPG);

    if (ren == NULL) {
        SDL_DestroyWindow(win);
        SDL_Quit();
    }

    TTF_Init();

    int close = 0;

    //draw_pictures(ren);
    
    SDL_Thread *physics_thread;
    int ignore;

    startgame(ren);

    physics_thread = SDL_CreateThread(physics_loop, "physics", (void *)ren);

    start_audio();
    int count = 0;
    while (!close)  {

        SDL_Event event; 
        while(SDL_PollEvent(&event))  {
            switch (event.type) {
                case SDL_QUIT:
                    close = 1;
                    return 0;
                case SDL_KEYDOWN:
                    if (event.key.keysym.scancode == SDL_SCANCODE_ESCAPE) {
                        return 0;
                    }
                    if (!SDL_SemValue(resume)) {
                        SDL_SemPost(resume);
                    }
                case SDL_KEYUP:
                case SDL_MOUSEBUTTONDOWN:
                case SDL_MOUSEBUTTONUP:
                    handle_input_event (event);
            }
        }
        /* Redraw Screen */
//        step(10);

        if (!in_game) {
            draw_end_screen(ren);
        } else {
            redraw(ren);
            if (player.physics->colliding) {
                count++;
                play_game_sound(game_sounds.collision, 200, 1);
            } else {
                count = 0;
            }
        }
    }
}


int main (int argc, char** argv)  {

    mkdirat(AT_FDCWD, "saves", 0777);

    game();
    SDL_Quit();
    //empty_cleanup_queue();
    return 0; 
}