2019-07-03 13:35:38 +02:00
|
|
|
local Global = require 'utils.global'
|
|
|
|
local Task = require 'utils.task'
|
|
|
|
local Token = require 'utils.token'
|
|
|
|
local Queue = require 'utils.queue'
|
|
|
|
|
|
|
|
local random = math.random
|
|
|
|
local queue_new = Queue.new
|
|
|
|
local push = Queue.push
|
|
|
|
local push_to_end = Queue.push_to_end
|
|
|
|
local pop = Queue.pop
|
|
|
|
local peek = Queue.peek
|
|
|
|
local peek_start = Queue.peek_start
|
|
|
|
local peek_index = Queue.peek_index
|
|
|
|
local queue_size = Queue.size
|
|
|
|
local queue_pairs = Queue.pairs
|
2019-07-03 16:45:34 +02:00
|
|
|
local pairs = pairs
|
|
|
|
set_timeout_in_ticks = Task.set_timeout_in_ticks
|
2019-07-03 13:35:38 +02:00
|
|
|
|
|
|
|
local snakes = {} -- player_index -> snake_data {is_marked_for_destroy:bool, queue :Queue of {entity, cord} }
|
|
|
|
local board = {
|
|
|
|
size = 0,
|
|
|
|
surface = nil,
|
|
|
|
position = nil,
|
|
|
|
food_count = 0,
|
|
|
|
is_running = false,
|
|
|
|
update_rate = 30,
|
|
|
|
max_food = 6
|
|
|
|
}
|
|
|
|
local cords_map = {} -- cords -> positions
|
|
|
|
|
|
|
|
Global.register(
|
|
|
|
{snakes = snakes, board = board, cords_map = cords_map},
|
|
|
|
function(tbl)
|
|
|
|
snakes = tbl.snakes
|
|
|
|
board = tbl.board
|
|
|
|
cords_map = tbl.cords_map
|
|
|
|
end
|
|
|
|
)
|
|
|
|
|
|
|
|
local vectors = {
|
|
|
|
[0] = {x = 0, y = -1},
|
|
|
|
[1] = {x = 0, y = -1},
|
|
|
|
[2] = {x = 1, y = 0},
|
|
|
|
[3] = {x = 1, y = 0},
|
|
|
|
[4] = {x = 0, y = 1},
|
|
|
|
[5] = {x = 0, y = 1},
|
|
|
|
[6] = {x = -1, y = 0},
|
|
|
|
[7] = {x = -1, y = 0}
|
|
|
|
}
|
|
|
|
|
|
|
|
local function destroy_snake(index, snake)
|
|
|
|
for _, element in queue_pairs(snake.queue) do
|
|
|
|
local e = element.entity
|
|
|
|
if e and e.valid then
|
|
|
|
e.destroy()
|
|
|
|
end
|
|
|
|
end
|
|
|
|
snakes[index] = nil
|
|
|
|
|
|
|
|
local player = game.get_player(index)
|
|
|
|
if not player or not player.valid then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
game.print(table.concat {player.name, ' has been destroyed with a score of ', queue_size(snake.queue), '.'})
|
|
|
|
end
|
|
|
|
|
|
|
|
local function destroy_dead_snakes()
|
|
|
|
for index, snake in pairs(snakes) do
|
|
|
|
if snake.is_marked_for_destroy then
|
|
|
|
destroy_snake(index, snake)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
local function spawn_food()
|
|
|
|
local size = board.size
|
|
|
|
local center = math.ceil(size / 2)
|
|
|
|
local surface = board.surface
|
|
|
|
local find_entity = surface.find_entity
|
|
|
|
|
|
|
|
local food_count = board.food_count
|
|
|
|
local max_food = board.max_food
|
2019-07-03 16:45:34 +02:00
|
|
|
local tries = max_food - food_count + 10
|
2019-07-03 13:35:38 +02:00
|
|
|
|
|
|
|
while food_count < max_food and tries > 0 do
|
|
|
|
while tries > 0 do
|
|
|
|
tries = tries - 1
|
|
|
|
local x, y = random(size), random(size)
|
|
|
|
|
|
|
|
if x == center and y == center then
|
|
|
|
goto continue
|
|
|
|
end
|
|
|
|
|
|
|
|
local pos = cords_map[x][y]
|
|
|
|
|
|
|
|
local entity = find_entity('character', pos) or find_entity('compilatron', pos)
|
|
|
|
if entity then
|
|
|
|
goto continue
|
|
|
|
end
|
|
|
|
|
|
|
|
entity =
|
|
|
|
surface.create_entity({name = 'compilatron', position = pos, force = 'neutral', direction = random(7)})
|
|
|
|
entity.active = false
|
|
|
|
food_count = food_count + 1
|
|
|
|
|
2019-07-03 16:45:34 +02:00
|
|
|
break
|
2019-07-03 13:35:38 +02:00
|
|
|
|
|
|
|
::continue::
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
board.food_count = food_count
|
|
|
|
end
|
|
|
|
|
|
|
|
local function destroy_food()
|
|
|
|
local position = board.position
|
|
|
|
local size = board.size
|
|
|
|
local food =
|
|
|
|
board.surface.find_entities_filtered(
|
|
|
|
{
|
|
|
|
name = 'compilatron',
|
|
|
|
area = {left_top = position, right_bottom = {position.x + size * 2, position.y + size * 2}}
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
for i = 1, #food do
|
|
|
|
local e = food[i]
|
|
|
|
if e.valid then
|
|
|
|
e.destroy()
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
board.food_count = 0
|
|
|
|
end
|
|
|
|
|
|
|
|
local function get_new_head_cord(head_cord, direction)
|
|
|
|
local vector = vectors[direction]
|
|
|
|
local vec_x, vec_y = vector.x, vector.y
|
|
|
|
local x, y = head_cord.x + vec_x, head_cord.y + vec_y
|
|
|
|
|
|
|
|
return x, y
|
|
|
|
end
|
|
|
|
|
|
|
|
local function tick_snake(index, snake)
|
|
|
|
local player = game.get_player(index)
|
|
|
|
|
|
|
|
if not player or not player.valid then
|
|
|
|
snake.is_marked_for_destroy = true
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
local character = player.character
|
|
|
|
if not character or not character.valid then
|
|
|
|
snake.is_marked_for_destroy = true
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
local surface = board.surface
|
|
|
|
local find_entity = surface.find_entity
|
|
|
|
local snake_queue = snake.queue
|
|
|
|
local snake_size = queue_size(snake_queue)
|
|
|
|
local head = peek_start(snake_queue)
|
|
|
|
local tail = peek(snake_queue)
|
|
|
|
local head_cord = head.cord
|
|
|
|
local tail_entity = tail.entity
|
|
|
|
local tail_cord = tail.cord
|
|
|
|
local size = board.size
|
|
|
|
|
|
|
|
local walking_state = character.walking_state
|
|
|
|
walking_state.walking = true
|
|
|
|
local direction = walking_state.direction
|
|
|
|
local x, y = get_new_head_cord(head_cord, direction)
|
|
|
|
|
|
|
|
if x <= 0 or x > size or y <= 0 or y > size then
|
|
|
|
snake.is_marked_for_destroy = true
|
|
|
|
tail_entity.destroy()
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
local new_head_position = cords_map[x][y]
|
|
|
|
|
|
|
|
if snake_size > 1 and find_entity('character', new_head_position) == peek_index(snake_queue, snake_size - 1).entity then
|
|
|
|
direction = (direction + 4) % 8
|
|
|
|
walking_state.direction = direction
|
|
|
|
x, y = get_new_head_cord(head_cord, direction)
|
|
|
|
end
|
|
|
|
|
|
|
|
if x <= 0 or x > size or y <= 0 or y > size then
|
|
|
|
snake.is_marked_for_destroy = true
|
|
|
|
tail_entity.destroy()
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
new_head_position = cords_map[x][y]
|
|
|
|
|
|
|
|
tail_entity.teleport(new_head_position)
|
|
|
|
tail.cord = {x = x, y = y}
|
|
|
|
|
|
|
|
pop(snake_queue)
|
|
|
|
push(snake_queue, tail)
|
|
|
|
|
|
|
|
player.character = nil
|
|
|
|
player.character = tail_entity
|
|
|
|
tail_entity.walking_state = walking_state
|
2019-07-03 16:45:34 +02:00
|
|
|
head.entity.active = false
|
|
|
|
tail_entity.active = true
|
2019-07-03 13:35:38 +02:00
|
|
|
|
|
|
|
local entity = find_entity('compilatron', new_head_position)
|
|
|
|
if entity and entity.valid then
|
|
|
|
entity.destroy()
|
|
|
|
|
|
|
|
entity =
|
|
|
|
surface.create_entity {name = 'character', position = cords_map[tail_cord.x][tail_cord.y], force = 'player'}
|
|
|
|
entity.character_running_speed_modifier = -1
|
2019-07-03 16:45:34 +02:00
|
|
|
entity.color = player.color
|
|
|
|
entity.active = false
|
2019-07-03 13:35:38 +02:00
|
|
|
push_to_end(snake_queue, {entity = entity, cord = tail_cord})
|
|
|
|
|
|
|
|
board.food_count = board.food_count - 1
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
local function tick_snakes()
|
|
|
|
for index, snake in pairs(snakes) do
|
|
|
|
tick_snake(index, snake)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
local function check_snakes_for_collisions()
|
|
|
|
local count_entities_filtered = board.surface.count_entities_filtered
|
|
|
|
for index, snake in pairs(snakes) do
|
|
|
|
if snake.is_marked_for_destroy then
|
|
|
|
goto continue
|
|
|
|
end
|
|
|
|
|
|
|
|
if count_entities_filtered({name = 'character', position = peek_start(snake.queue).entity.position}) > 1 then
|
|
|
|
snake.is_marked_for_destroy = true
|
|
|
|
end
|
|
|
|
|
|
|
|
::continue::
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
local tick
|
|
|
|
tick =
|
|
|
|
Token.register(
|
|
|
|
function()
|
|
|
|
if not board.is_running then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
tick_snakes()
|
|
|
|
check_snakes_for_collisions()
|
|
|
|
destroy_dead_snakes()
|
|
|
|
spawn_food()
|
|
|
|
|
2019-07-03 16:45:34 +02:00
|
|
|
set_timeout_in_ticks(board.update_rate, tick)
|
2019-07-03 13:35:38 +02:00
|
|
|
end
|
|
|
|
)
|
|
|
|
|
|
|
|
local function make_board()
|
|
|
|
local size = board.size
|
|
|
|
local position = board.position
|
|
|
|
local surface = board.surface
|
|
|
|
|
|
|
|
local pos_x, pos_y = position.x, position.y
|
|
|
|
|
|
|
|
for x = 1, size do
|
|
|
|
local col = {}
|
|
|
|
cords_map[x] = col
|
|
|
|
for y = 1, size do
|
|
|
|
col[y] = {pos_x + 2 * x - 0.5, pos_y + 2 * y - 0.5}
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
size = size * 2
|
|
|
|
local tiles = {}
|
|
|
|
|
|
|
|
for x = 0, size do
|
|
|
|
for y = 0, size do
|
|
|
|
local pos = {pos_x + x, pos_y + y}
|
|
|
|
local tile_name
|
|
|
|
|
|
|
|
if x == 0 or x == size or y == 0 or y == size then
|
|
|
|
tile_name = 'deepwater'
|
|
|
|
elseif x % 2 == 1 and y % 2 == 1 then
|
|
|
|
tile_name = 'grass-1'
|
|
|
|
else
|
|
|
|
tile_name = 'water'
|
|
|
|
end
|
|
|
|
|
|
|
|
tiles[#tiles + 1] = {position = pos, name = tile_name}
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
surface.set_tiles(tiles)
|
|
|
|
end
|
|
|
|
|
2019-07-03 16:45:34 +02:00
|
|
|
local function find_new_snake_position()
|
|
|
|
local size = board.size
|
|
|
|
local find_entity = board.surface.find_entity
|
|
|
|
|
|
|
|
local min = math.min(4, size)
|
|
|
|
local max = math.max(1, size - 4)
|
|
|
|
|
|
|
|
if min > max then
|
|
|
|
min, max = max, min
|
|
|
|
elseif min == max then
|
|
|
|
min = 1
|
|
|
|
max = size
|
|
|
|
end
|
|
|
|
|
|
|
|
local tries = 10
|
|
|
|
|
|
|
|
while tries > 0 do
|
|
|
|
tries = tries - 1
|
|
|
|
|
|
|
|
local x, y = random(min, max), random(min, max)
|
|
|
|
local pos = cords_map[x][y]
|
|
|
|
|
|
|
|
local entity = find_entity('character', pos) or find_entity('compilatron', pos)
|
|
|
|
if not entity then
|
|
|
|
return {x = x, y = y}, pos
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-07-03 13:35:38 +02:00
|
|
|
local function new_snake(player)
|
|
|
|
if not board.is_running then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
if not player or not player.valid then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
if snakes[player.index] then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
local character = player.character
|
|
|
|
if character and character.valid then
|
|
|
|
character.destroy()
|
|
|
|
end
|
|
|
|
|
2019-07-03 16:45:34 +02:00
|
|
|
local cord, pos = find_new_snake_position()
|
2019-07-03 13:35:38 +02:00
|
|
|
|
2019-07-03 16:45:34 +02:00
|
|
|
if not cord then
|
|
|
|
player.print('Unable to spawn snake, please try again.')
|
|
|
|
return
|
|
|
|
end
|
2019-07-03 13:35:38 +02:00
|
|
|
|
2019-07-03 16:45:34 +02:00
|
|
|
player.teleport(pos)
|
2019-07-03 13:35:38 +02:00
|
|
|
player.create_character()
|
|
|
|
character = player.character
|
|
|
|
character.character_running_speed_modifier = -1
|
|
|
|
|
|
|
|
local queue = queue_new()
|
2019-07-03 16:45:34 +02:00
|
|
|
push(queue, {entity = character, cord = cord})
|
2019-07-03 13:35:38 +02:00
|
|
|
local snake = {queue = queue}
|
|
|
|
|
|
|
|
snakes[player.index] = snake
|
|
|
|
end
|
|
|
|
|
|
|
|
local function new_game(surface, position, size, update_rate, max_food)
|
2019-07-03 16:45:34 +02:00
|
|
|
board.size = size or 15
|
2019-07-03 13:35:38 +02:00
|
|
|
board.surface = surface
|
2019-07-03 16:45:34 +02:00
|
|
|
position = position or {x = 1, y = 1}
|
|
|
|
position.x = position.x or position[1]
|
|
|
|
position.y = position.y or position[2]
|
2019-07-03 13:35:38 +02:00
|
|
|
board.position = position
|
2019-07-03 16:45:34 +02:00
|
|
|
board.update_rate = update_rate or 30
|
|
|
|
board.max_food = max_food or 6
|
2019-07-03 13:35:38 +02:00
|
|
|
|
|
|
|
make_board()
|
|
|
|
destroy_food()
|
|
|
|
spawn_food()
|
|
|
|
|
|
|
|
board.is_running = true
|
|
|
|
|
2019-07-03 16:45:34 +02:00
|
|
|
set_timeout_in_ticks(board.update_rate, tick)
|
2019-07-03 13:35:38 +02:00
|
|
|
end
|
|
|
|
|
|
|
|
local Public = {}
|
|
|
|
|
|
|
|
function Public.start_game(surface, top_left_position, size, update_rate, max_food)
|
|
|
|
if board.is_running then
|
|
|
|
error('Snake game is already running you must end the game first.', 2)
|
|
|
|
end
|
|
|
|
|
|
|
|
new_game(surface, top_left_position, size, update_rate or board.update_rate, max_food or board.max_food)
|
|
|
|
end
|
|
|
|
|
|
|
|
function Public.end_game()
|
2019-07-03 16:45:34 +02:00
|
|
|
for index, snake in pairs(snakes) do
|
2019-07-03 13:35:38 +02:00
|
|
|
destroy_snake(i, snakes[i])
|
|
|
|
end
|
|
|
|
|
|
|
|
destroy_food()
|
|
|
|
|
|
|
|
board.is_running = false
|
|
|
|
end
|
|
|
|
|
|
|
|
function Public.new_snake(player)
|
|
|
|
new_snake(player)
|
|
|
|
end
|
|
|
|
|
|
|
|
function Public.is_running()
|
|
|
|
return board.is_running
|
|
|
|
end
|
|
|
|
|
|
|
|
return Public
|