Subversion Repositories freemyipod

//
//
//    Copyright 2011 TheSeven
//
//
//    This file is part of emCORE.
//
//    emCORE is free software: you can redistribute it and/or
//    modify it under the terms of the GNU General Public License as
//    published by the Free Software Foundation, either version 2 of the
//    License, or (at your option) any later version.
//
//    emCORE is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//    See the GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License along
//    with emCORE.  If not, see <http://www.gnu.org/licenses/>.
//
//


#include "emcoreapp.h"
#include "libui.h"


#define TILE_W 5
#define TILE_H 5


enum state
{
    STATE_FREE,
    STATE_SNAKE,
    STATE_FOOD,
    STATE_OUTOFBOUNDS,
    NUM_STATES
};

struct pos
{
    uint8_t x;
    uint8_t y;
};


uint32_t colors[NUM_STATES] =
{
    [STATE_FREE] = 0,
    [STATE_SNAKE] = 0xff000000,
    [STATE_FOOD] = 0xffff0000
};


struct libui_api* ui;
int dirx;
int diry;
int offsetx;
int offsety;
int tilesx;
int tilesy;
int tilecount;
void* framebuf;
int framebufx;
int framebufy;
int framebufsize;
uint8_t* field;
struct pos* snake;
int snakehead;
int snaketail;
int snakelength;
int xrandshift;
int yrandshift;


void buttonhandler(void* user, enum button_event eventtype, int which, int value)
{
    if (eventtype == BUTTON_PRESS)
        switch (which)
        {
        case 1:
            dirx = 1;
            diry = 0;
            break;
        case 2:
            dirx = -1;
            diry = 0;
            break;
        case 3:
            dirx = 0;
            diry = 1;
            break;
        case 4:
            dirx = 0;
            diry = -1;
            break;
        }
}

void setstate(int x, int y, enum state s)
{
    if (x < 0 || x >= tilesx || y < 0 || y >= tilesy) return;
    field[y * tilesx + x] = (uint8_t)s;
}

enum state getstate(int x, int y)
{
    if (x < 0 || x >= tilesx || y < 0 || y >= tilesy) return STATE_OUTOFBOUNDS;
    return (enum state)field[y * tilesx + x];
}

enum state extendsnake()
{
    int newx = snake[snakehead].x + dirx;
    int newy = snake[snakehead].y + diry;
    enum state s = getstate(newx, newy);
    if (s != STATE_FREE && s != STATE_FOOD) return s;
    snakehead++;
    setstate(newx, newy, STATE_SNAKE);
    if (snakehead >= tilecount) snakehead = 0;
    snake[snakehead].x = newx;
    snake[snakehead].y = newy;
    snakelength++;
    return s;
}

void shrinksnake()
{
    setstate(snake[snaketail].x, snake[snaketail].y, STATE_FREE);
    snaketail++;
    if (snaketail >= tilecount) snaketail = 0;
    snakelength--;
}

void placefood()
{
    int x;
    int y;
    enum state s = STATE_OUTOFBOUNDS;
    while (s != STATE_FREE)
    {
        x = rand() >> xrandshift;
        y = rand() >> yrandshift;
        s = getstate(x, y);
    }
    setstate(x, y, STATE_FOOD);
}

void draw()
{
    int x, y;
    memset(framebuf, 0xff, framebufsize);
    for (y = 0; y < tilesy; y++)
        for (x = 0; x < tilesx; x++)
        {
            uint32_t color = colors[getstate(x, y)];
            if (color) ui->fill(TILE_W, TILE_H, color, framebuf, x * TILE_W, y * TILE_H, framebufx);
        }
    displaylcd(offsetx, offsety, framebufx, framebufy, framebuf, 0, 0, framebufx);
}


static void main(int argc, const char** argv)
{
    int i;

    struct emcorelib_header* libui = get_library(LIBUI_IDENTIFIER, LIBUI_API_VERSION, LIBSOURCE_BOOTFLASH, "libui   ");
    if (!libui) panicf(PANIC_KILLTHREAD, "Could not load user interface library!");
    ui = (struct libui_api*)libui->api;

    int width = lcd_get_width();
    int height = lcd_get_height();
    tilesx = width / TILE_W;
    tilesy = height / TILE_H;
    tilecount = tilesx * tilesy;
    framebufx = tilesx * TILE_W;
    framebufy = tilesy * TILE_H;
    framebufsize = framebufx * framebufy * 3;
    offsetx = (width - framebufx) / 2;
    offsety = (height - framebufy) / 2;
    xrandshift = __emcore_syscall->__clzsi2(tilesx - 1) - 1;
    yrandshift = __emcore_syscall->__clzsi2(tilesy - 1) - 1;
    framebuf = malloc(framebufsize);
    field = malloc(tilecount * sizeof(typeof(*field)));
    snake = malloc(tilecount * sizeof(typeof(*snake)));
    if (!framebuf || !field || !snake) panicf(PANIC_KILLTHREAD, "Out of memory!");
    struct button_hook_entry* hook = button_register_handler(buttonhandler, NULL);
    if (!hook) panicf(PANIC_KILLTHREAD, "Could not register button hook!");

    memset(field, STATE_FREE, tilesx * tilesy);
    bool finished = false;
    dirx = 1;
    diry = 0;
    snakehead = 0;
    snaketail = 0;
    snakelength = 0;
    snake[0].x = 10;
    snake[0].y = 10;
    for (i = 0; i < 10; i++) placefood();
    long steptime = 500000;
    long lasttime = USEC_TIMER - steptime;

    while (!finished)
    {
        long time = USEC_TIMER;
        lasttime += steptime;
        if (time >= lasttime) lasttime = time;
        else sleep(lasttime - time);
        bool food = false;
        switch (extendsnake())
        {
        case STATE_SNAKE:
        case STATE_OUTOFBOUNDS:
            finished = true;
            break;
        case STATE_FOOD:
            food = true;
        }
        if (food) placefood();
        else if (snakelength > 5) shrinksnake();
        if (steptime > 50000) steptime -= 100;
        draw();
    }

    cprintf(1, "Score: %d\n", snakelength);

    button_unregister_handler(hook);
    free(snake);
    free(field);
    free(framebuf);

    release_library(libui);
    library_unload(libui);
}


EMCORE_APP_HEADER("Snake", main, 127)