(*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2004-2015 Andrey Korotaev <unC0Rr@gmail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; version 2 of the License

 *

 * 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 *)

{$INCLUDE "options.inc"}

unit uChat;

interface

uses SDLh;

procedure initModule;

procedure freeModule;

procedure ReloadLines;

procedure CleanupInput;

procedure AddChatString(s: shortstring);

procedure DrawChat;

procedure KeyPressChat(keysym: TSDL_Keysym);

procedure SendHogSpeech(s: shortstring);

procedure CopyToClipboard(var newContent: shortstring);

procedure TextInput(var event: TSDL_TextInputEvent);

implementation

uses uConsts, uInputHandler, uTypes, uVariables, uCommands, uUtils, uTextures, uRender, uIO, uScript, uRenderUtils, uStore, Math;

const MaxStrIndex = 27;

      MaxInputStrLen = 200;

type TChatLine = record

    Tex: PTexture;

    Time: Longword;

    Width: LongInt;

    s: shortstring;

    Color: TSDL_Color;

    end;

    TChatCmd = (ccQuit, ccPause, ccShowHistory, ccFullScreen);

var Strs: array[0 .. MaxStrIndex] of TChatLine;

    MStrs: array[0 .. MaxStrIndex] of shortstring;

    LocalStrs: array[0 .. MaxStrIndex] of shortstring;

    missedCount: LongWord;

    lastStr: LongWord;

    localLastStr: LongInt;

    history: LongInt;

    visibleCount: LongWord;

    InputStr: TChatLine;

    ChatReady: boolean;

    showAll: boolean;

    liveLua: boolean;

    ChatHidden: boolean;

    firstDraw: boolean;

    InputLinePrefix: TChatLine;

    // cursor

    cursorPos, cursorX, selectedPos, selectionDx: LongInt;

    LastKeyPressTick: LongWord;

const

    colors: array[#0..#9] of TSDL_Color = (

            (r:$FF; g:$FF; b:$FF; a:$FF), // #0 unused, feel free to take it for anything

            (r:$FF; g:$FF; b:$FF; a:$FF), // #1 chat message [White]

            (r:$FF; g:$00; b:$FF; a:$FF), // #2 action message [Purple]

            (r:$90; g:$FF; b:$90; a:$FF), // #3 join/leave message [Lime]

            (r:$FF; g:$FF; b:$A0; a:$FF), // #4 team message [Light Yellow]

            (r:$FF; g:$00; b:$00; a:$FF), // #5 error messages [Red]

            (r:$00; g:$FF; b:$FF; a:$FF), // #6 input line [Light Blue]

            (r:$FF; g:$80; b:$80; a:$FF), // #7 team gone [Light Red]

            (r:$FF; g:$D0; b:$80; a:$FF), // #8 team back [Light Orange]

            (r:$DF; g:$DF; b:$DF; a:$FF)  // #9 hog speech [Light Gray]

            );

    ChatCommandz: array [TChatCmd] of record

            ChatCmd: string[31];

            ProcedureCallChatCmd: string[31];

            end = (

            (ChatCmd: '/quit'; ProcedureCallChatCmd: 'halt'),

            (ChatCmd: '/pause'; ProcedureCallChatCmd: 'pause'),

            (ChatCmd: '/history'; ProcedureCallChatCmd: 'history'),

            (ChatCmd: '/fullscreen'; ProcedureCallChatCmd: 'fullscr')

            );

const PaddingFactor = (1/6); // relative to font size

var Padding, ClHeight: integer;

    LastChatScaleValue, LastUIScaleValue: real;

    SkipNextInput: boolean;

procedure UpdateInputLinePrefix(); forward;

procedure UpdateCursorCoords(); forward;

// relevant for UTF-8 handling

function IsFirstCharByte(c: char): boolean; inline;

begin

    // based on https://en.wikipedia.org/wiki/UTF-8#Description

    IsFirstCharByte:= (byte(c) and $C0) <> $80;

end;

function charIsForHogSpeech(c: char): boolean;

begin

exit((c = '"') or (c = '''') or (c = '-'));

end;

procedure ResetSelection();

begin

    selectedPos:= -1;

end;

procedure AdjustToUIScale();

var fntSize: integer;

begin

    // don't do anything if no change

    if (ChatScaleValue = LastChatScaleValue) and (UIScaleValue = LastUIScaleValue) then

        exit;

    LastChatScaleValue:= ChatScaleValue;

    LastUIScaleValue:= UIScaleValue;

    // determine font size - note: +0.1 to because I don't trust float inaccuracy combined with floor

    fntSize:= max(1, floor(UIScaleValue * ChatScaleValue * Fontz[fnt16].Height + 0.1));

    if Fontz[fntChat].Height <> fntSize then

        begin

        // adjust associated heights

        Fontz[fntChat].Height:= fntSize;

        Fontz[CJKfntChat].Height:= fntSize;

        // reload if initialized already

        if Fontz[fntChat].Handle <> nil then

            LoadFont(fntChat);

        if Fontz[CJKfntChat].Handle <> nil then

            LoadFont(CJKfntChat);

        end;

    // adjust line height etc.

    Padding:= max(1, floor(PaddingFactor * fntSize + 0.1));

    ClHeight:= 2 * Padding + fntSize;

    // clear cache of already rendered lines

    ReloadLines();

    UpdateInputLinePrefix();

    UpdateCursorCoords();

end;

procedure ChatSizeInc();

begin

// TODO cChatMinScaleLevel, cChatSizeDelta (probably half of cZoomDelta)

// TODO always - effectively -- increase font by 1px?

if ChatScaleValue < cMinZoomLevel then

    begin

    ChatScaleValue:= ChatScaleValue + cZoomDelta;

    AdjustToUIScale();

    end;

end;

procedure ChatSizeDec();

begin

// TODO cChatMaxScaleLevel, cChatSizeDelta (probably half of cZoomDelta)

// TODO always - effectively -- increase font by 1px?

if ChatScaleValue > cMaxZoomLevel then

    begin

    ChatScaleValue:= ChatScaleValue - cZoomDelta;

    AdjustToUIScale();

    end;

end;

procedure chatSizeReset();

begin

ChatScaleValue:= cDefaultChatScaleLevel;

AdjustToUIScale();

end;

function GetChatFont(str: shortstring): THWFONT;

begin

    GetChatFont:= CheckCJKFont(ansistring(str), fntChat);

end;

procedure UpdateCursorCoords();

var font: THWFont;

    str : shortstring;

    coff, soff: LongInt;

begin

    AdjustToUIScale();

    if cursorPos = selectedPos then

        ResetSelection();

    // calculate cursor offset

    str:= InputStr.s;

    font:= GetChatFont(str);

    // get only substring before cursor to determine length

    // SetLength(str, cursorPos); // makes pas2c unhappy

    str[0]:= char(cursorPos);

    // get render size of text

    TTF_SizeUTF8(Fontz[font].Handle, Str2PChar(str), @coff, nil);

    cursorX:= Padding + coff;

    // calculate selection width on screen

    if selectedPos >= 0 then

        begin

        if selectedPos > cursorPos then

            str:= InputStr.s;

        // SetLength(str, selectedPos); // makes pas2c unhappy

        str[0]:= char(selectedPos);

        TTF_SizeUTF8(Fontz[font].Handle, Str2PChar(str), @soff, nil);

        selectionDx:= soff - coff;

        end

    else

        selectionDx:= 0;

end;

procedure ResetCursor();

begin

    ResetSelection();

    cursorPos:= 0;

    UpdateCursorCoords();

end;

(* This procedure [re]renders a texture showing str for the chat line cl.

 * It will use the color stored in cl and update width

 *)

procedure RenderChatLineTex(var cl: TChatLine; var str: shortstring);

var strSurface, tmpSurface,

    resSurface: PSDL_Surface;

    dstrect   : TSDL_Rect; // destination rectangle for blitting

    font      : THWFont;

const

    shadowint  = $80 shl AShift;

begin

FreeAndNilTexture(cl.Tex);

font:= GetChatFont(str);

// get render size of text

TTF_SizeUTF8(Fontz[font].Handle, Str2PChar(str), @cl.Width, nil);

// calculate and save size

cl.Width := cl.Width  + 2 * Padding;

// create surface to draw on

resSurface:= SDL_CreateRGBSurface(

                0, toPowerOf2(cl.Width), toPowerOf2(ClHeight),

                32, RMask, GMask, BMask, AMask);

// define area we want to draw in

dstrect.x:= 0;

dstrect.y:= 0;

dstrect.w:= cl.Width;

dstrect.h:= ClHeight;

// draw background

SDL_FillRect(resSurface, @dstrect, shadowint);

// create and blit text

tmpSurface:= nil;

strSurface:= TTF_RenderUTF8_Blended(Fontz[font].Handle, Str2PChar(str), cl.color);

// fix format

if strSurface <> nil then tmpSurface:= SDL_ConvertSurface(strSurface, resSurface^.format, 0);

SDL_FreeSurface(strSurface);

//SDL_UpperBlit(strSurface, nil, resSurface, @dstrect);

if tmpSurface <> nil then copyToXY(tmpSurface, resSurface, Padding, 2);

SDL_FreeSurface(tmpSurface);

cl.Tex:= Surface2Tex(resSurface, false);

SDL_FreeSurface(resSurface)

end;

const ClDisplayDuration = 12500;

procedure SetLine(var cl: TChatLine; str: shortstring; isInput: boolean);

var color  : TSDL_Color;

begin

if isInput then

    begin

    cl.s:= str;

    color:= colors[#6];

    str:= str + ' ';

    end

else

    begin

    if str[1] <= High(colors) then

        begin

        color:= colors[str[1]];

        delete(str, 1, 1);

        end

    // fallback if invalid color

    else

        color:= colors[Low(colors)];

    cl.s:= str;

    end;

cl.color:= color;

// set texture, note: variables cl.s and str will be different here if isInput

RenderChatLineTex(cl, str);

cl.Time:= RealTicks + ClDisplayDuration;

end;

// For uStore texture recreation

procedure ReloadLines;

var i: LongWord;

begin

    // also reload empty input line (as chat size/scaling might have changed)

    for i:= 0 to MaxStrIndex do

        if Strs[i].s <> '' then

            begin

            RenderChatLineTex(Strs[i], Strs[i].s);

            end;

end;

procedure AddChatString(s: shortstring);

begin

if not ChatReady then

    begin

    if MissedCount < MaxStrIndex - 1 then

        MStrs[MissedCount]:= s

    else if MissedCount < MaxStrIndex then

        MStrs[MissedCount]:= #5 + '[...]';

    inc(MissedCount);

    exit

    end;

lastStr:= (lastStr + 1) mod (MaxStrIndex + 1);

SetLine(Strs[lastStr], s, false);

inc(visibleCount)

end;

procedure UpdateInputLinePrefix();

begin

if liveLua then

    begin

    InputLinePrefix.color:= colors[#1];

    InputLinePrefix.s:= '[Lua] >';

    end

else

    begin

    InputLinePrefix.color:= colors[#6];

    InputLinePrefix.s:= UserNick + '>';

    end;

FreeAndNilTexture(InputLinePrefix.Tex);

end;

procedure DrawChat;

var i, t, left, top, cnt: LongInt;

    selRect: TSDL_Rect;

    c: char;

begin

AdjustToUIScale();

ChatReady:= true; // maybe move to somewhere else?

if ChatHidden and (not showAll) then

    visibleCount:= 0;

// draw chat lines with some distance from screen border

left:= 4 - cScreenWidth div 2;

top := 10 + visibleCount * ClHeight; // we start with input line (if any)

// draw chat input line first and under all other lines

if isInChatMode and (InputStr.Tex <> nil) then

    begin

    if InputLinePrefix.Tex = nil then

        RenderChatLineTex(InputLinePrefix, InputLinePrefix.s);

    DrawTexture(left, top, InputLinePrefix.Tex);

    inc(left, InputLinePrefix.Width);

    DrawTexture(left, top, InputStr.Tex);

    if firstDraw then

        begin

        UpdateCursorCoords();

        firstDraw:= false;

        end;

    if selectedPos < 0 then

        begin

        // draw cursor

        if ((RealTicks - LastKeyPressTick) and 512) < 256 then

            DrawLineOnScreen(left + cursorX, top + Padding, left + cursorX, top + ClHeight - Padding, 2.0, $00, $FF, $FF, $FF);

        end

    else // draw selection

        begin

        selRect.y:= top + Padding;

        selRect.h:= clHeight - 2 * Padding;

        if selectionDx < 0 then

            begin

            selRect.x:= left + cursorX + selectionDx;

            selRect.w:= -selectionDx;

            end

        else

            begin

            selRect.x:= left + cursorX;

            selRect.w:= selectionDx;

            end;

        DrawRect(selRect, $FF, $FF, $FF, $40, true);

        end;

    dec(left, InputLinePrefix.Width);

    if (Length(InputStr.s) > 0) and ((CursorPos = 1) or (CursorPos = 2)) then

        begin

        c:= InputStr.s[1];

        if charIsForHogSpeech(c) then

            begin

            SpeechHogNumber:= 0;

            if Length(InputStr.s) > 1 then

                begin

                c:= InputStr.s[2];

                if (c > '0') and (c < '9') then

                    SpeechHogNumber:= byte(c) - 48;

                end;

            // default to current hedgehog (if own) or first hedgehog

            if SpeechHogNumber = 0 then

                begin

                if not CurrentTeam^.ExtDriven then

                    SpeechHogNumber:= CurrentTeam^.CurrHedgehog + 1

                else

                    SpeechHogNumber:= 1;

                end;

            end;

        end

    else

        SpeechHogNumber:= -1;

    end

else

    SpeechHogNumber:= -1;

// draw chat lines

if ((not ChatHidden) or showAll) and (UIDisplay <> uiNone) then

    begin

    if MissedCount <> 0 then // there are chat strings we missed, so print them now

        begin

        for i:= 0 to MissedCount - 1 do

            AddChatString(MStrs[i]);

        MissedCount:= 0;

        end;

    i:= lastStr;

    cnt:= 0; // count of lines displayed

    t  := 1; // # of current line processed

    // draw lines in reverse order

    while (((t < 7) and (Strs[i].Time > RealTicks)) or ((t <= MaxStrIndex + 1) and showAll))

    and (Strs[i].Tex <> nil) do

        begin

        top:= top - ClHeight;

        // draw chatline only if not offscreen

        if top > 0 then

            DrawTexture(left, top, Strs[i].Tex);

        if i = 0 then

            i:= MaxStrIndex

        else

            dec(i);

        inc(cnt);

        inc(t)