mirror of
https://github.com/ClassiCube/ClassiCube.git
synced 2025-10-07 13:06:51 -04:00
446 lines
14 KiB
C#
446 lines
14 KiB
C#
// ClassicalSharp copyright 2014-2016 UnknownShadow200 | Licensed under MIT
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using ClassicalSharp.Events;
|
|
using ClassicalSharp.Gui.Widgets;
|
|
using ClassicalSharp.Network;
|
|
using OpenTK.Input;
|
|
|
|
namespace ClassicalSharp.Gui.Screens {
|
|
public class ChatScreen : Screen {
|
|
|
|
public ChatScreen( Game game ) : base( game ) {
|
|
chatLines = game.ChatLines;
|
|
}
|
|
|
|
int chatLines;
|
|
ChatTextWidget announcement;
|
|
TextInputWidget textInput;
|
|
TextGroupWidget status, bottomRight, normalChat, clientStatus;
|
|
bool suppressNextPress = true;
|
|
int chatIndex;
|
|
int blockSize;
|
|
|
|
Font chatFont, chatUrlFont, announcementFont;
|
|
public override void Init() {
|
|
float textScale = game.Drawer2D.UseBitmappedChat ? 1.25f : 1;
|
|
int fontSize = (int)(12 * game.GuiChatScale * textScale);
|
|
Utils.Clamp( ref fontSize, 8, 60 );
|
|
chatFont = new Font( game.FontName, fontSize );
|
|
chatUrlFont = new Font( game.FontName, fontSize, FontStyle.Underline );
|
|
|
|
fontSize = (int)(14 * game.GuiChatScale);
|
|
Utils.Clamp( ref fontSize, 8, 60 );
|
|
announcementFont = new Font( game.FontName, fontSize );
|
|
blockSize = (int)(23 * 2 * game.GuiHotbarScale);
|
|
ConstructWidgets();
|
|
|
|
int[] indices = new int[chatLines];
|
|
for( int i = 0; i < indices.Length; i++ )
|
|
indices[i] = -1;
|
|
Metadata = indices;
|
|
SetInitialMessages();
|
|
|
|
game.Events.ChatReceived += ChatReceived;
|
|
game.Events.ChatFontChanged += ChatFontChanged;
|
|
game.Events.ColourCodeChanged += ColourCodeChanged;
|
|
}
|
|
|
|
void ConstructWidgets() {
|
|
textInput = new TextInputWidget( game, chatFont );
|
|
textInput.YOffset = 5;
|
|
status = new TextGroupWidget( game, 5, chatFont, chatUrlFont,
|
|
Anchor.BottomOrRight, Anchor.LeftOrTop );
|
|
status.Init();
|
|
status.SetUsePlaceHolder( 0, false );
|
|
status.SetUsePlaceHolder( 1, false );
|
|
bottomRight = new TextGroupWidget( game, 3, chatFont, chatUrlFont,
|
|
Anchor.BottomOrRight, Anchor.BottomOrRight );
|
|
bottomRight.YOffset = blockSize + 15;
|
|
bottomRight.Init();
|
|
normalChat = new TextGroupWidget( game, chatLines, chatFont, chatUrlFont,
|
|
Anchor.LeftOrTop, Anchor.BottomOrRight );
|
|
normalChat.XOffset = 10;
|
|
normalChat.YOffset = blockSize + 15;
|
|
normalChat.Init();
|
|
clientStatus = new TextGroupWidget( game, game.Chat.ClientStatus.Length, chatFont,
|
|
chatUrlFont, Anchor.LeftOrTop, Anchor.BottomOrRight );
|
|
clientStatus.XOffset = 10;
|
|
clientStatus.YOffset = blockSize + 15;
|
|
clientStatus.Init();
|
|
announcement = ChatTextWidget.Create( game, 0, 0, null,
|
|
Anchor.Centre, Anchor.Centre, announcementFont );
|
|
announcement.YOffset = -game.Height / 4;
|
|
}
|
|
|
|
void SetInitialMessages() {
|
|
Chat chat = game.Chat;
|
|
chatIndex = chat.Log.Count - chatLines;
|
|
ResetChat();
|
|
status.SetText( 2, chat.Status1.Text );
|
|
status.SetText( 3, chat.Status2.Text );
|
|
status.SetText( 4, chat.Status3.Text );
|
|
if( game.ShowClock ) status.SetText( 0, chat.ClientClock.Text );
|
|
|
|
bottomRight.SetText( 2, chat.BottomRight1.Text );
|
|
bottomRight.SetText( 1, chat.BottomRight2.Text );
|
|
bottomRight.SetText( 0, chat.BottomRight3.Text );
|
|
announcement.SetText( chat.Announcement.Text );
|
|
for( int i = 0; i < chat.ClientStatus.Length; i++ )
|
|
clientStatus.SetText( i, chat.ClientStatus[i].Text );
|
|
|
|
if( game.chatInInputBuffer != null ) {
|
|
OpenTextInputBar( game.chatInInputBuffer );
|
|
game.chatInInputBuffer = null;
|
|
}
|
|
}
|
|
|
|
public override void Render( double delta ) {
|
|
if( !game.ClassicMode ) {
|
|
status.Render( delta );
|
|
bottomRight.Render( delta );
|
|
}
|
|
CheckOtherStatuses();
|
|
|
|
UpdateChatYOffset( false );
|
|
RenderClientStatus();
|
|
DateTime now = DateTime.UtcNow;
|
|
if( HandlesAllInput )
|
|
normalChat.Render( delta );
|
|
else
|
|
RenderRecentChat( now, delta );
|
|
|
|
if( !game.ClassicMode )
|
|
announcement.Render( delta );
|
|
if( HandlesAllInput )
|
|
textInput.Render( delta );
|
|
|
|
if( announcement.IsValid && (now - game.Chat.Announcement.Received).TotalSeconds > 5 )
|
|
announcement.Dispose();
|
|
}
|
|
|
|
int lastDownloadStatus = int.MinValue;
|
|
StringBuffer lastDownload = new StringBuffer( 48 );
|
|
void CheckOtherStatuses() {
|
|
bool clockValid = status.Textures[0].IsValid;
|
|
if( game.ShowClock ) {
|
|
if( !clockValid ) status.SetText( 0, game.Chat.ClientClock.Text );
|
|
} else if( clockValid ) {
|
|
status.SetText( 0, null );
|
|
}
|
|
|
|
Request item = game.AsyncDownloader.CurrentItem;
|
|
if( item == null || !(item.Identifier == "terrain" || item.Identifier == "texturePack") ) {
|
|
if( status.Textures[1].IsValid ) status.SetText( 1, null );
|
|
lastDownloadStatus = int.MinValue;
|
|
return;
|
|
}
|
|
|
|
int progress = game.AsyncDownloader.CurrentItemProgress;
|
|
if( progress == lastDownloadStatus ) return;
|
|
lastDownloadStatus = progress;
|
|
SetFetchStatus( progress );
|
|
}
|
|
|
|
void SetFetchStatus( int progress ) {
|
|
lastDownload.Clear();
|
|
int index = 0;
|
|
if( progress == -2 ) {
|
|
lastDownload.Append( ref index, "&eRetrieving texture pack.." );
|
|
} else if( progress == -1 ) {
|
|
lastDownload.Append( ref index, "&eDownloading texture pack" );
|
|
} else if( progress >= 0 && progress <= 100 ) {
|
|
lastDownload.Append( ref index, "&eDownloading texture pack (&7" )
|
|
.AppendNum( ref index, progress ).Append( ref index, "&e%)" );
|
|
}
|
|
status.SetText( 1, lastDownload.ToString() );
|
|
}
|
|
|
|
void RenderRecentChat( DateTime now, double delta ) {
|
|
int[] metadata = (int[])Metadata;
|
|
for( int i = 0; i < normalChat.Textures.Length; i++ ) {
|
|
Texture texture = normalChat.Textures[i];
|
|
if( !texture.IsValid || metadata[i] == -1 ) continue;
|
|
|
|
DateTime received = game.Chat.Log[metadata[i]].Received;
|
|
if( (now - received).TotalSeconds <= 10 )
|
|
texture.Render( api );
|
|
}
|
|
}
|
|
|
|
void RenderClientStatus() {
|
|
int y = clientStatus.Y + clientStatus.Height;
|
|
for( int i = 0; i < clientStatus.Textures.Length; i++ ) {
|
|
Texture texture = clientStatus.Textures[i];
|
|
if( !texture.IsValid ) continue;
|
|
|
|
y -= texture.Height;
|
|
texture.Y1 = y;
|
|
texture.Render( api );
|
|
}
|
|
}
|
|
|
|
static FastColour backColour = new FastColour( 0, 0, 0, 127 );
|
|
public void RenderBackground() {
|
|
int minIndex = Math.Min( 0, game.Chat.Log.Count - chatLines );
|
|
int height = chatIndex == minIndex ? normalChat.GetUsedHeight() : normalChat.Height;
|
|
|
|
int y = normalChat.Y + normalChat.Height - height - 5;
|
|
int x = normalChat.X - 5;
|
|
int width = Math.Max( clientStatus.Width, normalChat.Width ) + 10;
|
|
|
|
int boxHeight = height + clientStatus.GetUsedHeight();
|
|
if( boxHeight > 0 )
|
|
api.Draw2DQuad( x, y, width, boxHeight + 10, backColour );
|
|
}
|
|
|
|
int inputOldHeight = -1;
|
|
void UpdateChatYOffset( bool force ) {
|
|
int height = textInput.UsedHeight;
|
|
if( force || height != inputOldHeight ) {
|
|
clientStatus.YOffset = Math.Max( blockSize + 15, height );
|
|
int y = game.Height - clientStatus.Height - clientStatus.YOffset;
|
|
clientStatus.MoveTo( clientStatus.X, y );
|
|
|
|
normalChat.YOffset = clientStatus.YOffset + clientStatus.GetUsedHeight();
|
|
y = game.Height - normalChat.Height - normalChat.YOffset;
|
|
normalChat.MoveTo( normalChat.X, y );
|
|
inputOldHeight = height;
|
|
}
|
|
}
|
|
|
|
void ColourCodeChanged( object sender, ColourCodeEventArgs e ) {
|
|
textInput.altText.UpdateColours();
|
|
Recreate( normalChat, e.Code ); Recreate( status, e.Code );
|
|
Recreate( bottomRight, e.Code ); Recreate( clientStatus, e.Code );
|
|
textInput.Recreate();
|
|
}
|
|
|
|
void Recreate( TextGroupWidget group, char code ) {
|
|
for( int i = 0; i < group.lines.Length; i++ ) {
|
|
string line = group.lines[i];
|
|
if( line == null ) continue;
|
|
|
|
for( int j = 0; j < line.Length - 1; j++ ) {
|
|
if( line[j] == '&' && line[j + 1] == code ) {
|
|
group.SetText( i, line ); break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChatReceived( object sender, ChatEventArgs e ) {
|
|
MessageType type = e.Type;
|
|
if( type == MessageType.Normal ) {
|
|
chatIndex++;
|
|
if( game.ChatLines == 0 ) return;
|
|
List<ChatLine> chat = game.Chat.Log;
|
|
normalChat.PushUpAndReplaceLast( chat[chatIndex + chatLines - 1].Text );
|
|
|
|
int[] metadata = (int[])Metadata;
|
|
for( int i = 0; i < chatLines - 1; i++ )
|
|
metadata[i] = metadata[i + 1];
|
|
metadata[chatLines - 1] = chatIndex + chatLines - 1;
|
|
} else if( type >= MessageType.Status1 && type <= MessageType.Status3 ) {
|
|
status.SetText( 2 + (int)(type - MessageType.Status1), e.Text );
|
|
} else if( type >= MessageType.BottomRight1 && type <= MessageType.BottomRight3 ) {
|
|
bottomRight.SetText( 2 - (int)(type - MessageType.BottomRight1), e.Text );
|
|
} else if( type == MessageType.Announcement ) {
|
|
announcement.SetText( e.Text );
|
|
} else if( type >= MessageType.ClientStatus1 && type <= MessageType.ClientStatus6 ) {
|
|
clientStatus.SetText( (int)(type - MessageType.ClientStatus1), e.Text );
|
|
UpdateChatYOffset( true );
|
|
} else if( type == MessageType.ClientClock && game.ShowClock ) {
|
|
status.SetText( 0, e.Text );
|
|
}
|
|
}
|
|
|
|
public override void Dispose() {
|
|
if( HandlesAllInput ) {
|
|
game.chatInInputBuffer = textInput.buffer.ToString();
|
|
game.CursorVisible = false;
|
|
} else {
|
|
game.chatInInputBuffer = null;
|
|
}
|
|
chatFont.Dispose();
|
|
chatUrlFont.Dispose();
|
|
announcementFont.Dispose();
|
|
|
|
normalChat.Dispose();
|
|
textInput.DisposeFully();
|
|
status.Dispose();
|
|
bottomRight.Dispose();
|
|
clientStatus.Dispose();
|
|
announcement.Dispose();
|
|
|
|
game.Events.ChatReceived -= ChatReceived;
|
|
game.Events.ChatFontChanged -= ChatFontChanged;
|
|
game.Events.ColourCodeChanged -= ColourCodeChanged;
|
|
}
|
|
|
|
void ChatFontChanged( object sender, EventArgs e ) {
|
|
if( !game.Drawer2D.UseBitmappedChat ) return;
|
|
Recreate();
|
|
UpdateChatYOffset( true );
|
|
}
|
|
|
|
public override void OnResize( int width, int height ) {
|
|
announcement.OnResize( width, height );
|
|
announcement.YOffset = -height / 4;
|
|
announcement.MoveTo( announcement.X, announcement.YOffset - announcement.Height / 2 );
|
|
blockSize = (int)(23 * 2 * game.GuiHotbarScale);
|
|
textInput.YOffset = 5;
|
|
bottomRight.YOffset = blockSize * 3 / 2;
|
|
|
|
int inputY = game.Height - textInput.Height - textInput.YOffset;
|
|
textInput.MoveTo( textInput.X, inputY );
|
|
status.OnResize( width, height );
|
|
bottomRight.OnResize( width, height );
|
|
UpdateChatYOffset( true );
|
|
}
|
|
|
|
void ResetChat() {
|
|
normalChat.Dispose();
|
|
List<ChatLine> chat = game.Chat.Log;
|
|
int[] metadata = (int[])Metadata;
|
|
for( int i = 0; i < chatLines; i++ )
|
|
metadata[i] = -1;
|
|
|
|
for( int i = chatIndex; i < chatIndex + chatLines; i++ ) {
|
|
if( i >= 0 && i < chat.Count ) {
|
|
normalChat.PushUpAndReplaceLast( chat[i].Text );
|
|
metadata[i - chatIndex] = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override bool HandlesKeyPress( char key ) {
|
|
if( !HandlesAllInput ) return false;
|
|
if( suppressNextPress ) {
|
|
suppressNextPress = false;
|
|
return false;
|
|
}
|
|
return textInput.HandlesKeyPress( key );
|
|
}
|
|
|
|
public void OpenTextInputBar( string initialText ) {
|
|
game.CursorVisible = true;
|
|
suppressNextPress = true;
|
|
HandlesAllInput = true;
|
|
game.Keyboard.KeyRepeat = true;
|
|
|
|
textInput.buffer.Clear();
|
|
textInput.buffer.Append( 0, initialText );
|
|
textInput.Init();
|
|
}
|
|
|
|
public void AppendTextToInput( string text ) {
|
|
if( !HandlesAllInput ) return;
|
|
textInput.AppendText( text );
|
|
}
|
|
|
|
public override bool HandlesKeyDown( Key key ) {
|
|
suppressNextPress = false;
|
|
|
|
if( HandlesAllInput ) { // text input bar
|
|
if( key == game.Mapping( KeyBind.SendChat ) || key == Key.KeypadEnter
|
|
|| key == game.Mapping( KeyBind.PauseOrExit ) ) {
|
|
HandlesAllInput = false;
|
|
game.CursorVisible = false;
|
|
game.Camera.RegrabMouse();
|
|
game.Keyboard.KeyRepeat = false;
|
|
|
|
if( key == game.Mapping( KeyBind.PauseOrExit ) )
|
|
textInput.Clear();
|
|
textInput.SendTextInBufferAndReset();
|
|
|
|
chatIndex = game.Chat.Log.Count - chatLines;
|
|
ScrollHistory();
|
|
} else if( key == Key.PageUp ) {
|
|
chatIndex -= chatLines;
|
|
ScrollHistory();
|
|
} else if( key == Key.PageDown ) {
|
|
chatIndex += chatLines;
|
|
ScrollHistory();
|
|
} else {
|
|
textInput.HandlesKeyDown( key );
|
|
}
|
|
return key < Key.F1 || key > Key.F35;
|
|
}
|
|
|
|
if( key == game.Mapping( KeyBind.Chat ) ) {
|
|
OpenTextInputBar( "" );
|
|
} else if( key == Key.Slash ) {
|
|
OpenTextInputBar( "/" );
|
|
} else {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override bool HandlesMouseScroll( int delta ) {
|
|
if( !HandlesAllInput ) return false;
|
|
chatIndex -= delta;
|
|
ScrollHistory();
|
|
return true;
|
|
}
|
|
|
|
public override bool HandlesMouseClick( int mouseX, int mouseY, MouseButton button ) {
|
|
if( !HandlesAllInput || game.HideGui ) return false;
|
|
if( !normalChat.Bounds.Contains( mouseX, mouseY ) )
|
|
return textInput.HandlesMouseClick( mouseX, mouseY, button );
|
|
|
|
int height = normalChat.GetUsedHeight();
|
|
int y = normalChat.Y + normalChat.Height - height;
|
|
if( new Rectangle( normalChat.X, y, normalChat.Width, height ).Contains( mouseX, mouseY ) )
|
|
return HandlesChatClick( mouseX, mouseY );
|
|
return false;
|
|
}
|
|
|
|
bool HandlesChatClick( int mouseX, int mouseY ) {
|
|
string text = normalChat.GetSelected( mouseX, mouseY );
|
|
if( text == null ) return false;
|
|
string url = Utils.StripColours( text );
|
|
|
|
if( Utils.IsUrlPrefix( url, 0 ) ) {
|
|
game.Gui.ShowWarning( new WarningScreen(
|
|
game, url, false, false, "Are you sure you want to go to this url?",
|
|
OpenUrl, AppendUrl, null, url,
|
|
"Be careful - urls from strangers may link to websites that",
|
|
" may have viruses, or things you may not want to open/see."
|
|
) );
|
|
} else if( game.ClickableChat ) {
|
|
for( int i = 0; i < text.Length; i++ ) {
|
|
if( !IsValidInputChar( text[i] ) ) {
|
|
game.Chat.Add( "&eChatline contained characters that can't be sent on this server." );
|
|
return true;
|
|
}
|
|
}
|
|
textInput.AppendText( text );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void OpenUrl( WarningScreen screen ) {
|
|
try {
|
|
Process.Start( (string)screen.Metadata );
|
|
} catch( Exception ex ) {
|
|
ErrorHandler.LogError( "ChatScreen.OpenUrl", ex );
|
|
}
|
|
}
|
|
|
|
void AppendUrl( WarningScreen screen ) {
|
|
if( !game.ClickableChat ) return;
|
|
textInput.AppendText( (string)screen.Metadata );
|
|
}
|
|
|
|
void ScrollHistory() {
|
|
int maxIndex = game.Chat.Log.Count - chatLines;
|
|
int minIndex = Math.Min( 0, maxIndex );
|
|
Utils.Clamp( ref chatIndex, minIndex, maxIndex );
|
|
ResetChat();
|
|
}
|
|
}
|
|
} |