fancy.asc

// fancy module script

// Define maximum text tokens and stack size
#define MAX_TXTTK 1024
#define MAX_LINES 16
#define MAX_TAG_NEST 6
#define MAX_FANCY_BUTTON 32

// internal
struct FancyButtonData {
  int ID;
  DynamicSprite* Normal;
  DynamicSprite* Over;
  DynamicSprite* Pushed;
};

FancyButtonData _fancybtn[MAX_FANCY_BUTTON];
int _fancybtn_count;
Dictionary* _tvdict;
FancyConfig* _default_cfg;
Fancy9Piece* _default_f9p;
Fancy9Piece* _default_default_f9p;
FancyTypedText _sayft;
DynamicSprite* _sayspr;
Overlay* _say_last_speech;
Overlay* _say_ovr_tmp;
bool _say_started;
bool _say_delay_end;
int _say_char_head_y;
bool _say_is_room_coords;

int _clamp_i(int v, int max, int min)
{
  if(v > max) return max;
  if(v < min) return min;
  return v;
}

int _get_character_height(Character* c)
{
  ViewFrame* vf = Game.GetViewFrame(c.View, c.Loop, c.Frame);
  
  if(vf == null) return 0;
  
  return ((Game.SpriteHeight[vf.Graphic] + c.z) * c.Scaling)/100;
}

int _adjust_speech_y(int y, int height) // meant to avoid occluding player head if possible
{
  y = _clamp_i(y, _clamp_i(_say_char_head_y-_sayspr.Height, Screen.Height, _sayspr.Height + 5), 0);
  return _clamp_i(_clamp_i(y + height, Screen.Height-5, 5) - height, Screen.Height-5, 5);
}

int _adjust_speech_x(int x, int width) // avoids text going outside screen
{
  return _clamp_i(_clamp_i(x + width, Screen.Width-5, 5) - width, Screen.Width-5, 5);
}

void _fancy_say_set_overlay(Overlay* curSpeech)
{
  curSpeech.Graphic = _sayspr.Graphic;
  
  int screen_x = curSpeech.X;
  int screen_y = curSpeech.Y;  
  screen_x = _adjust_speech_x(screen_x, curSpeech.Width);
  screen_y = _adjust_speech_y(screen_y, curSpeech.Height);
  
  // there's a bug in AGS we will workaround : https://github.com/adventuregamestudio/ags/issues/1180
  // The text overlay may be using room coordinates if Speech Style is lucasarts or is Sierra but the
  // but the character has no speech view! We do this check in _fancy_say function.
  int x = screen_x;
  int y = screen_y;
  if(_say_is_room_coords)
  {
    Point* p = Screen.Viewport.ScreenToRoomPoint(x, y, false);
    x = p.x;
    y = p.y;
  }
  
  curSpeech.Y = y;
  curSpeech.X = x;
}

int _get_character_top_head_y(Character* c)
{
  int y = 0;
  Point* p = Screen.Viewport.RoomToScreenPoint(c.x, c.y, false);
  if(p)
    y = p.y;
  
  y -= _get_character_height(c);
  return y;
}

int _get_btn_real_id(Button* btn)
{
  return btn.ID + btn.OwningGUI.ID * 64;
}

int _get_fancybtn_index(int id) {
  for(int i=0; i<_fancybtn_count; i++) {
    if(id == _fancybtn[i].ID) return i;
  }
  return -1;
}

int _get_new_fancybtn_index(int id) {
  int index = _get_fancybtn_index(id);
  if(index != -1) return index;
  if(_fancybtn_count >= MAX_FANCY_BUTTON) return -1; // max capacity
  index = _fancybtn_count;
  _fancybtn_count++;
  return index;
}

void _set_fancybtn(int index, int id,  DynamicSprite* normal, DynamicSprite* over, DynamicSprite* pushed)
{
  _fancybtn[index].ID = id;
  _fancybtn[index].Normal = normal;
  _fancybtn[index].Over = over;
  _fancybtn[index].Pushed = pushed;
}

void _remove_fancybtn(int id)
{
  int index = _get_fancybtn_index(id);
  if(index != -1) return; // already removed
  for(int i=index; i<_fancybtn_count-1; i++) {
    _set_fancybtn(i, _fancybtn[i+1].ID, _fancybtn[i+1].Normal, _fancybtn[i+1].Over, _fancybtn[i+1].Pushed);
  }
  _set_fancybtn(_fancybtn_count-1, -1, null, null, null);
  _fancybtn_count--;
}

#region TEXT_TOKEN_REG
managed struct TokenState {
  int color;
  int outline_color;
  FontType font;
};

enum TkType
{
  eTkText = 0,
  eTkLinebreak,
  eTkBlank, 
  eTkGraphic
};

FancyTextToken* _newLineBreakTxtToken()
{
  FancyTextToken* tk = new FancyTextToken;
  tk.type = eTkLinebreak;
  return tk;
}

FancyTextToken* _newSpriteTxtToken(int sprite)
{
  FancyTextToken* tk = new FancyTextToken;
  tk.type = eTkGraphic;
  tk.font = sprite;
  tk.width = Game.SpriteWidth[sprite];
  tk.height = Game.SpriteHeight[sprite];
  return tk;
}

FancyTextToken* _newTxtToken(String text, int text_begin, int text_length, TokenState* ts)
{
  FancyTextToken* tk = new FancyTextToken;
  tk.text_begin = text_begin;
  tk.text_length = text_length;
  tk.color = ts.color;
  tk.outline_color = ts.outline_color;
  tk.font = ts.font;
  tk.width = GetTextWidth(text, ts.font);
  tk.height = GetFontHeight(ts.font);
  return tk;
}

int _AppendTxtTok(FancyTextToken* txttk_arr[], int txttk_count, FancyTextToken* tk)
{
  int i = txttk_count;
  
  txttk_arr[i] = tk;
  txttk_count++;
  return txttk_count;
}

int _InserTxtTok(FancyTextToken* txttk_arr[], int txttk_count, FancyTextToken* tk, int index)
{
  txttk_count++;
  for(int i = txttk_count; i>index; i--)
  {
    txttk_arr[i] = txttk_arr[i-1];
  }  
  txttk_arr[index] = tk;  
  return txttk_count;  
}

FancyTextToken* [] _NewTxtTok()
{
  FancyTextToken* txttk_arr[];
  txttk_arr = new FancyTextToken [MAX_TXTTK];
  return txttk_arr;
}
#endregion // TEXT_TOKEN_REG

enum TagType
{
  eTagNone = 0,
  eTagColor,
  eTagOutlineColor, 
  eTagFont, 
  eTagSprite
};

#region STACK_OF_INT_REG
struct StackOfInt
{
  int items[MAX_TAG_NEST];
  int index;
  import void Push(int number);
  import int Pop();
};

void StackOfInt::Push(int number)
{
  this.items[this.index] = number;
  this.index++;
}

int StackOfInt::Pop()
{
  this.index--;
  return this.items[this.index];
}
#endregion // STACK_OF_INT_REG

FancyState* NewState() {
  FancyState* fs = new FancyState;
  return fs;
}

// Get the type of tag in format [>tag_type<:data]
TagType _get_tag_type(String tag)
{
  int c = tag.Chars[0];
  switch (c) {
    case 'c': return eTagColor;
    case 'o': return eTagOutlineColor;
    case 'f': return eTagFont;
    case 's': return eTagSprite;
  }
  return eTagNone;
}

// Get the data from tag in format [tag_type:>data<]
int _get_tag_data(String tag, TagType tag_type)
{
  if (tag_type == eTagNone) return 0;
  int p = tag.IndexOf(":") + 1;
  if (p == 0) return -1;
  String data = tag.Substring(p, tag.Length-p);
  if (data.Chars[0] >= '0' && data.Chars[0] <= '9') return data.AsInt;
  if (_tvdict.Contains(data)) {
    String sval = _tvdict.Get(data);
    return sval.AsInt;
  }
  return 0;
}

// Parse the input text for tags and generate text tokens
int _parse_text(FancyTextToken* txttk_arr[], String text, FancyConfig* cfg)
{
  TokenState* ts = new TokenState;
  int len = text.Length;
  ts.color = cfg.TextColor;
  ts.outline_color = cfg.OutlineColor;
  ts.font = cfg.Font;
  String token = "";
  int token_start = 0;
  int token_length = 0;
  int txttk_count = 0;
  
  StackOfInt stk_font;
  StackOfInt stk_color;
  StackOfInt stk_outcolor;

  for (int i = 0; i < len; i++) {
    int c = text.Chars[i];

    if (c == '[') {
      if (token.Length > 0) {
        txttk_count = _AppendTxtTok(txttk_arr, txttk_count, _newTxtToken(token, token_start, token_length, ts));
        token = "";
        token_start = i - token_length;
        token_length = 0;
      }

      i++;
      bool is_closing = false;
      if (i < len && text.Chars[i] == '/') {
        is_closing = true;
        i++;
      }

      int j = i;
      while (j <= len && text.Chars[j] != ']') j++;
      int delta = j - i;

      String strtag = text.Substring(i, delta);
      TagType tag = _get_tag_type(strtag);
      TagType tdata = tag;
      if (is_closing) tdata = eTagNone;
      int data = _get_tag_data(strtag, tdata);
      switch (tag) {
        case eTagColor:
          if (is_closing) {
            ts.color = stk_color.Pop();
          } else {
            stk_color.Push(ts.color);
            ts.color = data;
          }
          break;
        case eTagOutlineColor:
          if (is_closing) {
            ts.outline_color = stk_outcolor.Pop();
          } else {
            stk_outcolor.Push(ts.outline_color);
            ts.outline_color = data;
          }
          break;
        case eTagFont:
          if (is_closing) {
            ts.font = stk_font.Pop();
          } else {
            stk_font.Push(ts.font);
            ts.font = data;
          }
          break;
        // following tags have no closing elements
        case eTagSprite:
          txttk_count = _AppendTxtTok(txttk_arr, txttk_count, _newSpriteTxtToken(data));
          break;
      }

      i += delta + is_closing - 1;
      if (is_closing) {
        token_start = i;
      }
    } else if (c == ']') {
      // skip
    } else if (c == ' ' || c == '\n') {
      if (token.Length > 0) {
        txttk_count = _AppendTxtTok(txttk_arr, txttk_count, _newTxtToken(token, token_start, token_length, ts));
        token = "";
        token_start = i - token_length;
        token_length = 0;
      }
      txttk_count = _AppendTxtTok(txttk_arr, txttk_count, _newTxtToken(" ", i, 1, ts));
    } else {
      if (token.Length == 0) {
        token_start = i;
      }
      token = token.AppendChar(c);
      token_length++;
    }
  }
  if (token_length > 0) {
    txttk_count = _AppendTxtTok(txttk_arr, txttk_count, _newTxtToken(token, token_start, token_length, ts));
  }
  
  _AppendTxtTok(txttk_arr, txttk_count, null);
  return txttk_count;
}

int _do_word_wrapping(FancyTextToken* tk_arr[], int tk_count, FancyState* fs, String text)
{
  int line_height[MAX_LINES];
  int line_width[MAX_LINES];
  int line = 0;
  int w = 0;
  int width = fs.MaxTextWidth;

  for (int i = 0; i < tk_count; i++) {
    FancyTextToken* t = tk_arr[i];
    String word = "";
    if(t.type == eTkText) word = text.Substring(t.text_begin, t.text_length);
    
    bool is_wrap_linebreak = w + t.width > width;
    bool is_char_linebreak = word == "\n";
    if (word == " ") {
      t.type = eTkBlank; // Optimize for the draw step
    }

    if (is_wrap_linebreak || is_char_linebreak) {
      line++;
      w = 0;
      if (is_char_linebreak) {
        t.width = 0;
        t.type = eTkLinebreak;
      } else if (is_wrap_linebreak) {
        tk_count = _InserTxtTok(tk_arr, tk_count, _newLineBreakTxtToken(), i);
        i++; // advance i due to insertion
      }
    }
    if (t.height > line_height[line]) {
      line_height[line] = t.height;
    }
    w += t.width;
    line_width[line] = w;
  }
  line++;
    
  int max_width = 0;
  int text_height = 0;
  for (int i = 0; i < line; i++) {
    if (max_width < line_width[i]) {
      max_width = line_width[i];
    }
    text_height += line_height[i];
  }
  line = 0;
  
  fs.TextWidth = max_width;
  fs.TextHeight = text_height;
  
  for (int i = 0; i < tk_count; i++) {
    FancyTextToken* t = tk_arr[i];
    t.line_height = line_height[line];
    t.line_width = line_width[line];
    
    // System.Log(eLogInfo, "(%d) bw %d lw %d tw %d lh %d, %d : %s", i, t.text_width, t.line_width, t.width, t.line_height, t.type, text.Substring(t.text_begin, t.text_length));
    // System.Log(eLogInfo, "(%d) len %d type %d : %s", i, t.text_length, t.type, text.Substring(t.text_begin, t.text_length));
    if (t.type == eTkLinebreak) {
      line++;
      t.line_width = line_width[line];
    }
  }
  return tk_count;
}

String _get_as_plain_text(FancyTextToken* tk_arr[], int tk_count, String text)
{
  String s = "";
  
  for (int i = 0; i < tk_count; i++) {
    FancyTextToken* t = tk_arr[i];
    
    switch (t.type) {
      case eTkBlank:
        s = s.Append(" ");
        break;
      case eTkLinebreak:
        s = s.Append("\n");
        break;
      case eTkText:
        if(t.text_length > 0) {
          s = s.Append(text.Substring(t.text_begin, t.text_length));
        }
        break;
      case eTkGraphic:
        // skip
        break;
    }
  }
  return s;
}

void _adjust_state_sizes_to_config(FancyState* fs, FancyConfig* cfg)
{
  int adjust = cfg.OutlineWidth + cfg.Padding;
  fs.TextWidth += adjust*2;
  fs.TextHeight += adjust*2;
  fs.X += adjust;
  fs.Y += adjust;
}

void _draw_string_outline(this DrawingSurface*, int x, int y, FontType font, String text, int outline_color, int outline_width)
{
  this.DrawingColor = outline_color;
  for(int i = -outline_width; i <= outline_width; i++) {
    for(int j = -outline_width; j <= outline_width; j++) {
      this.DrawString(x+i, y+j, font, text);
    }
  }
}

void _draw_text(DrawingSurface* surf, int x, int y, int color, int outline_color, int outline_width, FontType font, const string text)
{
  if(outline_color != COLOR_TRANSPARENT && outline_width > 0) {
    surf._draw_string_outline(x, y, font, text, outline_color, outline_width);
  }
  
  surf.DrawingColor = color;
  surf.DrawString(x, y, font, text);
}

void _draw_sprite(DrawingSurface* surf, int x, int y, int graphic)
{
  surf.DrawImage(x, y, graphic);
}

enum VerticalAlignment {
  eVAlignTop = 1,
  eVAlignMiddle = 2,
  eVAlignBottom = 4
};

int _get_align_x(HorizontalAlignment halign, int x, FancyTextToken* t, int text_width)
{
  switch(halign) {
    case eAlignRight:  return x + text_width - t.line_width;
    case eAlignCenter: return x + text_width/2 - t.line_width/2;
    default: return x; break;
  }
}

int _get_align_y(VerticalAlignment valign, int y, FancyTextToken* t)
{
  switch(valign) {
    case eVAlignTop: return y; // do nothing
    case eVAlignMiddle: return y + t.line_height/2 - t.height/2; break;
    default: return y + t.line_height - t.height; break; // bottom by default      
  }
}

// Write text tokens on a surface
void _draw_tokens(FancyTextToken* tk_arr[], int tk_count, FancyState* fs, DrawingSurface* surf, String text, int partial, FancyConfig* cfg)
{
  if(tk_count <= 0) return;
  if(fs == null) return;
  int x = fs.X;
  int y = fs.Y;
  int r_x = x;
  int r_y = y;
  VerticalAlignment valign = ((cfg.TextAlign & eAlignHasTop) && true) * eVAlignTop + ((cfg.TextAlign & eAlignHasVerCenter ) && true) * eVAlignMiddle;
  HorizontalAlignment halign = ((cfg.TextAlign & eAlignHasRight) && true) * eAlignRight + ((cfg.TextAlign & eAlignHasHorCenter ) && true) * eAlignCenter;
  int text_width = fs.TextWidth;
  r_x = _get_align_x(halign, x, tk_arr[0], text_width);
  int tk_len;
  
  for (int i = 0; i < tk_count; i++) {
    FancyTextToken* t = tk_arr[i];
    int line_height = t.line_height;
    int draw_y = _get_align_y(valign, r_y, t);   
    
    switch (t.type) {
      case eTkLinebreak:
        r_x = _get_align_x(halign, x, t, text_width);        
        r_y += line_height;
        continue; // this will skip to next line and token
      case eTkText:
        tk_len = t.text_length;
        if(partial >= 0 && i == tk_count-1) tk_len = partial;
        _draw_text(surf, r_x, draw_y, t.color, t.outline_color, cfg.OutlineWidth, t.font, text.Substring(t.text_begin, tk_len));
        break;
      case eTkGraphic:
        _draw_sprite(surf, r_x, draw_y, t.font);
        break;
    }
    r_x += t.width;
  }
}

int _i_max3(int v1, int v2, int v3)
{
  if(v1 > v2 && v1 > v3) return v1;
  if(v2 > v1 && v2 > v3) return v2;
  return v3;
}

int _i_min3(int v1, int v2, int v3)
{
  if(v1 < v2 && v1 < v3) return v1;
  if(v2 < v1 && v2 < v3) return v2;
  return v3;
}

int _f9p_get_left_border(Fancy9Piece* f9p) { return _i_max3(f9p.TL_w, f9p.BL_w, f9p.L_w); }
int _f9p_get_right_border(Fancy9Piece* f9p) { return _i_max3(f9p.TR_w, f9p.BR_w, f9p.R_w); }
int _f9p_get_top_border(Fancy9Piece* f9p) { return _i_max3(f9p.TL_h, f9p.TR_h, f9p.T_h); }
int _f9p_get_bottom_border(Fancy9Piece* f9p) { return _i_max3(f9p.BL_h, f9p.BR_h, f9p.B_h); }

DynamicSprite* _create_textbox(int internal_width, int internal_height, Fancy9Piece* f9p)
{
  int left_border = f9p.BorderLeft;
  int right_border = f9p.BorderRight;
  int top_border = f9p.BorderTop;
  int bottom_border = f9p.BorderBottom;
  int w = left_border + internal_width + right_border;
  int h = top_border + internal_height + bottom_border;
  DynamicSprite* spr = DynamicSprite.Create(w, h, true);
  DrawingSurface* surf = spr.GetDrawingSurface();
  int bg_color = f9p.CBG_Color;
  
  if(f9p.CBG) surf.DrawImage(left_border, top_border, f9p.CBG, 0, internal_width, internal_height); //draw background
  else if(bg_color && bg_color != COLOR_TRANSPARENT) {
    surf.DrawingColor = bg_color;
    surf.DrawRectangle(left_border, top_border, left_border + internal_width, top_border + internal_height);
  }
  
  if(f9p.TL) surf.DrawImage(0, 0, f9p.TL); // Top Left Corner
  if(f9p.TR) surf.DrawImage(w - f9p.TR_w, 0, f9p.TR); // Top Right Corner
  if(f9p.BL) surf.DrawImage(0, h - f9p.BL_h, f9p.BL); // Bottom Left Corner
  if(f9p.BR) surf.DrawImage(w - f9p.BR_w, h - f9p.BR_h, f9p.BR); // Bottom Right Corner
  
  if(f9p.T) surf.DrawImage(f9p.TL_w, 0, f9p.T, 0, w - f9p.TL_w - f9p.TR_w, f9p.T_h); // Top Edge
  if(f9p.L) surf.DrawImage(0, f9p.TL_h, f9p.L, 0, f9p.L_w, h - f9p.TL_h - f9p.BL_h); // Left Edge
  if(f9p.R) surf.DrawImage(w - f9p.R_w, f9p.TR_h, f9p.R, 0, f9p.R_w, h - f9p.TR_h - f9p.BR_h); // Right Edge
  if(f9p.B) surf.DrawImage(f9p.BL_w, h - f9p.B_h, f9p.B, 0, w - f9p.BL_w - f9p.BR_w, f9p.B_h); // Bottom Edge
  return spr;
}

DynamicSprite* _create_textbox_from_textgraphic(Fancy9Piece* f9p, int internal_width, int internal_height, int text_graphic) 
{
  if(f9p == null) return null;
  
  DynamicSprite* textbox = _create_textbox(internal_width, internal_height, f9p);
  DrawingSurface* surf = textbox.GetDrawingSurface();
  surf.DrawImage(f9p.BorderLeft, f9p.BorderTop, text_graphic);
  surf.Release();
  return textbox;
}

int _get_speech_width(Character* c, int width)
{
  int portrait_added_width = 0;
  if(Speech.Style == eSpeechSierra || Speech.Style == eSpeechSierraWithBackground)
  {
    ViewFrame* vf = null;
    int speech_view = c.SpeechView;
    if(speech_view != 0) {
      vf = Game.GetViewFrame(speech_view, 0, 0);
    }
    if(vf != null) {
      portrait_added_width = Game.SpriteWidth[vf.Frame];
    }
  }
  
  portrait_added_width += 35;
  
  width = _clamp_i(width, Screen.Width - portrait_added_width, 0);
  
  return width;
}

DynamicSprite* _create_textbox_from_text_spr(DynamicSprite* text_spr, Fancy9Piece* f9p)
{
  if(f9p == null)
    return text_spr;
  return _create_textbox_from_textgraphic(f9p, text_spr.Width, text_spr.Height, text_spr.Graphic);
}

DynamicSprite* _create_text_sprite(FancyTextToken* tk_arr[], int tk_count,  FancyState* fs, String text, int typed_token_len, FancyConfig* cfg)
{
  DynamicSprite* text_spr = DynamicSprite.Create(fs.TextWidth, fs.TextHeight, true);
  DrawingSurface* surf = text_spr.GetDrawingSurface();
  _draw_tokens(tk_arr, tk_count, fs, surf, text, typed_token_len, cfg);
  surf.Release();
  return text_spr;
}

int _process_fancy_string(FancyTextToken* tk_arr[], FancyState* fs, String text, FancyConfig* config) 
{
  if(String.IsNullOrEmpty(text))
    return 0;
  int tk_count = _parse_text(tk_arr, text, config);
  tk_count = _do_word_wrapping(tk_arr, tk_count, fs, text);
  
  _adjust_state_sizes_to_config(fs, config); // fix outline and margin
  return tk_count;
}

// ----------------------------------------------------------------------
// ---------------- fancy module public interface -----------------------
// ----------------------------------------------------------------------

static FancyConfig* FancyConfig::Create(FontType font, int color, int outline_color, int outline_width, Alignment align, int line_spacing)
{
  FancyConfig* cfg = new FancyConfig;
  cfg.Font = font;
  cfg.LineSpacing = line_spacing;
  cfg.OutlineColor = outline_color;
  cfg.OutlineWidth = outline_width;
  cfg.TextAlign = align;
  cfg.TextColor = color;
  return cfg;
}

void FancyConfig::Set(FancyConfig* config) 
{
  this.Font = config.Font;
  this.LineSpacing = config.LineSpacing;
  this.OutlineColor = config.OutlineColor;
  this.OutlineWidth = config.OutlineWidth;
  this.Padding = config.Padding;
  this.TextAlign = config.TextAlign;
  this.TextColor = config.TextColor;
}

FancyConfig* FancyConfig::Clone()
{
  FancyConfig* cfg = new FancyConfig;
  cfg.Set(this);
  return cfg;
}

FancyConfig* _get_speech_config(Character* c, FancyConfig* config)
{
  if(config == null) {
    config = _default_cfg.Clone();
    config.Font = Game.SpeechFont;
    config.TextColor = c.SpeechColor;
    config.OutlineWidth = 0;
    config.OutlineColor = COLOR_TRANSPARENT;
    config.Padding = 1;
  }
  return config;  
}

static void Fancy::AddAlias(String key, int value)
{
  _tvdict.Set(key, String.Format("%d", value));
}

static FancyConfig* Fancy::get_FancyConfig()
{  
  if(_default_cfg == null) {
    _default_cfg = FancyConfig.Create();
  }
  return _default_cfg;
}

static void Fancy::set_FancyConfig(FancyConfig* value)
{
  if(value == null) {
    value = FancyConfig.Create();
  }
  if(_default_cfg == null) {
    _default_cfg = FancyConfig.Create();
  }
  _default_cfg.Set(value);
}

void Fancy9Piece::SetAll(int top, int bottom, int left, int right, int top_left, int top_right, int bottom_left, int bottom_right, int background, int bg_color)
{
  this.T = top;
  this.B = bottom;
  this.L = left;
  this.R = right;
  this.TL = top_left;
  this.TR = top_right;
  this.BL = bottom_left;
  this.BR = bottom_right;
  this.CBG = background;
  this.CBG_Color = bg_color;
  if(this.T > 0) { this.T_w = Game.SpriteWidth[this.T]; this.T_h = Game.SpriteHeight[this.T]; } else {this.T_w = 0; this.T_h = 0;}
  if(this.B > 0) { this.B_w = Game.SpriteWidth[this.B]; this.B_h = Game.SpriteHeight[this.B]; } else {this.B_w = 0; this.B_h = 0;}
  if(this.L > 0) { this.L_w = Game.SpriteWidth[this.L]; this.L_h = Game.SpriteHeight[this.L]; } else {this.L_w = 0; this.L_h = 0;}
  if(this.R > 0) { this.R_w = Game.SpriteWidth[this.R]; this.R_h = Game.SpriteHeight[this.R]; } else {this.R_w = 0; this.R_h = 0;}
  if(this.TL > 0) { this.TL_w = Game.SpriteWidth[this.TL]; this.TL_h = Game.SpriteHeight[this.TL]; } else {this.TL_w = 0; this.TL_h = 0;}
  if(this.TR > 0) { this.TR_w = Game.SpriteWidth[this.TR]; this.TR_h = Game.SpriteHeight[this.TR]; } else {this.TR_w = 0; this.TR_h = 0;}
  if(this.BL > 0) { this.BL_w = Game.SpriteWidth[this.BL]; this.BL_h = Game.SpriteHeight[this.BL]; } else {this.BL_w = 0; this.BL_h = 0;}
  if(this.BR > 0) { this.BR_w = Game.SpriteWidth[this.BR]; this.BR_h = Game.SpriteHeight[this.BR]; } else {this.BR_w = 0; this.BR_h = 0;}
  if(this.CBG > 0) { this.CBG_w = Game.SpriteWidth[this.CBG]; this.CBG_h = Game.SpriteHeight[this.CBG]; } else {this.CBG_w = 0; this.CBG_h = 0;}
  this.BorderLeft = _f9p_get_left_border(this);
  this.BorderRight = _f9p_get_right_border(this);
  this.BorderTop = _f9p_get_top_border(this);
  this.BorderBottom = _f9p_get_bottom_border(this);
}

static Fancy9Piece* Fancy9Piece::CreateFrom9Sprites(int top, int bottom, int left, int right, int top_left, int top_right, int bottom_left, int bottom_right, int background, int bg_color)
{
  Fancy9Piece* f9p = new Fancy9Piece;
  f9p.SetAll(top, bottom, left, right, top_left, top_right, bottom_left, bottom_right, background, bg_color);
  return f9p;
}

static Fancy9Piece* Fancy9Piece::CreateFromTextWindowGui(GUI* text_window_gui)
{
  TextWindowGUI* twg = null;
  if(text_window_gui != null) {
    twg = text_window_gui.AsTextWindow;
  }
  if(twg == null) {
    if(game.speech_text_gui >= 0 && Speech.Style != eSpeechLucasarts) {
      twg = gui[game.speech_text_gui].AsTextWindow;
    }
    if(twg == null)
      return null;
  }
  
  Button* btn_top_left = twg.Controls[0].AsButton;
  Button* btn_bot_left = twg.Controls[1].AsButton;
  Button* btn_top_right = twg.Controls[2].AsButton;
  Button* btn_bot_right = twg.Controls[3].AsButton;
  Button* btn_left = twg.Controls[4].AsButton;
  Button* btn_right = twg.Controls[5].AsButton;
  Button* btn_top = twg.Controls[6].AsButton;
  Button* btn_bot = twg.Controls[7].AsButton;
  int sprite_bg = twg.BackgroundGraphic;
  int bg_color = twg.BackgroundColor;
  
  return Fancy9Piece.CreateFrom9Sprites(btn_top.NormalGraphic, btn_bot.NormalGraphic, btn_left.NormalGraphic, btn_right.NormalGraphic,
         btn_top_left.NormalGraphic, btn_top_right.NormalGraphic, btn_bot_left.NormalGraphic, btn_bot_right.NormalGraphic, 
  sprite_bg, bg_color);
}

void Fancy9Piece::Set(Fancy9Piece* v) 
{
  if(v == null) v = Fancy9Piece.CreateFrom9Sprites(0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
  
  this.B = v.B; this.B_h = v.B_h; this.B_w = v.B_w;
  this.L = v.L; this.L_h = v.L_h; this.L_w = v.L_w;
  this.R = v.R; this.R_h = v.R_h; this.R_w = v.R_w;
  this.T = v.T; this.T_h = v.T_h; this.T_w = v.T_w;
  this.TL = v.TL; this.TL_h = v.TL_h; this.TL_w = v.TL_w;
  this.TR = v.TR; this.TR_h = v.TR_h; this.TR_w = v.TR_w;
  this.BL = v.BL; this.BL_h = v.BL_h; this.BL_w = v.BL_w;
  this.BR = v.BR; this.BR_h = v.BR_h; this.BR_w = v.BR_w;
  this.CBG = v.CBG; this.CBG_Color = v.CBG_Color; this.CBG_h = v.CBG_h; this.CBG_w = v.CBG_w;
  this.BorderBottom = v.BorderBottom; this.BorderLeft = v.BorderLeft; this.BorderRight = v.BorderRight; this.BorderTop = v.BorderTop;
}

Fancy9Piece* Fancy9Piece::Clone()
{
  Fancy9Piece* f9p = new Fancy9Piece;
  f9p.Set(this);
  return f9p;
}

static Fancy9Piece* Fancy::get_Fancy9Piece()
{
  return _default_f9p;
}

static void Fancy::set_Fancy9Piece(Fancy9Piece* value)
{
  if(value == null) {
    value = _default_default_f9p.Clone();
  }
  if(_default_f9p == null) {
    _default_f9p = value.Clone();
  }
  _default_f9p.Set(value);
}

void DrawFancyString(this DrawingSurface*, int x, int y, const string text, FancyConfig* config, int width)
{ 
  FancyTextToken* tk_arr[] = _NewTxtTok();
  FancyState* fs = NewState();
  if(config == null)
    config = _default_cfg.Clone();

  fs.X = x; fs.Y = y; fs.MaxTextWidth = width;
  
  int tk_count = _process_fancy_string(tk_arr, fs, text, config);
  if(tk_count <= 0) return;
  
  _draw_tokens(tk_arr, tk_count, fs, this, text, -1, config);
}

DynamicSprite* CreateFromFancyString(static DynamicSprite, const string text, FancyConfig* config, int width)
{
  FancyTextToken* tk_arr[] = _NewTxtTok();
  FancyState* fs = NewState();
  if(config == null)
    config = _default_cfg.Clone();

  fs.MaxTextWidth = width;
  
  int tk_count = _process_fancy_string(tk_arr, fs, text, config);
  if(tk_count <= 0) return null;
  
  return _create_text_sprite(tk_arr, tk_count, fs, text, -1, config);
}

DynamicSprite* CreateFromFancyTextBox(static DynamicSprite, const string text, FancyConfig* config, int width, Fancy9Piece* f9p)
{
  if(String.IsNullOrEmpty(text)) return null;
  if(config == null) config = _default_cfg.Clone();
  
  DynamicSprite* text_spr = DynamicSprite.CreateFromFancyString(text, config, width);

  return _create_textbox_from_text_spr(text_spr, f9p);
}

void Fancify(this Button*, Fancy9Piece* normal9p, Fancy9Piece* mouse_over9p, Fancy9Piece* pushed9p)
{
  if(String.IsNullOrEmpty(this.Text))
    return;
    
  DynamicSprite* spr_normal, spr_over, spr_pushed;
  int id = _get_btn_real_id(this);
  int index = _get_new_fancybtn_index(id);
  if(index < 0) AbortGame("Maximum Fancy Button capacity reached");
  
  int border_left, border_right, border_top, border_bottom;
  if(normal9p != null) {
    border_left = normal9p.BorderLeft;
    border_right = normal9p.BorderRight;
    border_top = normal9p.BorderTop;
    border_bottom = normal9p.BorderBottom;    
  }
  
  int w = this.Width - border_left - border_right;
  int h = this.Height - border_top - border_bottom;
  
  String text = this.Text;
  int color = this.TextColor;
  int font = this.Font;
  FancyConfig* config = FancyConfig.Create(font, color);
    
  DynamicSprite* text_spr = DynamicSprite.CreateFromFancyString(text, config, w);
  if(text_spr.Height > h) {
    h = text_spr.Height;
  }
  
  spr_normal = _create_textbox_from_textgraphic(normal9p, w, h, text_spr.Graphic);
  
  if(spr_normal == null) {
    spr_normal = text_spr;
  } else {
    spr_over = _create_textbox_from_textgraphic(mouse_over9p, w, h, text_spr.Graphic);
    spr_pushed = _create_textbox_from_textgraphic(pushed9p, w, h, text_spr.Graphic);
  }
  
  _set_fancybtn(index, id, spr_normal, spr_over, spr_pushed);
  
  if(spr_normal != null) this.NormalGraphic = spr_normal.Graphic;
  if(spr_over != null) this.MouseOverGraphic = spr_over.Graphic;
  if(spr_pushed!= null) this.PushedGraphic = spr_pushed.Graphic;
  
  this.Text = "";
}

void UnFancify(this Button*)
{
  int id = _get_btn_real_id(this);
  
  this.NormalGraphic = 0;
  this.MouseOverGraphic = 0;
  this.PushedGraphic = 0;
  
  _remove_fancybtn(id);
}

FancyConfig* FancyTextBase::get_FancyConfig()
{  
  if(this._cfg == null) {
    this._cfg =  _default_cfg.Clone();
  }
  return this._cfg;
}

void FancyTextBase::set_FancyConfig(FancyConfig* value)
{
  if(value == null) {
    value = _default_cfg.Clone();
  }
  if(this._cfg == null) {
    this._cfg = _default_cfg.Clone();
  }
  this._cfg.Set(value);
}

void FancyTextBase::SetDrawingArea(int x, int y, int width)
{
  if(this._fs == null)
    this._fs = NewState();
  
  this._fs.X = x;
  this._fs.Y = y;
  this._fs.MaxTextWidth = width;
}

// FIX-ME: reduce code duplication
protected void FancyTextBase::_set_text(String text)
{
  if(this._cfg == null) { this._cfg = _default_cfg.Clone(); }
  if(this._fs == null) { this._fs = NewState(); }
  if(String.IsNullOrEmpty(text)) { 
    this._text = "";
    this._tk_arr = null;
    this._tk_count = 0;
    return;
  }

  int font = this._cfg.Font;
  int color = this._cfg.TextColor;
  if(this._fs.MaxTextWidth <= 0) { this._fs.MaxTextWidth = FANCY_INFINITE_WIDTH; }
  if(this._f9p != null) {
    this._fs.MaxTextWidth -= (this._f9p.BorderLeft + this._f9p.BorderRight);
  }
  
  FancyTextToken* tk_arr[] = _NewTxtTok();
  int tk_count = _process_fancy_string(tk_arr, this._fs, text, this._cfg);
  
  this._tk_arr = tk_arr;
  this._tk_count = tk_count;
  this._text = text;
  this._is_typed_text = false;
}

void FancyTextBase::set_Text(String text)
{
  this._set_text(text);
}

String FancyTextBase::get_Text()
{
  if(String.IsNullOrEmpty(this._text))
    return "";
  return this._text;  
}

String FancyTextBase::get_PlainText()
{
  if(String.IsNullOrEmpty(this._text) || this._tk_count <= 0)
    return "";
  return _get_as_plain_text(this._tk_arr, this._tk_count, this._text);
}
  
void FancyTextBase::Draw(DrawingSurface* surf)
{  
  FancyTextToken* tk_arr[] = this._tk_arr;
  int tk_count = this._tk_count;
  String text = this._text;
  
  _draw_tokens(tk_arr, tk_count, this._fs, surf, text, -1, this._cfg);
}

Fancy9Piece* FancyTextBox::get_Fancy9Piece()
{  
  if(this._f9p == null) {
    this._f9p = _default_f9p.Clone();
  }
  return this._f9p;
}

void FancyTextBox::set_Fancy9Piece(Fancy9Piece* value)
{
  if(value == null && _default_f9p != null) {
    value = _default_f9p.Clone();
  }
  if(this._f9p == null && value != null) {
    this._f9p = value; 
    return;
  }
  if(this._f9p == null)
    this._f9p = Fancy9Piece.CreateFrom9Sprites(0, 0, 0, 0, 0, 0, 0, 0, 0, 0);

  this._f9p.Set(value);
}

DynamicSprite* FancyTextBox::CreateTextBoxSprite()
{
  if(String.IsNullOrEmpty(this._text) || this._tk_count <= 0) return null;
  if(this._cfg == null) this._cfg = _default_cfg.Clone();
  
  DynamicSprite* text_spr = _create_text_sprite(this._tk_arr, this._tk_count, this._fs, this._text, -1, this._cfg);

  return _create_textbox_from_text_spr(text_spr, this._f9p);
}

DynamicSprite* FancyTypedText::CreateTypedSprite()
{
  if(String.IsNullOrEmpty(this._text) || this._tk_count <= 0) return null;
  if(this._cfg == null) this._cfg = _default_cfg.Clone();
  
  DynamicSprite* text_spr = _create_text_sprite(this._tk_arr, this._typed_token_count, this._fs, this._text, this._typed_token_len, this._cfg);
  
  return _create_textbox_from_text_spr(text_spr, this._f9p);
}

bool get_IsTextBeingTyped(this FancyTypedText*)
{
  return !String.IsNullOrEmpty(this._text) && this._is_typed_text && !(this._typed_token_count == this._tk_count && this._typed_token_len == -1);
}

void FancyTypedText::Skip()
{  
  this._typed_token_count = this._tk_count;
  this._typed_token_len = -1;
}

void FancyTypedText::Tick()
{  
  if((this._typed_token_count >= this._tk_count && this._typed_token_len == -1) || String.IsNullOrEmpty(this._text)) return;
  
  int max_tk_len = 0;
  if(this._typed_token_count > 0) max_tk_len = this._tk_arr[this._typed_token_count-1].text_length;
    
  this._typed_token_len++;
  
  if (this._typed_token_len > max_tk_len) {
    this._typed_token_len = 0;
    this._typed_token_count++;
    
    if (this._typed_token_count > this._tk_count) {
      this._typed_token_count = this._tk_count;
      this._typed_token_len = -1;
    }
  }
}

void FancyTypedText::DrawTyped(DrawingSurface* surf)
{
  _draw_tokens(this._tk_arr, this._typed_token_count, this._fs, surf, this._text, this._typed_token_len, this._cfg);  
}

void FancyTypedText::Clear()
{
  this._text = "";
  this._tk_arr = null;
  this._tk_count = 0;
  this._typed_token_count = 0;
  this._typed_token_len = -1;
  this._is_typed_text = false;
}

void FancyTypedText::Start(String text)
{  
  this._set_text(text);
  this._typed_token_len = 0;
  this._typed_token_count = 0;
  this._is_typed_text = true;
}

void _fancy_say_setup(Character* c, FancyConfig* config, int width, Fancy9Piece* f9p)
{  
  width = _get_speech_width(c, width);
  config = _get_speech_config(c, config);  
    
  _sayft.SetDrawingArea(0, 0, width);
  _sayft.set_FancyConfig(config);
  _sayft.set_Fancy9Piece(f9p);
  _say_char_head_y = _get_character_top_head_y(c);
}

int _get_voice_txt_end_pos(String text)
{
  int len = text.Length;
  if(!(len>1 && text.Chars[0] == '&' && text.Chars[1] >= '0' && text.Chars[1] <= '9'))
  {
    return -1; // no voice line
  }
  
  int k=1;
  while(text.Chars[k] >= '0' && text.Chars[k] <= '9' && k < len) k++;
  if(k < len && text.Chars[k] == ' ') k++;
  return k;
}

void _fancy_say(bool typed, Character* c, String text, FancyConfig* config, int width, Fancy9Piece* f9p)
{
  if(String.IsNullOrEmpty(text))
    return;
    
  int voice_txt_end_pos = _get_voice_txt_end_pos(text);
  String voice_str = "";
  if(voice_txt_end_pos > 0) {
    voice_str = text.Substring(0, voice_txt_end_pos);
    text = text.Substring(voice_txt_end_pos, text.Length - voice_txt_end_pos);
  }

  _fancy_say_setup(c, config, width, f9p);
  _sayft.Clear();
  if(typed) {
    _sayft.Start(text);
  } else {
    _sayft.set_Text(text);
  }
  _say_is_room_coords = Speech.Style == eSpeechLucasarts || c.SpeechView == 0;
  
  String plain_text = _sayft.get_PlainText();
  String plain_text_with_voice = voice_str.Append(plain_text);
    
  c.Say(plain_text_with_voice.Append(" o o o"));
  if(typed && _sayft.get_IsTextBeingTyped()) {
    _sayft.Skip();
    c.Say(plain_text.Append(" o o o"));
  }
  _sayft.set_Text(null);  
}

void FancySay(this Character*, const string text, FancyConfig* config, int width, Fancy9Piece* f9p)
{
  _fancy_say(false, this, text, config, width, f9p);
}

void FancySayTyped(this Character*, const string text, FancyConfig* config, int width, Fancy9Piece* f9p)
{
  _fancy_say(true, this, text, config, width, f9p);
}

void _fancy_say_update()
{
  Overlay* curSpeech = Speech.TextOverlay;

  // Hack to avoid blink when skipping typed text
  if (_say_delay_end)
  {
    if (_say_ovr_tmp) 
      _say_ovr_tmp.Remove();
    _say_ovr_tmp = null;
    _say_delay_end = false;
  }

  bool is_fancy_say = !String.IsNullOrEmpty(_sayft.get_Text());
  
  bool speech_started = _say_last_speech == null && curSpeech != null;
  bool speech_ended = _say_last_speech != null && curSpeech == null;
  bool speech_changed = _say_last_speech != null && curSpeech != null && curSpeech != _say_last_speech;
  _say_last_speech = curSpeech;

  if (speech_ended)
  {
    _say_started = false;
    _say_delay_end = true; // To avoid blinking, we will show _say_ovr_tmp and remove it on the next frame
    if (_say_ovr_tmp) 
      _say_ovr_tmp.Transparency = 0;
    return;
  }

  if (curSpeech == null)  
    return; // no speech to display, exit

  if (is_fancy_say && (speech_started || speech_changed))
  {
    if (_sayft._is_typed_text)
    {
      _sayspr = _sayft.CreateTypedSprite();
      _fancy_say_set_overlay(curSpeech);
    }
    else 
    {
      _sayspr = _sayft.CreateTextBoxSprite();
      _fancy_say_set_overlay(curSpeech);
    }
  }

  if (is_fancy_say && _sayft._is_typed_text)
  {
    _sayft.Tick();
  }

  if (_sayft.get_IsTextBeingTyped())
  {
    _sayspr = _sayft.CreateTypedSprite();
    _fancy_say_set_overlay(curSpeech);
    if (_say_ovr_tmp) 
      _say_ovr_tmp.Remove();
    _say_ovr_tmp = Overlay.CreateGraphical(curSpeech.X, curSpeech.Y, _sayspr.Graphic); // Hack to avoid blink when skipping typed text
    _say_ovr_tmp.Transparency = 100;
  }
}

void game_start()
{
  _tvdict = Dictionary.Create(eSorted, eCaseInsensitive);
  _default_cfg = FancyConfig.Create();
  _default_f9p = Fancy9Piece.CreateFromTextWindowGui(null);
  _default_default_f9p = Fancy9Piece.CreateFromTextWindowGui(null);
}

function late_repeatedly_execute_always() {
  _fancy_say_update();
}