472 lines
16 KiB
Lua
472 lines
16 KiB
Lua
local channel_created_string = "|#${channel_name}| Channel created"
|
|
local channel_invitation_string = "|#${channel_name}| Channel invite from (${from_player}), " ..
|
|
"to join the channel, do /jc ${channel_name},${channel_password} after " ..
|
|
"which you can send messages to the channel via #${channel_name}: message"
|
|
local channel_invited_string = "|#${channel_name}| Invite sent to ${to_player}"
|
|
local channel_deleted_string = "|#${channel_name}| Channel deleted"
|
|
local channel_joined_string = "|#${channel_name}| Joined channel"
|
|
local channel_left_string = "|#${channel_name}| Left channel"
|
|
local channel_already_deleted_string = "|#${channel_name}| Channel seems to have already been deleted, " ..
|
|
"will unregister channel from your list of channels"
|
|
|
|
local join_channel_sound = "beerchat_chirp" -- Sound when you join a channel
|
|
local leave_channel_sound = "beerchat_chirp" -- Sound when you leave a channel
|
|
local channel_invite_sound = "beerchat_chirp" -- Sound when sending/ receiving an invite to a channel
|
|
|
|
local create_channel = {
|
|
params = "<Channel Name>,<Password (optional)>,<Color (optional, default is #ffffff)>",
|
|
description = "Create a channel named <Channel Name> with optional <Password> and hexadecimal <Color> "..
|
|
"starting with # (e.g. #00ff00 for green). Use comma's to separate the arguments, e.g. "..
|
|
"/cc my secret channel,#0000ff for a blue colored my secret channel without password",
|
|
func = function(lname, param)
|
|
local lowner = lname
|
|
|
|
if not param or param == "" then
|
|
return false, "ERROR: Invalid number of arguments. Please supply the channel name as a minimum"
|
|
end
|
|
|
|
local str = string.split(param, ",")
|
|
if #str > 3 then
|
|
return false, "ERROR: Invalid number of arguments. 4 parameters passed, " ..
|
|
"maximum of 3 allowed: <Channel Name>,<Password>,<Color>"
|
|
end
|
|
|
|
local lchannel_name = string.trim(str[1] or "")
|
|
if lchannel_name == "" then
|
|
return false, "ERROR: You must supply a channel name"
|
|
end
|
|
|
|
if lchannel_name == beerchat.main_channel_name then
|
|
return false, "ERROR: You cannot use channel name \""..beerchat.main_channel_name.."\""
|
|
end
|
|
|
|
if beerchat.channels[lchannel_name] then
|
|
return false, "ERROR: Channel "..lchannel_name.." already exists, owned by player "..
|
|
beerchat.channels[lchannel_name].owner
|
|
end
|
|
|
|
local arg2 = str[2]
|
|
local lcolor = beerchat.default_channel_color
|
|
local lpassword = ""
|
|
|
|
if arg2 then
|
|
if string.sub(arg2, 1, 1) ~= "#" then
|
|
lpassword = arg2
|
|
else
|
|
lcolor = string.lower(str[2])
|
|
end
|
|
end
|
|
|
|
if #str == 3 then
|
|
lcolor = string.lower(str[3])
|
|
end
|
|
|
|
beerchat.channels[lchannel_name] = { owner = lowner, name = lchannel_name, password = lpassword, color = lcolor }
|
|
beerchat.mod_storage:set_string("channels", minetest.write_json(beerchat.channels))
|
|
|
|
beerchat.playersChannels[lowner][lchannel_name] = "owner"
|
|
minetest.get_player_by_name(lowner):get_meta():set_string(
|
|
"beerchat:channels",
|
|
minetest.write_json(beerchat.playersChannels[lowner])
|
|
)
|
|
if beerchat.enable_sounds then
|
|
minetest.sound_play(beerchat.channel_management_sound, { to_player = lowner, gain = beerchat.sounds_default_gain } )
|
|
end
|
|
minetest.chat_send_player(lowner, beerchat.format_message(channel_created_string, { channel_name = lchannel_name }))
|
|
|
|
return true
|
|
end
|
|
}
|
|
|
|
local delete_channel = {
|
|
params = "<Channel Name>",
|
|
description = "Delete channel named <Channel Name>. " ..
|
|
"You must be the owner of the channel or you are not allowed to delete the channel",
|
|
func = function(name, param)
|
|
if not param or param == "" then
|
|
return false, "ERROR: Invalid number of arguments. Please supply the channel name"
|
|
end
|
|
|
|
if param == beerchat.main_channel_name then
|
|
return false, "ERROR: Cannot delete the main channel!"
|
|
end
|
|
|
|
if not beerchat.channels[param] then
|
|
return false, "ERROR: Channel "..param.." does not exist"
|
|
end
|
|
|
|
if name ~= beerchat.channels[param].owner then
|
|
return false, "ERROR: You are not the owner of channel "..param
|
|
end
|
|
|
|
local color = beerchat.channels[param].color
|
|
beerchat.channels[param] = nil
|
|
beerchat.mod_storage:set_string("channels", minetest.write_json(beerchat.channels))
|
|
|
|
beerchat.playersChannels[name][param] = nil
|
|
minetest.get_player_by_name(name):get_meta():set_string(
|
|
"beerchat:channels",
|
|
minetest.write_json(beerchat.playersChannels[name])
|
|
)
|
|
|
|
if beerchat.enable_sounds then
|
|
minetest.sound_play(beerchat.channel_management_sound, { to_player = name, gain = beerchat.sounds_default_gain } )
|
|
end
|
|
|
|
minetest.chat_send_player(
|
|
name,
|
|
beerchat.format_message(channel_deleted_string, { channel_name = param, color = color })
|
|
)
|
|
|
|
return true
|
|
|
|
end
|
|
}
|
|
|
|
local my_channels = {
|
|
params = "<Channel Name optional>",
|
|
description = "List the channels you have joined or are the owner of, " ..
|
|
"or show channel information when passing channel name as argument",
|
|
func = function(name, param)
|
|
if not param or param == "" then
|
|
if beerchat.enable_sounds then
|
|
minetest.sound_play(beerchat.channel_management_sound, { to_player = name, gain = beerchat.sounds_default_gain } )
|
|
end
|
|
minetest.chat_send_player(name, dump2(beerchat.playersChannels[name]))
|
|
else
|
|
if beerchat.playersChannels[name][param] then
|
|
if beerchat.enable_sounds then
|
|
minetest.sound_play(beerchat.channel_management_sound, { to_player = name, gain = beerchat.sounds_default_gain } )
|
|
end
|
|
minetest.chat_send_player(name, dump2(beerchat.channels[param]))
|
|
else
|
|
minetest.chat_send_player(name, "ERROR: Channel not in your channel list")
|
|
return false
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
}
|
|
|
|
local join_channel = {
|
|
params = "<Channel Name>,<Password (only mandatory if channel was created using a password)>",
|
|
description = "Join channel named <Channel Name>. " ..
|
|
"After joining you will see messages sent to that channel (in addition to the other channels you have joined)",
|
|
func = function(name, param)
|
|
if beerchat.is_player_jailed(name) then
|
|
return false, "You are in chat-jail, no joining channels for you."
|
|
end
|
|
if not param or param == "" then
|
|
return false, "ERROR: Invalid number of arguments. Please supply the channel name as a minimum"
|
|
end
|
|
|
|
local str = string.split(param, ",")
|
|
local channel_name = str[1] or "<empty>"
|
|
|
|
if not beerchat.channels[channel_name] then
|
|
return false, "ERROR: Channel "..channel_name.." does not exist"
|
|
end
|
|
|
|
if beerchat.playersChannels[name] and beerchat.playersChannels[name][channel_name] then
|
|
return false, "ERROR: You already joined "..channel_name..", no need to rejoin"
|
|
end
|
|
|
|
if beerchat.channels[channel_name].password and beerchat.channels[channel_name].password ~= "" then
|
|
if #str == 1 then
|
|
return false, "ERROR: This channel requires that you supply a password. " ..
|
|
"Supply it in the following format: /jc my channel,password01"
|
|
end
|
|
if str[2] ~= beerchat.channels[channel_name].password then
|
|
return false, "ERROR: Invalid password"
|
|
end
|
|
end
|
|
|
|
beerchat.playersChannels[name] = beerchat.playersChannels[name] or {}
|
|
beerchat.playersChannels[name][channel_name] = "joined"
|
|
minetest.get_player_by_name(name):get_meta():set_string(
|
|
"beerchat:channels",
|
|
minetest.write_json(beerchat.playersChannels[name])
|
|
)
|
|
|
|
if beerchat.enable_sounds then
|
|
minetest.sound_play(join_channel_sound, { to_player = name, gain = beerchat.sounds_default_gain } )
|
|
end
|
|
minetest.chat_send_player(name, beerchat.format_message(channel_joined_string, { channel_name = channel_name }))
|
|
|
|
return true
|
|
|
|
end
|
|
}
|
|
|
|
local leave_channel = {
|
|
params = "<Channel Name>",
|
|
description = "Leave channel named <Channel Name>. " ..
|
|
"When you leave the channel you can no longer send/ receive messages from that channel. " ..
|
|
"NOTE: You can also leave the main channel",
|
|
func = function(name, param)
|
|
if beerchat.is_player_jailed(name) then
|
|
return false, "You are in chat-jail, no leaving for you."
|
|
end
|
|
if not param or param == "" then
|
|
return false, "ERROR: Invalid number of arguments. Please supply the channel name"
|
|
end
|
|
|
|
local channel_name = param
|
|
|
|
if not beerchat.playersChannels[name][channel_name] then
|
|
return false, "ERROR: You are not member of "..channel_name..", no need to leave"
|
|
end
|
|
|
|
beerchat.playersChannels[name][channel_name] = nil
|
|
minetest.get_player_by_name(name):get_meta():set_string(
|
|
"beerchat:channels",
|
|
minetest.write_json(beerchat.playersChannels[name])
|
|
)
|
|
|
|
if beerchat.enable_sounds then
|
|
minetest.sound_play(leave_channel_sound, { to_player = name, gain = beerchat.sounds_default_gain } )
|
|
end
|
|
if not beerchat.channels[channel_name] then
|
|
minetest.chat_send_player(
|
|
name,
|
|
beerchat.format_message(channel_already_deleted_string, { channel_name = channel_name })
|
|
)
|
|
else
|
|
minetest.chat_send_player(
|
|
name,
|
|
beerchat.format_message(channel_left_string, { channel_name = channel_name })
|
|
)
|
|
end
|
|
|
|
return true
|
|
|
|
end
|
|
}
|
|
|
|
local invite_channel = {
|
|
params = "<Channel Name>,<Player Name>",
|
|
description = "Invite player named <Player Name> to channel named <Channel Name>. " ..
|
|
"You must be the owner of the channel in order to do invites",
|
|
func = function(name, param)
|
|
if not param or param == "" then
|
|
return false, "ERROR: Invalid number of arguments. Please supply the channel name and the player name"
|
|
end
|
|
|
|
local channel_name, player_name = string.match(param, "(.*),(.*)")
|
|
|
|
if not channel_name or channel_name == "" then
|
|
return false, "ERROR: Channel name is empty"
|
|
end
|
|
|
|
if not player_name or player_name == "" then
|
|
return false, "ERROR: Player name not supplied or empty"
|
|
end
|
|
|
|
if not beerchat.channels[channel_name] then
|
|
return false, "ERROR: Channel "..channel_name.." does not exist"
|
|
end
|
|
|
|
if name ~= beerchat.channels[channel_name].owner then
|
|
return false, "ERROR: You are not the owner of channel "..param
|
|
end
|
|
|
|
if not minetest.get_player_by_name(player_name) then
|
|
return false, "ERROR: "..player_name.." does not exist or is not online"
|
|
else
|
|
if beerchat.is_player_jailed(player_name) then
|
|
return false, player_name .. " is in chat-jail, no inviting."
|
|
end
|
|
if not beerchat.has_player_muted_player(player_name, name) then
|
|
if beerchat.enable_sounds then
|
|
minetest.sound_play(channel_invite_sound, { to_player = player_name, gain = beerchat.sounds_default_gain } )
|
|
end
|
|
-- Sending the message
|
|
minetest.chat_send_player(
|
|
player_name,
|
|
beerchat.format_message(channel_invitation_string, { channel_name = channel_name, from_player = name })
|
|
)
|
|
end
|
|
if beerchat.enable_sounds then
|
|
minetest.sound_play(channel_invite_sound, { to_player = name, gain = beerchat.sounds_default_gain } )
|
|
end
|
|
minetest.chat_send_player(
|
|
name,
|
|
beerchat.format_message(channel_invited_string, { channel_name = channel_name, to_player = player_name })
|
|
)
|
|
end
|
|
|
|
return true
|
|
end
|
|
}
|
|
|
|
local mute_player = {
|
|
params = "<Player Name>",
|
|
description = "Mute a player. After muting a player, you will no longer see chat messages of this user, " ..
|
|
"regardless of what channel his user sends messages to",
|
|
func = function(name, param)
|
|
if beerchat.is_player_jailed(name) then
|
|
return false, "You are in chat-jail, no muting for you."
|
|
end
|
|
if not param or param == "" then
|
|
return false, "ERROR: Invalid number of arguments. Please supply the name of the user to mute"
|
|
end
|
|
|
|
if beerchat.has_player_muted_player(name, param) then
|
|
minetest.chat_send_player(name, "Player " .. param .. " is already muted.")
|
|
else
|
|
minetest.get_player_by_name(name):get_meta():set_string("beerchat:muted:" .. param, "true")
|
|
minetest.chat_send_player(name, "Muted player " .. param .. ".")
|
|
end
|
|
|
|
return true
|
|
|
|
end
|
|
}
|
|
|
|
local unmute_player = {
|
|
params = "<Player Name>",
|
|
description = "Unmute a player. After unmuting a player, you will again see chat messages of this user",
|
|
func = function(name, param)
|
|
if not param or param == "" then
|
|
return false, "ERROR: Invalid number of arguments. Please supply the name of the user to mute."
|
|
end
|
|
|
|
if beerchat.has_player_muted_player(name, param) then
|
|
minetest.get_player_by_name(name):get_meta():set_string("beerchat:muted:" .. param, nil)
|
|
minetest.chat_send_player(name, "Unmuted player " .. param .. ".")
|
|
else
|
|
minetest.chat_send_player(name, "Player " .. param .. " was not muted.")
|
|
end
|
|
|
|
return true
|
|
|
|
end
|
|
}
|
|
|
|
local list_muted = {
|
|
params = "",
|
|
description = "Show list of muted players.",
|
|
func = function(name)
|
|
|
|
local player = minetest.get_player_by_name(name)
|
|
local tMeta = player:get_meta():to_table()
|
|
|
|
if nil == tMeta or nil == tMeta.fields then return false end
|
|
|
|
local sOut = ""
|
|
for sKey, _ in pairs(tMeta.fields) do
|
|
if "beerchat:muted:" == sKey:sub(1, 15) then
|
|
sOut = sOut .. sKey:sub(16, -1) .. ', '
|
|
end
|
|
end
|
|
|
|
if 0 == #sOut then
|
|
sOut = "You have not muted any players."
|
|
else
|
|
-- remove trailing comma and space
|
|
sOut = sOut:sub(1, -3)
|
|
end
|
|
|
|
minetest.chat_send_player(name, sOut)
|
|
|
|
return true
|
|
|
|
end
|
|
}
|
|
|
|
beerchat.force_player_to_channel = function(name, param)
|
|
if not param or param == "" then
|
|
return false, "ERROR: Invalid number of arguments. Please supply the channel name and the player name."
|
|
end
|
|
|
|
local channel_name, player_name = string.match(param, "(.*), ?(.*)")
|
|
|
|
if not channel_name or channel_name == "" then
|
|
return false, "ERROR: Channel name is empty."
|
|
end
|
|
|
|
if not player_name or player_name == "" then
|
|
return false, "ERROR: Player name not supplied or empty."
|
|
end
|
|
|
|
if not beerchat.channels[channel_name] then
|
|
return false, "ERROR: Channel " .. channel_name .. " does not exist."
|
|
end
|
|
|
|
local player = minetest.get_player_by_name(player_name)
|
|
if not player then
|
|
return false, "ERROR: " .. player_name .. " does not exist or is not online."
|
|
else
|
|
local meta = player:get_meta()
|
|
-- force join
|
|
beerchat.playersChannels[player_name] = beerchat.playersChannels[player_name] or {}
|
|
beerchat.playersChannels[player_name][channel_name] = "joined"
|
|
meta:set_string(
|
|
"beerchat:channels",
|
|
minetest.write_json(beerchat.playersChannels[player_name])
|
|
)
|
|
-- force default channel
|
|
beerchat.currentPlayerChannel[player_name] = channel_name
|
|
meta:set_string("beerchat:current_channel", channel_name)
|
|
|
|
-- going to/from jail?
|
|
if channel_name == beerchat.jail_channel_name then
|
|
meta:set_int("beerchat:jailed", 1)
|
|
beerchat.jail_list[name] = true
|
|
elseif beerchat.is_player_jailed(player_name) then
|
|
meta:set_int("beerchat:jailed", 0)
|
|
beerchat.jail_list[name] = nil
|
|
end
|
|
|
|
-- inform user
|
|
minetest.chat_send_player(player_name, name .. " has set your default channel to "
|
|
.. channel_name .. ".")
|
|
-- feedback to mover
|
|
minetest.chat_send_player(name, "Set default channel of " .. player_name
|
|
.. " to " .. channel_name .. ".")
|
|
-- inform admin
|
|
minetest.log("action", "CHAT " .. name .. " moved " .. player_name
|
|
.. " to channel " .. channel_name)
|
|
end
|
|
return true
|
|
end
|
|
|
|
local force_player_to_channel = {
|
|
params = "<Channel Name>, <Player Name>",
|
|
description = "Force player named <Player Name> to channel named <Channel Name>. " ..
|
|
"You must have ban priv to use this.",
|
|
privs = { ban = true },
|
|
func = beerchat.force_player_to_channel
|
|
}
|
|
|
|
local whisper = {
|
|
params = "<message>",
|
|
description = "Whisper command for those who can't use $",
|
|
func = function(name, param) beerchat.whisper(name, "$ " .. param) end
|
|
}
|
|
|
|
minetest.register_chatcommand("cc", create_channel)
|
|
minetest.register_chatcommand("create_channel", create_channel)
|
|
minetest.register_chatcommand("dc", delete_channel)
|
|
minetest.register_chatcommand("delete_channel", delete_channel)
|
|
|
|
minetest.register_chatcommand("mc", my_channels)
|
|
minetest.register_chatcommand("my_channels", my_channels)
|
|
|
|
minetest.register_chatcommand("jc", join_channel)
|
|
minetest.register_chatcommand("join_channel", join_channel)
|
|
minetest.register_chatcommand("lc", leave_channel)
|
|
minetest.register_chatcommand("leave_channel", leave_channel)
|
|
minetest.register_chatcommand("ic", invite_channel)
|
|
minetest.register_chatcommand("invite_channel", invite_channel)
|
|
|
|
minetest.register_chatcommand("mute", mute_player)
|
|
minetest.register_chatcommand("ignore", mute_player)
|
|
minetest.register_chatcommand("unmute", unmute_player)
|
|
minetest.register_chatcommand("unignore", unmute_player)
|
|
minetest.register_chatcommand("list_muted", list_muted)
|
|
|
|
minetest.register_chatcommand("force2channel", force_player_to_channel)
|
|
|
|
minetest.register_chatcommand("whis", whisper)
|