forked from Mirrorlandia_minetest/minetest
5e507c9829
This adds a chat console the server owner can use for administration or to talk with players. It runs in its own thread, which makes the user interface immune to the server's lag, behaving just like a client, except timeout. As it uses the same console code as the f10 console, things like nick completion or a scroll buffer basically come for free. The terminal itself is written in a general way so that adding a client version later on is just about implementing an interface. Fatal errors are printed after the console exists and the ncurses terminal buffer gets cleaned up with endwin(), so that the error still remains visible. The server owner can chose their username their entered text will have in chat and where players can send PMs to. Once the username is secured with a password to prevent anybody to take over the server, the owner can execute admin tasks over the console. This change includes a contribution by @kahrl who has improved ncurses library detection.
276 lines
7.1 KiB
C++
276 lines
7.1 KiB
C++
/*
|
|
Minetest
|
|
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#ifndef CHAT_HEADER
|
|
#define CHAT_HEADER
|
|
|
|
#include "irrlichttypes.h"
|
|
#include <string>
|
|
#include <vector>
|
|
#include <list>
|
|
|
|
// Chat console related classes
|
|
|
|
struct ChatLine
|
|
{
|
|
// age in seconds
|
|
f32 age;
|
|
// name of sending player, or empty if sent by server
|
|
std::wstring name;
|
|
// message text
|
|
std::wstring text;
|
|
|
|
ChatLine(std::wstring a_name, std::wstring a_text):
|
|
age(0.0),
|
|
name(a_name),
|
|
text(a_text)
|
|
{
|
|
}
|
|
};
|
|
|
|
struct ChatFormattedFragment
|
|
{
|
|
// text string
|
|
std::wstring text;
|
|
// starting column
|
|
u32 column;
|
|
// formatting
|
|
//u8 bold:1;
|
|
};
|
|
|
|
struct ChatFormattedLine
|
|
{
|
|
// Array of text fragments
|
|
std::vector<ChatFormattedFragment> fragments;
|
|
// true if first line of one formatted ChatLine
|
|
bool first;
|
|
};
|
|
|
|
class ChatBuffer
|
|
{
|
|
public:
|
|
ChatBuffer(u32 scrollback);
|
|
~ChatBuffer();
|
|
|
|
// Append chat line
|
|
// Removes oldest chat line if scrollback size is reached
|
|
void addLine(std::wstring name, std::wstring text);
|
|
|
|
// Remove all chat lines
|
|
void clear();
|
|
|
|
// Get number of lines currently in buffer.
|
|
u32 getLineCount() const;
|
|
// Get scrollback size, maximum number of lines in buffer.
|
|
u32 getScrollback() const;
|
|
// Get reference to i-th chat line.
|
|
const ChatLine& getLine(u32 index) const;
|
|
|
|
// Increase each chat line's age by dtime.
|
|
void step(f32 dtime);
|
|
// Delete oldest N chat lines.
|
|
void deleteOldest(u32 count);
|
|
// Delete lines older than maxAge.
|
|
void deleteByAge(f32 maxAge);
|
|
|
|
// Get number of columns, 0 if reformat has not been called yet.
|
|
u32 getColumns() const;
|
|
// Get number of rows, 0 if reformat has not been called yet.
|
|
u32 getRows() const;
|
|
// Update console size and reformat all formatted lines.
|
|
void reformat(u32 cols, u32 rows);
|
|
// Get formatted line for a given row (0 is top of screen).
|
|
// Only valid after reformat has been called at least once
|
|
const ChatFormattedLine& getFormattedLine(u32 row) const;
|
|
// Scrolling in formatted buffer (relative)
|
|
// positive rows == scroll up, negative rows == scroll down
|
|
void scroll(s32 rows);
|
|
// Scrolling in formatted buffer (absolute)
|
|
void scrollAbsolute(s32 scroll);
|
|
// Scroll to bottom of buffer (newest)
|
|
void scrollBottom();
|
|
// Scroll to top of buffer (oldest)
|
|
void scrollTop();
|
|
|
|
// Format a chat line for the given number of columns.
|
|
// Appends the formatted lines to the destination array and
|
|
// returns the number of formatted lines.
|
|
u32 formatChatLine(const ChatLine& line, u32 cols,
|
|
std::vector<ChatFormattedLine>& destination) const;
|
|
|
|
protected:
|
|
s32 getTopScrollPos() const;
|
|
s32 getBottomScrollPos() const;
|
|
|
|
private:
|
|
// Scrollback size
|
|
u32 m_scrollback;
|
|
// Array of unformatted chat lines
|
|
std::vector<ChatLine> m_unformatted;
|
|
|
|
// Number of character columns in console
|
|
u32 m_cols;
|
|
// Number of character rows in console
|
|
u32 m_rows;
|
|
// Scroll position (console's top line index into m_formatted)
|
|
s32 m_scroll;
|
|
// Array of formatted lines
|
|
std::vector<ChatFormattedLine> m_formatted;
|
|
// Empty formatted line, for error returns
|
|
ChatFormattedLine m_empty_formatted_line;
|
|
};
|
|
|
|
class ChatPrompt
|
|
{
|
|
public:
|
|
ChatPrompt(std::wstring prompt, u32 history_limit);
|
|
~ChatPrompt();
|
|
|
|
// Input character or string
|
|
void input(wchar_t ch);
|
|
void input(const std::wstring &str);
|
|
|
|
// Submit, clear and return current line
|
|
std::wstring submit();
|
|
|
|
// Clear the current line
|
|
void clear();
|
|
|
|
// Replace the current line with the given text
|
|
void replace(std::wstring line);
|
|
|
|
// Select previous command from history
|
|
void historyPrev();
|
|
// Select next command from history
|
|
void historyNext();
|
|
|
|
// Nick completion
|
|
void nickCompletion(const std::list<std::string>& names, bool backwards);
|
|
|
|
// Update console size and reformat the visible portion of the prompt
|
|
void reformat(u32 cols);
|
|
// Get visible portion of the prompt.
|
|
std::wstring getVisiblePortion() const;
|
|
// Get cursor position (relative to visible portion). -1 if invalid
|
|
s32 getVisibleCursorPosition() const;
|
|
|
|
// Cursor operations
|
|
enum CursorOp {
|
|
CURSOROP_MOVE,
|
|
CURSOROP_DELETE
|
|
};
|
|
|
|
// Cursor operation direction
|
|
enum CursorOpDir {
|
|
CURSOROP_DIR_LEFT,
|
|
CURSOROP_DIR_RIGHT
|
|
};
|
|
|
|
// Cursor operation scope
|
|
enum CursorOpScope {
|
|
CURSOROP_SCOPE_CHARACTER,
|
|
CURSOROP_SCOPE_WORD,
|
|
CURSOROP_SCOPE_LINE
|
|
};
|
|
|
|
// Cursor operation
|
|
// op specifies whether it's a move or delete operation
|
|
// dir specifies whether the operation goes left or right
|
|
// scope specifies how far the operation will reach (char/word/line)
|
|
// Examples:
|
|
// cursorOperation(CURSOROP_MOVE, CURSOROP_DIR_RIGHT, CURSOROP_SCOPE_LINE)
|
|
// moves the cursor to the end of the line.
|
|
// cursorOperation(CURSOROP_DELETE, CURSOROP_DIR_LEFT, CURSOROP_SCOPE_WORD)
|
|
// deletes the word to the left of the cursor.
|
|
void cursorOperation(CursorOp op, CursorOpDir dir, CursorOpScope scope);
|
|
|
|
protected:
|
|
// set m_view to ensure that 0 <= m_view <= m_cursor < m_view + m_cols
|
|
// if line can be fully shown, set m_view to zero
|
|
// else, also ensure m_view <= m_line.size() + 1 - m_cols
|
|
void clampView();
|
|
|
|
private:
|
|
// Prompt prefix
|
|
std::wstring m_prompt;
|
|
// Currently edited line
|
|
std::wstring m_line;
|
|
// History buffer
|
|
std::vector<std::wstring> m_history;
|
|
// History index (0 <= m_history_index <= m_history.size())
|
|
u32 m_history_index;
|
|
// Maximum number of history entries
|
|
u32 m_history_limit;
|
|
|
|
// Number of columns excluding columns reserved for the prompt
|
|
s32 m_cols;
|
|
// Start of visible portion (index into m_line)
|
|
s32 m_view;
|
|
// Cursor (index into m_line)
|
|
s32 m_cursor;
|
|
|
|
// Last nick completion start (index into m_line)
|
|
s32 m_nick_completion_start;
|
|
// Last nick completion start (index into m_line)
|
|
s32 m_nick_completion_end;
|
|
};
|
|
|
|
class ChatBackend
|
|
{
|
|
public:
|
|
ChatBackend();
|
|
~ChatBackend();
|
|
|
|
// Add chat message
|
|
void addMessage(std::wstring name, std::wstring text);
|
|
// Parse and add unparsed chat message
|
|
void addUnparsedMessage(std::wstring line);
|
|
|
|
// Get the console buffer
|
|
ChatBuffer& getConsoleBuffer();
|
|
// Get the recent messages buffer
|
|
ChatBuffer& getRecentBuffer();
|
|
// Concatenate all recent messages
|
|
std::wstring getRecentChat();
|
|
// Get the console prompt
|
|
ChatPrompt& getPrompt();
|
|
|
|
// Reformat all buffers
|
|
void reformat(u32 cols, u32 rows);
|
|
|
|
// Clear all recent messages
|
|
void clearRecentChat();
|
|
|
|
// Age recent messages
|
|
void step(float dtime);
|
|
|
|
// Scrolling
|
|
void scroll(s32 rows);
|
|
void scrollPageDown();
|
|
void scrollPageUp();
|
|
|
|
private:
|
|
ChatBuffer m_console_buffer;
|
|
ChatBuffer m_recent_buffer;
|
|
ChatPrompt m_prompt;
|
|
};
|
|
|
|
#endif
|
|
|