var Game = function () {
                this.tile_size = 16; // размер квадратика карты в пикселях

// для удобного получения нажатой кнопки
                this.key = {
                    down: false,
                    left: false,
                    right: false,
                    up: false
                };

// перевод кода кнопки в читаемый вид
                this.keyCode = {
                    37: "left",
                    38: "up",
                    39: "right",
                    40: "down"
                };

                this.player = {
                    loc: {x: 0, y: 0}, // координаты игрока
                  step:1 // шаг игрока в пикселях
                };

// бинд функций на нажатие кнопок
                window.onkeydown = this.keydown.bind(this);
                window.onkeyup   = this.keyup.bind(this);

                this.current_map = this.map_gen(5);
};

// тут пояснять не буду
Game.prototype.keydown = function (e) {
var _this = this;
k = _this.keyCode[e.keyCode];
if (k) _this.key [k]= true;
};

Game.prototype.keyup = function (e) {
var _this = this;
k = _this.keyCode[e.keyCode];
if (k) _this.key [k]= false;
};

Game.prototype.map_gen = function(size){
// данный объект нам нужен для удобной реализации алгоритма Эллера
                function obj(id, gleft, gdown){
                    this.id=0;
                    this.gdown = false;
                    this.gleft = false;
                    if (id)this.id=id;
                    if (gleft)this.gleft=true;
                    if (gdown)this.gdown=true;

                    this.toString=function(){return ''+this.id+
                     (+this.gleft)+
                     (+this.gdown)}
                }

// я хочу квадратик. вот.
                var s_x=size,
                    s_y=size;

// собственно генерация лабиринта по алгоритму Эллера, пояснять код не буду
// кстати, вместо добавлении справа границы, добавляем слева, мне почему-то показалось это проще
                var arr = [];
                logt = '';
                for (var y = 0; y < s_y; y++) {
                    arr [y]= [];

                    for(var x=0; x<s_x; x++){
                        arr [y][x]= new obj(x);
                        var bar = Math.round(Math.random());
                        var left = (bar==1&&x!=0)?true:false,
                            downprev = false,
                            down = false;

                        if (y!=0)
                            arr[y][x]= new obj(arr[y-1][x].id, arr[y-1][x].gleft, arr[y-1][x].gdown)
                        else             
                            arr[y][x]= new obj(x);

                        if (y == s_y-1){
                            left = false;
                            if (arr[y][x-1]) {
                      if((arr[y][x].id == arr[y][x-1].id && !arr[y][x].gleft && !arr[y][x].gdown && !arr[y][x-1].gleft)) {
                          arr[y][x-1].gleft = false;
                          arr[y][x-1].gdown = false;
                          left = true;
                      }             
                      arr[y][x].id = arr[y][x-1].id;
                            }
                        } else {
                            if(arr[y][x].gdown) arr [y][x]= new obj(x);
                            if(arr[y][x-1] && x!=0){
                      if(!left) {
                          if (Math.round(Math.random()) ==0)
                    down = true;
                          else  downprev = true;
                      }
                      if (!left) arr[y][x-1].id = arr[y][x].id;
                            }
                        }               
                        if (downprev)arr[y][x-1].gdown = downprev;
                        arr[y][x].gleft = left;
                        arr[y][x].gdown = down;
                    }
                };

                //перевод в нормальный вид, для удобного вывода на экран
                var new_arr = [];
                var border = [];
                for (var y = 0; y < s_y*2; y++) {new_arr [y]= [];};

                for (var y = 0; y < s_y; y++) {
                    for (var x=0; x < s_x; x++){
                        new_arr[y*2+1][x*2+1] = 0;
                        if (arr[y][x].gleft) {
                            new_arr[y*2][x*2-1] = 1;             
                            if(arr[y-1]) new_arr[y*2-1][x*2-1] = 1;             
                            if(arr[y+1]) new_arr[y*2+1][x*2-1] = 1;
                        }

                        if (arr[y][x].gdown) {
                            new_arr[y*2+1][x*2] = 1;             
                            if(arr[x-1]) new_arr[y*2+1][x*2-1] = 1;
                            if(arr[x+1]) new_arr[y*2+1][x*2+1] = 1;
                         }
                    }             
                }

// добавление границ лабиринта
                for (var e = 0; e<new_arr.length  ; e++) {
                    border [e]= [1];
                    new_arr[e].unshift(1);
                    new_arr[e][new_arr.length] = 1
                }
                border.push(1);
                new_arr.unshift(border);
                new_arr[new_arr.length-1] = border;

// вывод в консоль то что мы сгенерировали, для нормальной отладки
                log(arr);
                log(new_arr);
                return new_arr;
};

// функция для вывода в консоль матрицы в удобном представлении
log = function(arr) {
                text = '';
                for (var i = 0; i < arr.length; i++) {
                    if (arr[i].length<arr.length)arr[i].length=arr.length;
                    for (var e=0; e<arr[i].length; e++){
                        if (!arr[i][e]) text += 0;
                        else text += arr[i][e];
                        text+=' ';
                    }
                    text+='\n';
                }
                console.log(text)
}

// вывод одной "ячейки" в канвас
Game.prototype.draw_tile = function (x, y, colour, context) {
                context.fillStyle = colour;
                context.fillRect(
                    x,
                    y,
                    this.tile_size,
                    this.tile_size
                );
};

// вывод сгенерированного лабиринта
Game.prototype.draw_map = function(context){
                var mapdata = this.current_map;
                for (var y = 0; y < mapdata.length; y++) {

                    for (var x = 0; x < mapdata[y].length; x++) {
                        var t_x = (x * this.tile_size)
                        var t_y = (y * this.tile_size)
                        if(mapdata[y][x]!=0 && mapdata[y][x])
                            this.draw_tile(t_x,t_y,'#111',context);
                        else
                            this.draw_tile(t_x,t_y,'#fff',context);
                    }
                }
}

window.requestAnimFrame = function(){
                return (
                    window.requestAnimationFrame       ||             
                    window.webkitRequestAnimationFrame ||             
                    window.mozRequestAnimationFrame    ||             
                    window.oRequestAnimationFrame      ||             
                    window.msRequestAnimationFrame     ||             
                    function(callback){
                        window.setTimeout(callback, 1000 / 60);
                    }
                );
}();

var canvas = document.getElementById('canvas'),
                ctx = canvas.getContext('2d');

// размер канваса             
canvas.width = 300;
canvas.height = 300;

var game = new Game();
                game.draw_map(ctx);

var Loop = function() {
                          
              ctx.fillStyle = '#333';
              //ctx.fillRect(0, 0, canvas.width, canvas.height);
              game.update_player();
              game.draw(ctx);
              //  game.draw_map(context);
                          
              window.requestAnimFrame(Loop);
};

Loop();