snake.cpp, snake_class.cpp, snake_class.h

//Plik snake.cpp - główny

#include "snake_class.h"
#include <ncurses.h>
#include <ctime>

WINDOW * create_win(int height, int width, int starty, int startx);
void destroy_win(WINDOW *win);
char sleep(int milliseconds);
void turn_left(segment * obj);
void turn_right(segment * obj);

int main()
{
    initscr();
    cbreak();
    noecho();
    int height = LINES - 10, width = COLS - 10;
    int starty = (LINES - height) / 2, startx = (COLS - width) / 2;
    WINDOW *win = create_win(height, width, starty, startx);

    snake s(new segment(5, 5, segment::RIGHT, 0));
    turn_point * turn = 0;
    while(not s.move(height, width))
    {
        wclear(win);
        box(win, 0, 0);
        wrefresh(win);
        segment * obj = s.head_val();
        while(obj != 0)
        {
            mvwprintw(win, obj -> y_val(), obj -> x_val(), "%c", 'o');
            turn_point * turn_obj = turn;
            while(turn_obj != 0)
            {
                if(turn_obj -> compare_with_segment(obj))
                {
                    if(turn_obj -> side_val() == turn_point::LEFT)
                        turn_left(obj);
                    if(turn_obj -> side_val() == turn_point::RIGHT)
                        turn_right(obj);
                    if(obj -> next_segment() == 0)
                        turn = turn -> next_turn();
                }
                turn_obj = turn_obj -> next_turn();
            }
            obj = obj -snake.cpp> next_segment();
        }
        wrefresh(win);
        char c = sleep(500);
        switch(c)
        {
            case ' ':
                break;
            case 'a':
                turn_left(s.head_val());
                if(turn == 0)
                    turn = new turn_point(s.head_val() -> x_val(), s.head_val() -> y_val(), 0, turn_point::LEFT);
                else
                    turn -> add_turn(new turn_point(s.head_val() -> x_val(), s.head_val() -> y_val(), 0, turn_point::LEFT));
                break;
            case 'd':
                turn_right(s.head_val());
                if(turn == 0)
                    turn = new turn_point(s.head_val() -> x_val(), s.head_val() -> y_val(), 0, turn_point::RIGHT);
                else
                    turn -> add_turn(new turn_point(s.head_val() -> x_val(), s.head_val() -> y_val(), 0, turn_point::RIGHT));
                break;
            case 'q':
                s.add();
                break;
        }
        wrefresh(win);
    }

    destroy_win(win);
    endwin();
    return 0;
}

WINDOW * create_win(int height, int width, int starty, int startx)
{
    WINDOW *win;
    win = newwin(height, width, starty, startx);
    wrefresh(win);
    refresh();
    box(win, 0, 0);
    wrefresh(win);
    return win;
}

void destroy_win(WINDOW *win)
{
    wborder(win, ' ', ' ', ' ',' ',' ',' ',' ',' ');
    wrefresh(win);
    delwin(win);
}

char sleep(int milliseconds)
{
    clock_t stop = (double(milliseconds) / 1000) * CLOCKS_PER_SEC;
    char c = ' ';
    timeout(milliseconds);
    c = getch();
    while(clock() < stop)
    {}
    return c;
}

void turn_left(segment * obj)
{
    segment::dest new_dest = obj -> dest_val();
    switch(new_dest)
    {
        case segment::RIGHT:
            obj -> set_dest(segment::UP);
            break;
        case segment::UP:
            obj -> set_dest(segment::LEFT);
            break;
        case segment::LEFT:
            obj -> set_dest(segment::DOWN);
            break;
        case segment::DOWN:
            obj -> set_dest(segment::RIGHT);
            break;
    }
}

void turn_right(segment * obj)
{
    segment::dest new_dest = obj -> dest_val();
    switch(new_dest)
    {
        case segment::RIGHT:
            obj -> set_dest(segment::DOWN);
            break;
        case segment::DOWN:
            obj -> set_dest(segment::LEFT);
            break;
        case segment::LEFT:
            obj -> set_dest(segment::UP);
            break;
        case segment::UP:
            obj -> set_dest(segment::RIGHT);
            break;
    }
}

//Plik nagłówkowy - snake_class.h

#ifndef _SNAKE_CLASS_H_
#define _SNAKE_CLASS_H_

#include <iostream>

class segment //singe snake element
{
public:
    enum dest {LEFT, RIGHT, UP, DOWN}; //destination
private:
    int x; //x value for a snake segment
    int y; //y value for a snake segment
    segment * next; //next snake element, 0 if last
    dest seg_dest; //single segment destination
public:
    segment(); //defsault construtor
    segment(int _x, int _y, dest _dest, segment * _next); //constructor
    ~segment() {next = 0;} //destructor
    void reset(int _x, int _y, dest _dest, segment * _next); //to same as constructor but not make on creating object
    void set_next(segment * _next) {next = _next;} //set next segment
    void set_dest(dest _dest) {seg_dest = _dest;} //set segment destination
    segment * next_segment() const {return next;} //returns next segment pointer
    int x_val() const {return x;} //returns x value of segment
    int y_val() const {return y;} //returns y value of segment
    dest dest_val() const {return seg_dest;} //returns destination of segment
};

class snake
{
private:
    segment * head; //first element of snake
public:
    snake(); //default constructor
    snake(segment * _head); //constructor
    ~snake() {head = 0;} //destructor
    void add(); //adds one segment on end of snake
    void remove(); //remove one segment from end of snake
    bool move(int h, int w); //moves whole snake
    segment * head_val() const {return head;} //returns pointer to snake head
};

class turn_point
{
public:
    enum side {LEFT, RIGHT};
private:
    int x; //x value for turn_point
    int y; //y value for turn_point
    turn_point * prev; //pointer to next turn_point
    side turn_side;
public:
    turn_point();
    turn_point(int _x, int _y, turn_point * _prev, side _side);
    ~turn_point() {prev = 0;}
    void add_turn(turn_point * _prev) {prev = _prev;}
    turn_point * next_turn() const {return prev;}
    bool compare_with_segment(segment * seg) const;
    side side_val() const {return turn_side;}
};

#endif

//Plik implementacyjny klas - snake_class.cpp

#include "snake_class.h"

/* Segment class implementation */

segment::segment()
{
    x = y = 0;
    next = 0;
    seg_dest = RIGHT;
}

segment::segment(int _x, int _y, dest _dest, segment * _next)
{
    x = _x;
    y = _y;
    seg_dest = _dest;
    next = _next;
}

void segment::reset(int _x, int _y, dest _dest, segment * _next)
{
    x = _x;
    y = _y;
    seg_dest = _dest;
    next = _next;
}

/* Snake class implementation */

snake::snake()
{
    head = 0;
}

snake::snake(segment * _head)
{
    head = _head;
}

void snake::add()
{
    segment * obj = head;
    while(obj -> next_segment() != 0)
        obj = obj -> next_segment();
    segment::dest last_dest = obj -> dest_val();
    int obj_x = obj -> x_val();
    int obj_y = obj -> y_val();
    segment * last;
    switch(last_dest)
    {
        case segment::UP:
            last = new segment(obj_x, obj_y - 1, segment::UP, 0);
            break;
        case segment::DOWN:
            last = new segment(obj_x, obj_y + 1, segment::DOWN, 0);
            break;
        case segment::RIGHT:
            last = new segment(obj_x - 1, obj_y, segment::RIGHT, 0);
            break;
        case segment::LEFT:
            last = new segment(obj_x + 1, obj_y, segment::LEFT, 0);
            break;
    }
    obj -> set_next(last);
}

void snake::remove()
{
    segment * obj = head;
    while((obj -> next_segment()) -> next_segment() != 0)
        obj = obj -> next_segment();
    delete obj -> next_segment();
    obj -> set_next(0);
}

bool snake::move(int h, int w)
{
    segment * obj = head;
    while(obj != 0)
    {
        segment::dest obj_dest = obj -> dest_val();
        int obj_x = obj -> x_val();
        int obj_y = obj -> y_val();
        switch(obj_dest)
        {
            case segment::RIGHT:
                obj_x++;
                if(obj_x >= w - 1)
                    return true;
                break;
            case segment::LEFT:
                obj_x--;
                if(obj_x < 1)
                    return true;
                break;
            case segment::DOWN:
                obj_y++;
                if(obj_y >= h - 1)
                    return true;
                break;
            case segment::UP:
                obj_y--;
                if(obj_y < 1)
                    return true;
                break;
        }
        obj -> reset(obj_x, obj_y, obj_dest, obj -> next_segment());
        obj = obj -> next_segment();
    }
    return false;
}

/* Turn point class implementation */

turn_point::turn_point()
{
    x = y = -1;
    prev = 0;
    turn_side = LEFT;
}

turn_point::turn_point(int _x, int _y, turn_point * _prev, side _side)
{
    x = _x;
    y = _y;
    prev = _prev;
    turn_side = _side;
}

bool turn_point::compare_with_segment(segment * seg) const
{
    int seg_x = seg -> x_val();
    int seg_y = seg -> y_val();
    int obj_x = x;
    int obj_y = y;
    if(seg_x == obj_x && seg_y == obj_y)
        return true;
    return false;
}