1
0
mirror of https://github.com/Refactorio/RedMew.git synced 2024-12-14 10:13:13 +02:00
RedMew/features/gui/poll.lua
2018-12-29 12:39:20 -05:00

1352 lines
38 KiB
Lua

local Gui = require 'utils.gui'
local Global = require 'utils.global'
local Event = require 'utils.event'
local UserGroups = require 'features.user_groups'
local Game = require 'utils.game'
local math = require 'utils.math'
local Utils = require 'utils.core'
local Server = require 'features.server'
local Color = require 'resources.color_presets'
local insert = table.insert
local default_poll_duration = 300 * 60 -- in ticks
local duration_max = 3600 -- in seconds
local duration_step = 15 -- in seconds
local duration_slider_max = duration_max / duration_step
local tick_duration_step = duration_step * 60
local inv_tick_duration_step = 1 / tick_duration_step
local normal_color = Color.white
local focus_color = Color.dark_orange
local polls = {}
local polls_counter = {0}
local no_notify_players = {}
local player_poll_index = {}
local player_create_poll_data = {}
Global.register(
{
polls = polls,
polls_counter = polls_counter,
no_notify_players = no_notify_players,
player_poll_index = player_poll_index,
player_create_poll_data = player_create_poll_data
},
function(tbl)
polls = tbl.polls
polls_counter = tbl.polls_counter
no_notify_players = tbl.no_notify_players
player_poll_index = tbl.player_poll_index
player_create_poll_data = tbl.player_create_poll_data
end
)
local main_button_name = Gui.uid_name()
local main_frame_name = Gui.uid_name()
local create_poll_button_name = Gui.uid_name()
local notify_checkbox_name = Gui.uid_name()
local poll_view_back_name = Gui.uid_name()
local poll_view_forward_name = Gui.uid_name()
local poll_view_vote_name = Gui.uid_name()
local poll_view_edit_name = Gui.uid_name()
local create_poll_frame_name = Gui.uid_name()
local create_poll_duration_name = Gui.uid_name()
local create_poll_label_name = Gui.uid_name()
local create_poll_question_name = Gui.uid_name()
local create_poll_answer_name = Gui.uid_name()
local create_poll_add_answer_name = Gui.uid_name()
local create_poll_delete_answer_name = Gui.uid_name()
local create_poll_close_name = Gui.uid_name()
local create_poll_clear_name = Gui.uid_name()
local create_poll_edit_name = Gui.uid_name()
local create_poll_confirm_name = Gui.uid_name()
local create_poll_delete_name = Gui.uid_name()
local function poll_id()
local count = polls_counter[1] + 1
polls_counter[1] = count
return count
end
local function apply_direction_button_style(button)
local button_style = button.style
button_style.width = 24
button_style.height = 24
button_style.top_padding = 0
button_style.bottom_padding = 0
button_style.left_padding = 0
button_style.right_padding = 0
button_style.font = 'default-listbox'
end
local function apply_button_style(button)
local button_style = button.style
button_style.font = 'default-bold'
button_style.height = 26
button_style.top_padding = 0
button_style.bottom_padding = 0
button_style.left_padding = 2
button_style.right_padding = 2
end
local function do_remaining_time(poll, remaining_time_label)
local end_tick = poll.end_tick
if end_tick == -1 then
remaining_time_label.caption = 'Endless Poll.'
return true
end
local ticks = end_tick - game.tick
if ticks < 0 then
remaining_time_label.caption = 'Poll Finished.'
return false
else
local time = math.ceil(ticks / 60)
remaining_time_label.caption = 'Remaining Time: ' .. time
return true
end
end
local function send_poll_result_to_discord(poll)
local result = {'Poll #', poll.id}
local created_by_player = poll.created_by
if created_by_player and created_by_player.valid then
insert(result, ' Created by ')
insert(result, created_by_player.name)
end
local edited_by_players = poll.edited_by
if next(edited_by_players) then
insert(result, ' Edited by ')
for pi, _ in pairs(edited_by_players) do
local p = game.players[pi]
if p and p.valid then
insert(result, p.name)
insert(result, ', ')
end
end
table.remove(result)
end
insert(result, '\\n**Question: ')
insert(result, poll.question)
insert(result, '**\\n')
local answers = poll.answers
local answers_count = #answers
for i, a in pairs(answers) do
insert(result, '[')
insert(result, a.voted_count)
insert(result, '] - ')
insert(result, a.text)
if i ~= answers_count then
insert(result, '\\n')
end
end
local message = table.concat(result)
Server.to_discord_embed(message)
end
local function redraw_poll_viewer_content(data)
local poll_viewer_content = data.poll_viewer_content
local remaining_time_label = data.remaining_time_label
local poll_index = data.poll_index
local player = poll_viewer_content.gui.player
data.vote_buttons = nil
Gui.remove_data_recursively(poll_viewer_content)
poll_viewer_content.clear()
local poll = polls[poll_index]
if not poll then
return
end
local answers = poll.answers
local voters = poll.voters
local tooltips = {}
for _, a in pairs(answers) do
tooltips[a] = {}
end
for player_index, answer in pairs(voters) do
local p = Game.get_player_by_index(player_index)
insert(tooltips[answer], p.name)
end
for a, t in pairs(tooltips) do
if #t == 0 then
tooltips[a] = ''
else
tooltips[a] = table.concat(t, ', ')
end
end
local created_by_player = poll.created_by
local created_by_text
if created_by_player and created_by_player.valid then
created_by_text = ' Created by ' .. created_by_player.name
else
created_by_text = ''
end
local top_flow = poll_viewer_content.add {type = 'flow', direction = 'horizontal'}
top_flow.add {type = 'label', caption = table.concat {'Poll #', poll.id, created_by_text}}
local edited_by_players = poll.edited_by
if next(edited_by_players) then
local edit_names = {'Edited by '}
for pi, _ in pairs(edited_by_players) do
local p = Game.get_player_by_index(pi)
if p and p.valid then
insert(edit_names, p.name)
insert(edit_names, ', ')
end
end
table.remove(edit_names)
local edit_text = table.concat(edit_names)
top_flow.add {type = 'label', caption = edit_text, tooltip = edit_text}
end
local poll_enabled = do_remaining_time(poll, remaining_time_label)
local question_flow = poll_viewer_content.add {type = 'table', column_count = 2}
if player.admin or UserGroups.is_regular(player.name) then
local edit_button =
question_flow.add {
type = 'sprite-button',
name = poll_view_edit_name,
sprite = 'utility/rename_icon_normal',
tooltip = 'Edit Poll.'
}
local edit_button_style = edit_button.style
edit_button_style.width = 26
edit_button_style.height = 26
end
local question_label = question_flow.add {type = 'label', caption = poll.question}
question_label.style.height = 32
question_label.style.font_color = focus_color
question_label.style.font = 'default-listbox'
local grid = poll_viewer_content.add {type = 'table', column_count = 2}
local answer = voters[player.index]
local vote_buttons = {}
for i, a in pairs(answers) do
local vote_button_flow = grid.add {type = 'flow'}
local vote_button =
vote_button_flow.add {
type = 'button',
name = poll_view_vote_name,
caption = a.voted_count,
enabled = poll_enabled
}
local tooltip = tooltips[a]
if tooltip ~= '' then
vote_button.tooltip = tooltip
end
local vote_button_style = vote_button.style
vote_button_style.height = 24
vote_button_style.width = 26
vote_button_style.font = 'default-small'
vote_button_style.top_padding = 0
vote_button_style.bottom_padding = 0
vote_button_style.left_padding = 0
vote_button_style.right_padding = 0
if answer == a then
vote_button_style.font_color = focus_color
vote_button_style.disabled_font_color = focus_color
end
Gui.set_data(vote_button, {answer = a, data = data})
vote_buttons[i] = vote_button
local label = grid.add {type = 'label', caption = a.text}
label.style.height = 24
end
data.vote_buttons = vote_buttons
end
local function update_poll_viewer(data)
local back_button = data.back_button
local forward_button = data.forward_button
local poll_index_label = data.poll_index_label
local poll_index = data.poll_index
if #polls == 0 then
poll_index = 0
else
poll_index = math.clamp(poll_index, 1, #polls)
end
data.poll_index = poll_index
if poll_index == 0 then
poll_index_label.caption = 'No Polls'
else
poll_index_label.caption = table.concat {'Poll ', poll_index, ' / ', #polls}
end
back_button.enabled = poll_index > 1
forward_button.enabled = poll_index < #polls
redraw_poll_viewer_content(data)
end
local function draw_main_frame(left, player)
local frame = left.add {type = 'frame', name = main_frame_name, caption = 'Polls', direction = 'vertical'}
frame.style.maximal_width = 320
local poll_viewer_top_flow = frame.add {type = 'table', column_count = 5}
poll_viewer_top_flow.style.horizontal_spacing = 0
local back_button = poll_viewer_top_flow.add {type = 'button', name = poll_view_back_name, caption = ''}
apply_direction_button_style(back_button)
local forward_button = poll_viewer_top_flow.add {type = 'button', name = poll_view_forward_name, caption = ''}
apply_direction_button_style(forward_button)
local poll_index_label = poll_viewer_top_flow.add {type = 'label'}
poll_index_label.style.left_padding = 8
local spacer = poll_viewer_top_flow.add {type = 'flow'}
spacer.style.horizontally_stretchable = true
local remaining_time_label = poll_viewer_top_flow.add {type = 'label'}
local poll_viewer_content = frame.add {type = 'scroll-pane'}
poll_viewer_content.style.maximal_height = 250
poll_viewer_content.style.width = 300
local poll_index = player_poll_index[player.index] or #polls
local data = {
back_button = back_button,
forward_button = forward_button,
poll_index_label = poll_index_label,
poll_viewer_content = poll_viewer_content,
remaining_time_label = remaining_time_label,
poll_index = poll_index
}
Gui.set_data(frame, data)
Gui.set_data(back_button, data)
Gui.set_data(forward_button, data)
update_poll_viewer(data)
frame.add {
type = 'checkbox',
name = notify_checkbox_name,
caption = 'Notify me about polls.',
state = not no_notify_players[player.index],
tooltip = 'Receive a message when new polls are created and popup the poll.'
}
local bottom_flow = frame.add {type = 'flow', direction = 'horizontal'}
local left_flow = bottom_flow.add {type = 'flow'}
left_flow.style.align = 'left'
left_flow.style.horizontally_stretchable = true
local close_button = left_flow.add {type = 'button', name = main_button_name, caption = 'Close'}
apply_button_style(close_button)
local right_flow = bottom_flow.add {type = 'flow'}
right_flow.style.align = 'right'
if player.admin or UserGroups.is_regular(player.name) then
local create_poll_button =
right_flow.add {type = 'button', name = create_poll_button_name, caption = 'Create Poll'}
apply_button_style(create_poll_button)
else
local create_poll_button =
right_flow.add {
type = 'button',
caption = 'Create Poll',
enabled = false,
tooltip = 'Sorry, you need to be a regular to create polls.'
}
apply_button_style(create_poll_button)
end
end
local function remove_create_poll_frame(create_poll_frame, player_index)
local data = Gui.get_data(create_poll_frame)
data.edit_mode = nil
player_create_poll_data[player_index] = data
Gui.remove_data_recursively(create_poll_frame)
create_poll_frame.destroy()
end
local function remove_main_frame(main_frame, left, player)
local player_index = player.index
local data = Gui.get_data(main_frame)
player_poll_index[player_index] = data.poll_index
Gui.remove_data_recursively(main_frame)
main_frame.destroy()
local create_poll_frame = left[create_poll_frame_name]
if create_poll_frame and create_poll_frame.valid then
remove_create_poll_frame(create_poll_frame, player_index)
end
end
local function toggle(event)
local left = event.player.gui.left
local main_frame = left[main_frame_name]
if main_frame then
remove_main_frame(main_frame, left, event.player)
else
draw_main_frame(left, event.player)
end
end
local function update_duration(slider)
local slider_data = Gui.get_data(slider)
local label = slider_data.duration_label
local value = slider.slider_value
value = math.floor(value)
slider_data.data.duration = value * tick_duration_step
if value == 0 then
label.caption = 'Endless Poll.'
else
label.caption = value * duration_step .. ' seconds.'
end
end
local function redraw_create_poll_content(data)
local grid = data.grid
local answers = data.answers
Gui.remove_data_recursively(grid)
grid.clear()
grid.add {type = 'flow'}
grid.add {
type = 'label',
caption = 'Duration:',
tooltip = 'Pro tip: Use mouse wheel or arrow keys for more fine control.'
}
local duration_flow = grid.add {type = 'flow', direction = 'horizontal'}
local duration_slider =
duration_flow.add {
type = 'slider',
name = create_poll_duration_name,
minimum_value = 0,
maximum_value = duration_slider_max,
value = math.floor(data.duration * inv_tick_duration_step)
}
duration_slider.style.width = 100
data.duration_slider = duration_slider
local duration_label = duration_flow.add {type = 'label'}
Gui.set_data(duration_slider, {duration_label = duration_label, data = data})
update_duration(duration_slider)
grid.add {type = 'flow'}
local question_label =
grid.add({type = 'flow'}).add {type = 'label', name = create_poll_label_name, caption = 'Question:'}
local question_textfield =
grid.add({type = 'flow'}).add {type = 'textfield', name = create_poll_question_name, text = data.question}
question_textfield.style.width = 400
Gui.set_data(question_label, question_textfield)
Gui.set_data(question_textfield, data)
local edit_mode = data.edit_mode
for count, answer in pairs(answers) do
local delete_flow = grid.add {type = 'flow'}
local delete_button
if edit_mode or count ~= 1 then
delete_button =
delete_flow.add {
type = 'sprite-button',
name = create_poll_delete_answer_name,
sprite = 'utility/remove',
tooltip = 'Delete answer field.'
}
delete_button.style.height = 26
delete_button.style.width = 26
else
delete_flow.style.height = 26
delete_flow.style.width = 26
end
local label_flow = grid.add {type = 'flow'}
local label =
label_flow.add {
type = 'label',
name = create_poll_label_name,
caption = table.concat {'Answer #', count, ':'}
}
local textfield_flow = grid.add {type = 'flow'}
local textfield = textfield_flow.add {type = 'textfield', name = create_poll_answer_name, text = answer.text}
textfield.style.width = 400
Gui.set_data(textfield, {answers = answers, count = count})
if delete_button then
Gui.set_data(delete_button, {data = data, count = count})
end
Gui.set_data(label, textfield)
end
end
local function draw_create_poll_frame(parent, player, previous_data)
previous_data = previous_data or player_create_poll_data[player.index]
local edit_mode
local question
local answers
local duration
local title_text
local confirm_text
local confirm_name
if previous_data then
edit_mode = previous_data.edit_mode
question = previous_data.question
answers = {}
for i, a in pairs(previous_data.answers) do
answers[i] = {text = a.text, source = a}
end
duration = previous_data.duration
else
question = ''
answers = {{text = ''}, {text = ''}, {text = ''}}
duration = default_poll_duration
end
if edit_mode then
title_text = 'Edit Poll #' .. previous_data.id
confirm_text = 'Edit Poll'
confirm_name = create_poll_edit_name
else
title_text = 'New Poll'
confirm_text = 'Create Poll'
confirm_name = create_poll_confirm_name
end
local frame =
parent.add {type = 'frame', name = create_poll_frame_name, caption = title_text, direction = 'vertical'}
frame.style.maximal_width = 320
local scroll_pane = frame.add {type = 'scroll-pane', vertical_scroll_policy = 'always'}
scroll_pane.style.maximal_height = 250
scroll_pane.style.maximal_width = 300
local grid = scroll_pane.add {type = 'table', column_count = 3}
local data = {
frame = frame,
grid = grid,
question = question,
answers = answers,
duration = duration,
previous_data = previous_data,
edit_mode = edit_mode
}
Gui.set_data(frame, data)
redraw_create_poll_content(data)
local add_answer_button =
scroll_pane.add {
type = 'button',
name = create_poll_add_answer_name,
caption = 'Add Answer'
}
apply_button_style(add_answer_button)
Gui.set_data(add_answer_button, data)
local bottom_flow = frame.add {type = 'flow', direction = 'horizontal'}
local left_flow = bottom_flow.add {type = 'flow'}
left_flow.style.align = 'left'
left_flow.style.horizontally_stretchable = true
local close_button = left_flow.add {type = 'button', name = create_poll_close_name, caption = 'Close'}
apply_button_style(close_button)
Gui.set_data(close_button, frame)
local clear_button = left_flow.add {type = 'button', name = create_poll_clear_name, caption = 'Clear'}
apply_button_style(clear_button)
Gui.set_data(clear_button, data)
local right_flow = bottom_flow.add {type = 'flow'}
right_flow.style.align = 'right'
if edit_mode then
local delete_button = right_flow.add {type = 'button', name = create_poll_delete_name, caption = 'Delete'}
apply_button_style(delete_button)
Gui.set_data(delete_button, data)
end
local confirm_button = right_flow.add {type = 'button', name = confirm_name, caption = confirm_text}
apply_button_style(confirm_button)
Gui.set_data(confirm_button, data)
end
local function show_new_poll(poll_data)
local message =
table.concat {poll_data.created_by.name, ' has created a new Poll #', poll_data.id, ': ', poll_data.question}
for _, p in pairs(game.connected_players) do
local left = p.gui.left
local frame = left[main_frame_name]
if no_notify_players[p.index] then
if frame and frame.valid then
local data = Gui.get_data(frame)
update_poll_viewer(data)
end
else
p.print(message)
if frame and frame.valid then
local data = Gui.get_data(frame)
data.poll_index = #polls
update_poll_viewer(data)
else
player_poll_index[p.index] = nil
draw_main_frame(left, p)
end
end
end
end
local function create_poll(event)
local player = event.player
local data = Gui.get_data(event.element)
local frame = data.frame
local question = data.question
if not question:find('%S') then
event.player.print('Sorry, the poll needs a question.')
return
end
local answers = {}
for _, a in pairs(data.answers) do
local text = a.text
if text:find('%S') then
local index = #answers + 1
answers[index] = {text = text, index = index, voted_count = 0}
end
end
if #answers < 1 then
player.print('Sorry, the poll needs at least one answer.')
return
end
player_create_poll_data[player.index] = nil
local tick = game.tick
local duration = data.duration
local end_tick
if duration == 0 then
end_tick = -1
else
end_tick = tick + duration
end
local poll_data = {
id = poll_id(),
question = question,
answers = answers,
voters = {},
start_tick = tick,
end_tick = end_tick,
duration = duration,
created_by = event.player,
edited_by = {}
}
insert(polls, poll_data)
show_new_poll(poll_data)
send_poll_result_to_discord(poll_data)
Gui.remove_data_recursively(frame)
frame.destroy()
end
local function update_vote(voters, answer, direction)
local count = answer.voted_count + direction
answer.voted_count = count
local tooltip = {}
for pi, a in pairs(voters) do
if a == answer then
local player = Game.get_player_by_index(pi)
insert(tooltip, player.name)
end
end
return tostring(count), table.concat(tooltip, ', ')
end
local function vote(event)
local player_index = event.player_index
local voted_button = event.element
local button_data = Gui.get_data(voted_button)
local answer = button_data.answer
local poll_index = button_data.data.poll_index
local poll = polls[poll_index]
local voters = poll.voters
local previous_vote_answer = voters[player_index]
if previous_vote_answer == answer then
return
end
local vote_index = answer.index
voters[player_index] = answer
local previous_vote_button_count
local previous_vote_button_tooltip
local previous_vote_index
if previous_vote_answer then
previous_vote_button_count, previous_vote_button_tooltip = update_vote(voters, previous_vote_answer, -1)
previous_vote_index = previous_vote_answer.index
end
local vote_button_count, vote_button_tooltip = update_vote(voters, answer, 1)
for _, p in pairs(game.connected_players) do
local frame = p.gui.left[main_frame_name]
if frame and frame.valid then
local data = Gui.get_data(frame)
if data.poll_index == poll_index then
local vote_buttons = data.vote_buttons
if previous_vote_answer then
local vote_button = vote_buttons[previous_vote_index]
vote_button.caption = previous_vote_button_count
vote_button.tooltip = previous_vote_button_tooltip
if p.index == player_index then
local vote_button_style = vote_button.style
vote_button_style.font_color = normal_color
vote_button_style.disabled_font_color = normal_color
end
end
local vote_button = vote_buttons[vote_index]
vote_button.caption = vote_button_count
vote_button.tooltip = vote_button_tooltip
if p.index == player_index then
local vote_button_style = vote_button.style
vote_button_style.font_color = focus_color
vote_button_style.disabled_font_color = focus_color
end
end
end
end
end
local function player_joined(event)
local player = Game.get_player_by_index(event.player_index)
if not player or not player.valid then
return
end
local gui = player.gui
if gui.top[main_button_name] ~= nil then
local frame = gui.left[main_frame_name]
if frame and frame.valid then
local data = Gui.get_data(frame)
update_poll_viewer(data)
end
else
gui.top.add {type = 'sprite-button', name = main_button_name, sprite = 'item/programmable-speaker'}
end
end
local function tick()
for _, p in pairs(game.connected_players) do
local frame = p.gui.left[main_frame_name]
if frame and frame.valid then
local data = Gui.get_data(frame)
local poll = polls[data.poll_index]
if poll then
local poll_enabled = do_remaining_time(poll, data.remaining_time_label)
if not poll_enabled then
for _, v in pairs(data.vote_buttons) do
v.enabled = poll_enabled
end
end
end
end
end
end
Event.add(defines.events.on_player_joined_game, player_joined)
Event.on_nth_tick(60, tick)
Gui.on_click(main_button_name, toggle)
Gui.on_click(
create_poll_button_name,
function(event)
local player = event.player
local left = player.gui.left
local frame = left[create_poll_frame_name]
if frame and frame.valid then
remove_create_poll_frame(frame, player.index)
else
draw_create_poll_frame(left, player)
end
end
)
Gui.on_click(
poll_view_edit_name,
function(event)
local player = event.player
local left = player.gui.left
local frame = left[create_poll_frame_name]
if frame and frame.valid then
Gui.remove_data_recursively(frame)
frame.destroy()
end
local main_frame = left[main_frame_name]
local frame_data = Gui.get_data(main_frame)
local poll = polls[frame_data.poll_index]
poll.edit_mode = true
draw_create_poll_frame(left, player, poll)
end
)
Gui.on_value_changed(
create_poll_duration_name,
function(event)
update_duration(event.element)
end
)
Gui.on_click(
create_poll_delete_answer_name,
function(event)
local button_data = Gui.get_data(event.element)
local data = button_data.data
table.remove(data.answers, button_data.count)
redraw_create_poll_content(data)
end
)
Gui.on_click(
create_poll_label_name,
function(event)
local textfield = Gui.get_data(event.element)
textfield.focus()
end
)
Gui.on_text_changed(
create_poll_question_name,
function(event)
local textfield = event.element
local data = Gui.get_data(textfield)
data.question = textfield.text
end
)
Gui.on_text_changed(
create_poll_answer_name,
function(event)
local textfield = event.element
local data = Gui.get_data(textfield)
data.answers[data.count].text = textfield.text
end
)
Gui.on_click(
create_poll_add_answer_name,
function(event)
local data = Gui.get_data(event.element)
insert(data.answers, {text = ''})
redraw_create_poll_content(data)
end
)
Gui.on_click(
create_poll_close_name,
function(event)
local frame = Gui.get_data(event.element)
remove_create_poll_frame(frame, event.player_index)
end
)
Gui.on_click(
create_poll_clear_name,
function(event)
local data = Gui.get_data(event.element)
local slider = data.duration_slider
slider.slider_value = math.floor(default_poll_duration * inv_tick_duration_step)
update_duration(slider)
data.question = ''
local answers = data.answers
for i = 1, #answers do
answers[i].text = ''
end
redraw_create_poll_content(data)
end
)
Gui.on_click(create_poll_confirm_name, create_poll)
Gui.on_click(
create_poll_delete_name,
function(event)
local player = event.player
local data = Gui.get_data(event.element)
local frame = data.frame
local poll = data.previous_data
Gui.remove_data_recursively(frame)
frame.destroy()
player_create_poll_data[player.index] = nil
local removed_index
for i, p in pairs(polls) do
if p == poll then
table.remove(polls, i)
removed_index = i
break
end
end
if not removed_index then
return
end
local message = table.concat {player.name, ' has deleted Poll #', poll.id, ': ', poll.question}
for _, p in pairs(game.connected_players) do
if not no_notify_players[p.index] then
p.print(message)
end
local main_frame = p.gui.left[main_frame_name]
if main_frame and main_frame.valid then
local main_frame_data = Gui.get_data(main_frame)
local poll_index = main_frame_data.poll_index
if removed_index < poll_index then
main_frame_data.poll_index = poll_index - 1
end
update_poll_viewer(main_frame_data)
end
end
end
)
Gui.on_click(
create_poll_edit_name,
function(event)
local player = event.player
local data = Gui.get_data(event.element)
local frame = data.frame
local poll = data.previous_data
local new_question = data.question
if not new_question:find('%S') then
player.print('Sorry, the poll needs a question.')
return
end
local new_answer_set = {}
local new_answers = {}
for _, a in pairs(data.answers) do
if a.text:find('%S') then
local source = a.source
local index = #new_answers + 1
if source then
new_answer_set[source] = a
source.text = a.text
source.index = index
new_answers[index] = source
else
new_answers[index] = {text = a.text, index = index, voted_count = 0}
end
end
end
if not next(new_answers) then
player.print('Sorry, the poll needs at least one answer.')
return
end
Gui.remove_data_recursively(frame)
frame.destroy()
local player_index = player.index
player_create_poll_data[player_index] = nil
local old_answers = poll.answers
local voters = poll.voters
for _, a in pairs(old_answers) do
if not new_answer_set[a] then
for pi, a2 in pairs(voters) do
if a == a2 then
voters[pi] = nil
end
end
end
end
poll.question = new_question
poll.answers = new_answers
poll.edited_by[player_index] = true
local start_tick = game.tick
local duration = data.duration
local end_tick
if duration == 0 then
end_tick = -1
else
end_tick = start_tick + duration
end
poll.start_tick = start_tick
poll.end_tick = end_tick
poll.duration = duration
local poll_index
for i, p in pairs(polls) do
if poll == p then
poll_index = i
break
end
end
if not poll_index then
insert(polls, poll)
poll_index = #polls
end
local message = table.concat {player.name, ' has edited Poll #', poll.id, ': ', poll.question}
for _, p in pairs(game.connected_players) do
local main_frame = p.gui.left[main_frame_name]
if no_notify_players[p.index] then
if main_frame and main_frame.valid then
local main_frame_data = Gui.get_data(main_frame)
update_poll_viewer(main_frame_data)
end
else
p.print(message)
if main_frame and main_frame.valid then
local main_frame_data = Gui.get_data(main_frame)
main_frame_data.poll_index = poll_index
update_poll_viewer(main_frame_data)
else
draw_main_frame(p.gui.left, p)
end
end
end
end
)
Gui.on_click(
notify_checkbox_name,
function(event)
local player_index = event.player_index
local checkbox = event.element
local new_state
if checkbox.state then
new_state = nil
else
new_state = true
end
no_notify_players[player_index] = new_state
end
)
local function do_direction(event, sign)
local count
if event.shift then
count = #polls
else
local button = event.button
if button == defines.mouse_button_type.right then
count = 5
else
count = 1
end
end
count = count * sign
local data = Gui.get_data(event.element)
data.poll_index = data.poll_index + count
update_poll_viewer(data)
end
Gui.on_click(
poll_view_back_name,
function(event)
do_direction(event, -1)
end
)
Gui.on_click(
poll_view_forward_name,
function(event)
do_direction(event, 1)
end
)
Gui.on_click(poll_view_vote_name, vote)
Gui.allow_player_to_toggle_top_element_visibility(main_button_name)
local Class = {}
function Class.validate(data)
if type(data) ~= 'table' then
return false, 'argument must be of type table'
end
local question = data.question
if type(question) ~= 'string' or question == '' then
return false, 'field question must be a non empty string.'
end
local answers = data.answers
if type(answers) ~= 'table' then
return false, 'answers field must be an array.'
end
if #answers == 0 then
return false, 'answer array must contain at least one entry.'
end
for _, a in pairs(answers) do
if type(a) ~= 'string' or a == '' then
return false, 'answers must be a non empty string.'
end
end
local duration = data.duration
local duration_type = type(duration)
if duration_type == 'number' then
if duration < 0 then
return false, 'duration cannot be negative, set duration to 0 for endless poll.'
end
elseif duration_type ~= 'nil' then
return false, 'duration must be of type number or nil'
end
return true
end
function Class.poll(data)
local suc, error = Class.validate(data)
if not suc then
return false, error
end
local answers = {}
for index, a in pairs(data.answers) do
if a ~= '' then
insert(answers, {text = a, index = index, voted_count = 0})
end
end
local duration = data.duration
if duration then
duration = duration * 60
else
duration = default_poll_duration
end
local start_tick = game.tick
local end_tick
if duration == 0 then
end_tick = -1
else
end_tick = start_tick + duration
end
local id = poll_id()
local poll_data = {
id = id,
question = data.question,
answers = answers,
voters = {},
start_tick = start_tick,
end_tick = end_tick,
duration = duration,
created_by = game.player or {name = '<server>', valid = true},
edited_by = {}
}
insert(polls, poll_data)
show_new_poll(poll_data)
send_poll_result_to_discord(poll_data)
return true, id
end
function Class.poll_result(id)
if type(id) ~= 'number' then
return 'poll-id must be a number'
end
for _, poll_data in pairs(polls) do
if poll_data.id == id then
local result = {'Question: ', poll_data.question, ' Answers: '}
local answers = poll_data.answers
local answers_count = #answers
for i, a in pairs(answers) do
insert(result, '( [')
insert(result, a.voted_count)
insert(result, '] - ')
insert(result, a.text)
insert(result, ' )')
if i ~= answers_count then
insert(result, ', ')
end
end
return table.concat(result)
end
end
return table.concat {'poll #', id, ' not found'}
end
local function poll_command(cmd)
local player = game.player
if player and not (player.admin or UserGroups.is_regular(player.name)) then
Utils.cant_run(cmd.name)
end
local param = cmd.parameter
if not param then
Game.player_print('Usage: /poll <{question = "question", answers = {"answer 1", "answer 2"}, duration = 300 | nil}>')
return
end
param = 'return ' .. param
local func, error = loadstring(param)
if not func then
Game.player_print(error)
return
end
local suc, result = Class.poll(func())
if not suc then
Game.player_print(result)
else
Game.player_print(table.concat {'Poll #', result, ' successfully created.'})
end
end
local function poll_result_command(cmd)
local param = cmd.parameter
if not param then
Game.player_print('Usage: /poll-result <poll#>')
return
end
local id = tonumber(param)
local result = Class.poll_result(id)
Game.player_print(result)
end
function Class.send_poll_result_to_discord(id)
if type(id) ~= 'number' then
Server.to_discord_embed('poll-id must be a number')
return
end
for _, poll_data in pairs(polls) do
if poll_data.id == id then
send_poll_result_to_discord(poll_data)
return
end
end
local message = table.concat {'poll #', id, ' not found'}
Server.to_discord_embed(message)
end
commands.add_command(
'poll',
'<{question = "question", answers = {"answer 1", "answer 2"}, duration = 300 | nil}> - Creates a new poll (Admin and regulars only).',
poll_command
)
commands.add_command('poll-result', '<poll#> - prints the result for the poll.', poll_result_command)
return Class