Paragraph with large font and alignment
// New paragraph with alignment
//
New line
// ![]()
Displays a texture as an image
// Sets font color and size
// Sets font size
// Sets boldfaced font
//
// All other tags are skipped and ignored, so this parser should in theory be
// able to take any existing web page. I don't make any claims about how that
// will look, though.
// ============================================================================
simulated function ScreenSlidePageItem Render(ScriptedTexture TextureCanvas, string Text, int Width, out int Height) {
local ScreenSlidePageItem ItemFirst;
local ScreenSlidePageItem ItemLast;
local ScreenSlidePageItem ItemNew;
local ScreenSlidePageItem ItemCurrent;
local ScreenSlidePageItem ItemLinestart;
local EnumTextAlign AlignPrev;
local StructTextFormat Format[32];
local Texture ImageNew;
local int CountItems;
local int IndexFormat;
local int IndexFormatCurrent;
local int IndexChar;
local int IndexCharStart;
local int IndexCharSeparator;
local int IndexParameter;
local int HeightLine;
local int HeightPadding;
local int WidthLine;
local int WidthIndent;
local int WidthMax;
local int LengthText;
local int PositionLeft;
local int PositionTop;
local int ValueParameter;
local string CharPrev;
local string CharCurrent;
local string TagText;
local string TagName;
local string TagArguments;
local string TextArgument;
local string TextParameters;
local string TextChunk;
local string TextNormalized;
local string TextPackage;
local bool FlagLinebreakDone;
local bool FlagLinebreakBefore;
local bool FlagLinebreakAfter;
local bool FlagTruncate;
local bool FlagTrim;
local bool FlagWhitespace;
local bool FlagWhitespacePrev;
// ================================================================
// Initialization
// ================================================================
Format[0].Tag = "";
Format[0].FontText = FontNormal;
Format[0].ColorText = FontNormalColor;
Format[0].AlignText = TextAlign_Left;
TextPackage = Level.GetLocalURL();
TextPackage = Left(TextPackage, InStr(TextPackage $ "?", "?"));
TextPackage = Mid (TextPackage, InStr(TextPackage, "/") + 1);
// ================================================================
// Normalize
// ================================================================
IndexCharStart = 0;
FlagWhitespace = true;
for (IndexChar = 0; IndexChar < Len(Text); IndexChar++) {
CharCurrent = Mid(Text, IndexChar, 1);
FlagWhitespacePrev = FlagWhitespace;
FlagWhitespace = (CharCurrent == Chr(10) || CharCurrent == Chr(13) || CharCurrent == " ");
if (FlagWhitespace && !FlagWhitespacePrev)
TextNormalized = TextNormalized $ Mid(Text, IndexCharStart, IndexChar - IndexCharStart) $ " ";
else if (!FlagWhitespace && FlagWhitespacePrev)
IndexCharStart = IndexChar;
}
if (!FlagWhitespace)
TextNormalized = TextNormalized $ Mid(Text, IndexCharStart);
Text = TextNormalized;
// ================================================================
// Tokenize and Interpret
// ================================================================
CountItems = 0;
FlagTrim = true;
FlagLinebreakDone = false;
FlagLinebreakBefore = false;
while (Len(Text) > 0 || !FlagLinebreakDone) {
ItemNew = None;
FlagLinebreakAfter = false;
// ====================================================
// Tag
// ====================================================
AlignPrev = Format[IndexFormatCurrent].AlignText;
if (Left(Text, 1) == "<") {
IndexChar = InStr(Text, ">");
if (IndexChar < 0) break;
TagText = Mid(Text, 1, IndexChar - 1);
Text = Mid(Text, IndexChar + 1);
IndexChar = InStr(TagText $ " ", " ");
TagName = Caps(Left(TagText, IndexChar));
TagArguments = Mid(TagText, IndexChar + 1);
if (Left(TagName, 1) == "/") {
TagName = Mid(TagName, 1);
switch (TagName) {
case "BODY":
FlagTrim = true;
FlagLinebreakBefore = true;
break;
case "H1":
case "H2":
case "H3":
case "H4":
case "H5":
case "H6":
case "P":
FlagTrim = true;
FlagLinebreakBefore = true;
HeightPadding = Max(HeightPadding, TextHeight(TextureCanvas, "X", Format[IndexFormatCurrent].FontText));
break;
case "FONT":
case "BIG":
case "SMALL":
case "B":
case "U":
FlagTrim = false;
break;
}
for (IndexFormat = IndexFormatCurrent; IndexFormat > 0; IndexFormat--)
if (Format[IndexFormat].Tag == TagName) {
IndexFormatCurrent = IndexFormat - 1;
break;
}
}
else {
switch (TagName) {
case "BODY":
IndexFormatCurrent = 0;
Format[0].Tag = TagName;
Format[0].FontText = FontNormal;
Format[0].ColorText = ArgumentColor(Argument(TagArguments, "text"), FontNormalColor);
Format[0].AlignText = TextAlign_Left;
Format[0].FlagUnderline = false;
FlagTrim = true;
FlagLinebreakBefore = true;
break;
case "H1":
case "H2":
case "H3":
case "H4":
case "H5":
case "H6":
IndexFormatCurrent++;
Format[IndexFormatCurrent] = Format[IndexFormatCurrent - 1];
Format[IndexFormatCurrent].Tag = TagName;
Format[IndexFormatCurrent].FontText = FontHeading;
Format[IndexFormatCurrent].ColorText = FontHeadingColor;
Format[IndexFormatCurrent].AlignText = ArgumentAlign(Argument(TagArguments, "align"), TextAlign_Left);
FlagTrim = true;
FlagLinebreakBefore = true;
if (ItemFirst != None)
HeightPadding = Max(HeightPadding, TextHeight(TextureCanvas, "X", Format[IndexFormatCurrent].FontText));
break;
case "P":
for (IndexFormat = IndexFormatCurrent; IndexFormat > 0; IndexFormat--)
if (Format[IndexFormat].Tag == "P") {
IndexFormatCurrent = IndexFormat - 1;
break;
}
FlagTrim = true;
FlagLinebreakBefore = true;
if (ItemFirst != None)
HeightPadding = Max(HeightPadding, TextHeight(TextureCanvas, "X", Format[IndexFormatCurrent].FontText));
IndexFormatCurrent++;
Format[IndexFormatCurrent] = Format[0];
Format[IndexFormatCurrent].Tag = TagName;
Format[IndexFormatCurrent].AlignText = ArgumentAlign(Argument(TagArguments, "align"), TextAlign_Left);
break;
case "BR":
if (PositionLeft == 0)
HeightPadding += TextHeight(TextureCanvas, "X", Format[IndexFormatCurrent].FontText);
FlagTrim = true;
FlagLinebreakBefore = true;
break;
case "IMG":
TextArgument = Argument(TagArguments, "src");
IndexCharSeparator = InStr(TextArgument, "?");
if (IndexCharSeparator < 0)
IndexCharSeparator = Len(TextArgument);
TextParameters = Mid (TextArgument, IndexCharSeparator + 1);
TextArgument = Left(TextArgument, IndexCharSeparator);
if (Caps(Left(TextArgument, 8)) == "MYLEVEL.")
TextArgument = TextPackage $ "." $ Mid(TextArgument, 8);
ImageNew = Texture(DynamicLoadObject(TextArgument, class 'Texture'));
if (ImageNew != None) {
ItemNew = new class 'ScreenSlidePageItemImage';
ScreenSlidePageItemImage(ItemNew).Image = ImageNew;
ScreenSlidePageItemImage(ItemNew).ClipTop = 0;
ScreenSlidePageItemImage(ItemNew).ClipLeft = 0;
ScreenSlidePageItemImage(ItemNew).ClipWidth = ImageNew.USize;
ScreenSlidePageItemImage(ItemNew).ClipHeight = ImageNew.VSize;
for (IndexParameter = 0; IndexParameter < 4; IndexParameter++) {
IndexCharSeparator = InStr(TextParameters, ",");
if (IndexCharSeparator < 0)
IndexCharSeparator = Len(TextParameters);
if (IndexCharSeparator == 0)
continue;
ValueParameter = int(Left(TextParameters, IndexCharSeparator));
switch (IndexParameter) {
case 0: ScreenSlidePageItemImage(ItemNew).ClipWidth = ValueParameter; break;
case 1: ScreenSlidePageItemImage(ItemNew).ClipHeight = ValueParameter; break;
case 2: ScreenSlidePageItemImage(ItemNew).ClipLeft = ValueParameter; break;
case 3: ScreenSlidePageItemImage(ItemNew).ClipTop = ValueParameter; break;
}
TextParameters = Mid(TextParameters, IndexCharSeparator + 1);
if (Len(TextParameters) == 0)
break;
}
ItemNew.Width = ArgumentNumber(Argument(TagArguments, "width"), ScreenSlidePageItemImage(ItemNew).ClipWidth);
ItemNew.Height = ArgumentNumber(Argument(TagArguments, "height"), ScreenSlidePageItemImage(ItemNew).ClipHeight);
if (PositionLeft + ItemNew.Width >= Width)
FlagLinebreakBefore = true;
ItemNew.Top = -ItemNew.Height;
}
break;
case "FONT":
FlagTrim = true;
IndexFormatCurrent++;
Format[IndexFormatCurrent] = Format[IndexFormatCurrent - 1];
Format[IndexFormatCurrent].Tag = TagName;
Format[IndexFormatCurrent].FontText = ArgumentFont (Argument(TagArguments, "size"), Format[IndexFormatCurrent - 1].FontText);
Format[IndexFormatCurrent].ColorText = ArgumentColor(Argument(TagArguments, "color"), Format[IndexFormatCurrent - 1].ColorText);
break;
case "BIG":
FlagTrim = true;
IndexFormatCurrent++;
Format[IndexFormatCurrent] = Format[IndexFormatCurrent - 1];
Format[IndexFormatCurrent].Tag = TagName;
Format[IndexFormatCurrent].FontText = FontBig;
break;
case "SMALL":
FlagTrim = true;
IndexFormatCurrent++;
Format[IndexFormatCurrent] = Format[IndexFormatCurrent - 1];
Format[IndexFormatCurrent].Tag = TagName;
Format[IndexFormatCurrent].FontText = FontNormal;
break;
case "B":
FlagTrim = true;
IndexFormatCurrent++;
Format[IndexFormatCurrent] = Format[IndexFormatCurrent - 1];
Format[IndexFormatCurrent].Tag = TagName;
switch (Format[IndexFormatCurrent - 1].FontText) {
case FontNormal: Format[IndexFormatCurrent].FontText = FontNormalBold; break;
case FontBig: Format[IndexFormatCurrent].FontText = FontBigBold; break;
}
break;
case "U":
FlagTrim = true;
IndexFormatCurrent++;
Format[IndexFormatCurrent] = Format[IndexFormatCurrent - 1];
Format[IndexFormatCurrent].Tag = TagName;
Format[IndexFormatCurrent].FlagUnderline = true;
break;
}
}
}
// ====================================================
// Text
// ====================================================
else if (Len(Text) > 0) {
if (FlagTrim)
while (Left(Text, 1) == " ")
Text = Mid(Text, 1);
FlagTrim = false;
IndexChar = InStr(Text, "<");
if (IndexChar < 0)
IndexChar = Len(Text);
TextChunk = Left(Text, IndexChar);
if (TextCaps)
TextChunk = Caps(TextChunk);
if (Len(TextChunk) > 0) {
ItemNew = new class 'ScreenSlidePageItemText';
FlagTruncate = (PositionLeft == 0);
while (true) {
if (FlagLinebreakBefore)
while (Left(TextChunk, 1) == " ")
TextChunk = Mid(TextChunk, 1);
ItemNew.Width = Width - PositionLeft;
ScreenSlidePageItemText(ItemNew).Text =
Wrap(TextureCanvas, TextChunk, ItemNew.Width, Format[IndexFormatCurrent].FontText, FlagTruncate, WidthMax);
ScreenSlidePageItemText(ItemNew).FontText = Format[IndexFormatCurrent].FontText;
ScreenSlidePageItemText(ItemNew).ColorText = Format[IndexFormatCurrent].ColorText;
ScreenSlidePageItemText(ItemNew).FlagUnderline = Format[IndexFormatCurrent].FlagUnderline;
if (FlagTruncate || ItemNew.Width > 0) break;
FlagTruncate = true;
PositionLeft = 0;
FlagLinebreakBefore = true;
}
FlagLinebreakAfter = (WidthMax >= Width - PositionLeft);
ItemNew.Height = TextHeight(TextureCanvas, "X", Format[IndexFormatCurrent].FontText);
ItemNew.Top = -ItemNew.Height;
Text = Mid(Text, IndexChar - Len(TextChunk));
}
}
// ====================================================
// Place New Item
// ====================================================
if (FlagLinebreakBefore && !FlagLinebreakDone) {
if (ItemLast != None && ItemLast.IsA('ScreenSlidePageItemText')) {
for (LengthText = Len(ScreenSlidePageItemText(ItemLast).Text); LengthText > 0; LengthText--)
if (Mid(ScreenSlidePageItemText(ItemLast).Text, LengthText - 1, 1) != " ")
break;
WidthLine -= ItemLast.Width - TextWidth(TextureCanvas,
Left(ScreenSlidePageItemText(ItemLast).Text, LengthText), ScreenSlidePageItemText(ItemLast).FontText);
}
switch (AlignPrev) {
case TextAlign_Left: WidthIndent = 0; break;
case TextAlign_Center: WidthIndent = (Width - WidthLine) / 2; break;
case TextAlign_Right: WidthIndent = Width - WidthLine; break;
}
for (ItemCurrent = ItemLinestart; ItemCurrent != None; ItemCurrent = ItemCurrent.ItemNext) {
ItemCurrent.Top += PositionTop + HeightLine;
ItemCurrent.Left += WidthIndent;
ItemCurrent.Prepare(TextureCanvas);
}
PositionLeft = 0;
PositionTop += HeightLine;
HeightLine = 0;
WidthLine = 0;
FlagLinebreakDone = true;
}
if (ItemNew != None) {
CountItems++;
if (FlagLinebreakBefore) {
PositionTop += HeightPadding;
HeightPadding = 0;
ItemLinestart = ItemNew;
}
ItemNew.Left = PositionLeft;
ItemNew.ColorBase = BackgroundColor;
WidthLine += ItemNew.Width;
PositionLeft += ItemNew.Width;
HeightLine = Max(HeightLine, -ItemNew.Top);
if (ItemLast == None)
ItemFirst = ItemNew;
else
ItemLast.ItemNext = ItemNew;
if (ItemLinestart == None)
ItemLinestart = ItemNew;
ItemLast = ItemNew;
FlagLinebreakDone = false;
FlagLinebreakBefore = FlagLinebreakAfter;
}
if (Len(Text) == 0 && !FlagLinebreakDone) {
FlagLinebreakBefore = true;
FlagLinebreakDone = false;
}
}
Log("Rendered slide" @ Name $ "," @ CountItems @ "items");
Height = PositionTop + HeightLine;
return ItemFirst;
}
// ============================================================================
// InStrFrom
//
// Same as the built-in InStr function, except for the addition of a parameter
// that specifies the start position of the search. Should, actually, be
// readily available in any decent scripting language.
// ============================================================================
simulated function int InStrFrom(int Start, string Haystack, string Needle) {
local int IndexChar;
IndexChar = InStr(Mid(Haystack, Start), Needle);
if (IndexChar < 0)
return IndexChar;
return IndexChar + Start;
}
// ============================================================================
// Wrap
//
// Calculates and returns the substring of characters in the given string that
// fits into the given width, wrapping only at whitespace characters. Removes
// the substring and all trailing whitespace from the Text argument and returns
// the wrapped text chunk's actual width in the Width argument.
// ============================================================================
simulated function string Wrap(ScriptedTexture TextureCanvas, out string Text, out int Width, Font FontText,
bool Truncate, out int WidthMax) {
local string CharPrev;
local string CharCurrent;
local int LengthWrap;
local int LengthCurrent;
local int WidthWrap;
local int WidthCurrent;
local string TextCurrent;
local string TextResult;
TextCurrent = Text;
for (LengthCurrent = 1; LengthCurrent <= Len(Text); LengthCurrent++) {
CharPrev = CharCurrent;
CharCurrent = Mid(Text, LengthCurrent, 1);
TextCurrent = Entity(TextCurrent, LengthCurrent - 1);
WidthCurrent = TextWidth(TextureCanvas, Left(TextCurrent, LengthCurrent), FontText);
if (WidthCurrent > Width && (!Truncate || LengthWrap > 0))
break;
if ((CharCurrent == " " && CharPrev != " ") || LengthCurrent == Len(Text)) {
LengthWrap = LengthCurrent;
Text = TextCurrent;
}
}
for (LengthWrap = LengthWrap; LengthWrap < Len(Text); LengthWrap++)
if (Mid(Text, LengthWrap, 1) != " ")
break;
TextResult = Left(Text, LengthWrap);
Text = Mid(Text, LengthWrap);
Width = TextWidth(TextureCanvas, TextResult, FontText);
WidthMax = WidthCurrent;
return TextResult;
}
// ============================================================================
// TextWidth
//
// Returns the pixel width of a chunk of text in the given font.
// ============================================================================
simulated function int TextWidth(ScriptedTexture TextureCanvas, string Text, Font FontText) {
local float WidthText;
local float HeightText;
TextureCanvas.TextSize(Text, WidthText, HeightText, FontText);
return WidthText;
}
// ============================================================================
// TextHeight
//
// Returns the pixel width of a chunk of text in the given font.
// ============================================================================
simulated function int TextHeight(ScriptedTexture TextureCanvas, string Text, Font FontText) {
local float WidthText;
local float HeightText;
TextureCanvas.TextSize(Text, WidthText, HeightText, FontText);
return HeightText;
}
// ============================================================================
// Entity
//
// Returns a string that represents the given string with the entity at the
// given position replaced by its corresponding character.
// ============================================================================
simulated function string Entity(string Text, optional int Index) {
local string TextEntity;
local string TextCharacter;
local int IndexChar;
if (Mid(Text, Index, 1) != "&")
return Text;
for (IndexChar = Index + 1; IndexChar < Index + 8; IndexChar++)
if (Mid(Text, IndexChar, 1) == ";") {
TextEntity = Mid(Text, Index, IndexChar - Index + 1);
break;
}
if (Len(TextEntity) == 0)
return Text;
switch (TextEntity) {
case " ": TextCharacter = " "; break;
case """: TextCharacter = "\""; break;
case "<": TextCharacter = "<"; break;
case ">": TextCharacter = ">"; break;
case "&": TextCharacter = "&"; break;
case "ä": TextCharacter = "ä"; break;
case "ö": TextCharacter = "ö"; break;
case "ü": TextCharacter = "ü"; break;
case "Ä": TextCharacter = "Ä"; break;
case "Ö": TextCharacter = "Ö"; break;
case "Ü": TextCharacter = "Ü"; break;
case "ß": TextCharacter = "ß"; break;
default: TextCharacter = TextEntity;
}
return Left(Text, Index) $ TextCharacter $ Mid(Text, Index + Len(TextEntity));
}
// ============================================================================
// Entities
//
// Replaces some generic entities by their corresponding characters.
// ============================================================================
simulated function string Entities(string Text) {
local int IndexChar;
local int LengthMax;
local int LengthPrev;
for (IndexChar = 0; IndexChar < Len(Text); IndexChar++)
Text = Entity(Text, IndexChar);
return Text;
}
// ============================================================================
// Argument
//
// Extracts an argument from an html tag's argument list and returns that
// argument's string value. Returns an empty string if no matching argument is
// found.
// ============================================================================
simulated function string Argument(string ArgumentList, string ArgumentName) {
local int IndexChar;
local string CharPrev;
local string CharCurrent;
local string CharQuote;
local bool FlagQuoted;
local string ArgumentText;
FlagQuoted = false;
ArgumentName = Caps(ArgumentName) $ "=";
for (IndexChar = 0; IndexChar < Len(ArgumentList); IndexChar++) {
CharPrev = CharCurrent;
CharCurrent = Mid(ArgumentList, IndexChar, 1);
if ((CharCurrent == "\"" || CharCurrent == "'") && (!FlagQuoted || CharQuote == CharCurrent)) {
FlagQuoted = !FlagQuoted;
CharQuote = CharCurrent;
continue;
}
if (FlagQuoted)
continue;
if ((CharPrev == "" || CharPrev == " ") &&
Caps(Mid(ArgumentList, IndexChar, Len(ArgumentName))) == ArgumentName) {
ArgumentText = Mid(ArgumentList, IndexChar + Len(ArgumentName));
CharQuote = Left(ArgumentText, 1);
if (CharQuote == "\"" || CharQuote == "'")
ArgumentText = Mid(ArgumentText, 1, InStr(Mid(ArgumentText, 1) $ CharQuote, CharQuote));
else
ArgumentText = Left(ArgumentText, InStr(ArgumentText $ " ", " "));
break;
}
}
return Entities(ArgumentText);
}
// ============================================================================
// ArgumentNumber
//
// Converts an argument into a number and returns this value. Returns the
// given default number if the argument is invalid.
// ============================================================================
simulated function int ArgumentNumber(string ArgumentText, int NumberDefault) {
local int NumberResult;
NumberResult = int(ArgumentText);
if (string(NumberResult) == ArgumentText)
return NumberResult;
else
return NumberDefault;
}
// ============================================================================
// ArgumentAlign
//
// Converts an argument into a text alignment value and returns this value.
// Returns the given default alignment if the argument is invalid.
// ============================================================================
simulated function EnumTextAlign ArgumentAlign(string ArgumentText, EnumTextAlign AlignDefault) {
switch (Caps(ArgumentText)) {
case "LEFT": return TextAlign_Left;
case "CENTER": return TextAlign_Center;
case "RIGHT": return TextAlign_Right;
default: return AlignDefault;
}
}
// ============================================================================
// ArgumentColor
//
// Converts an argument into a Color value and returns that value. Returns the
// given default color if the argument didn't represent a valid color.
// ============================================================================
simulated function Color ArgumentColor(string ArgumentText, Color ColorDefault) {
local Color ColorResult;
if (Left(ArgumentText, 1) == "#") {
ColorResult.R = Hex(Mid(ArgumentText, 1, 2));
ColorResult.G = Hex(Mid(ArgumentText, 3, 2));
ColorResult.B = Hex(Mid(ArgumentText, 5, 2));
if (ColorResult.R < 0 || ColorResult.G < 0 || ColorResult.B < 0)
ColorResult = ColorDefault;
}
else {
switch (Caps(ArgumentText)) {
case "BLACK": ColorResult.R = 0x00; ColorResult.G = 0x00; ColorResult.B = 0x00; break;
case "MAROON": ColorResult.R = 0x80; ColorResult.G = 0x00; ColorResult.B = 0x00; break;
case "GREEN": ColorResult.R = 0x00; ColorResult.G = 0x80; ColorResult.B = 0x00; break;
case "OLIVE": ColorResult.R = 0x80; ColorResult.G = 0x80; ColorResult.B = 0x00; break;
case "NAVY": ColorResult.R = 0x00; ColorResult.G = 0x00; ColorResult.B = 0x80; break;
case "PURPLE": ColorResult.R = 0x80; ColorResult.G = 0x00; ColorResult.B = 0x80; break;
case "TEAL": ColorResult.R = 0x00; ColorResult.G = 0x80; ColorResult.B = 0x80; break;
case "GRAY": ColorResult.R = 0x80; ColorResult.G = 0x80; ColorResult.B = 0x80; break;
case "SILVER": ColorResult.R = 0xc0; ColorResult.G = 0xc0; ColorResult.B = 0xc0; break;
case "RED": ColorResult.R = 0xff; ColorResult.G = 0x00; ColorResult.B = 0x00; break;
case "LIME": ColorResult.R = 0x00; ColorResult.G = 0xff; ColorResult.B = 0x00; break;
case "YELLOW": ColorResult.R = 0xff; ColorResult.G = 0xff; ColorResult.B = 0x00; break;
case "BLUE": ColorResult.R = 0x00; ColorResult.G = 0x00; ColorResult.B = 0xff; break;
case "FUCHSIA": ColorResult.R = 0xff; ColorResult.G = 0x00; ColorResult.B = 0xff; break;
case "AQUA": ColorResult.R = 0x00; ColorResult.G = 0xff; ColorResult.B = 0xff; break;
case "WHITE": ColorResult.R = 0xff; ColorResult.G = 0xff; ColorResult.B = 0xff; break;
default: ColorResult = ColorDefault;
}
}
return ColorResult;
}
// ============================================================================
// ArgumentFont
//
// Returns a font that matches the given font size as closely as possible.
// Returns the given default font if no valid font size is given.
// ============================================================================
simulated function Font ArgumentFont(string ArgumentText, Font FontDefault) {
switch (ArgumentText) {
case "1": case "-2":
case "2": case "-1":
case "3": case "-0": case "+0":
case "4": case "+1":
return FontNormal;
case "5": case "+2":
case "6": case "+3":
case "7": case "+4":
return FontBig;
default:
return FontDefault;
}
}
// ============================================================================
// Hex
//
// Returns the numerical value that corresponds to a hexadecimal number or a
// negative value if no valid hexadecimal value was given.
// ============================================================================
simulated function int Hex(string TextHex) {
local int IndexChar;
local string CharCurrent;
local int Result;
Result = 0;
TextHex = Caps(TextHex);
for (IndexChar = 0; IndexChar < Len(TextHex); IndexChar++) {
CharCurrent = Mid(TextHex, IndexChar, 1);
switch (CharCurrent) {
case "0": Result = Result * 0x10; break;
case "1": Result = Result * 0x10 + 0x01; break;
case "2": Result = Result * 0x10 + 0x02; break;
case "3": Result = Result * 0x10 + 0x03; break;
case "4": Result = Result * 0x10 + 0x04; break;
case "5": Result = Result * 0x10 + 0x05; break;
case "6": Result = Result * 0x10 + 0x06; break;
case "7": Result = Result * 0x10 + 0x07; break;
case "8": Result = Result * 0x10 + 0x08; break;
case "9": Result = Result * 0x10 + 0x09; break;
case "A": Result = Result * 0x10 + 0x0A; break;
case "B": Result = Result * 0x10 + 0x0B; break;
case "C": Result = Result * 0x10 + 0x0C; break;
case "D": Result = Result * 0x10 + 0x0D; break;
case "E": Result = Result * 0x10 + 0x0E; break;
case "F": Result = Result * 0x10 + 0x0F; break;
default: return -1;
}
}
return Result;
}
// ============================================================================
// Default Properties
// ============================================================================
VjS A ½ ` AU aŁ?> @? B?,?l?t ?d ?T ?R SS -» VcW W@ : J “^ ³Æ ©^ ĶĢĢ=t^ ©{ d%cd_d&F c% V VV hD// ============================================================================
// ScreenUIPageNetwork
// Copyright 2001 by Mychaeel
//
// Content of Network tab in Screen user interface.
// ============================================================================
class ScreenUIPageNetwork extends UWindowPageWindow;
// ============================================================================
// Controls
// ============================================================================
var UWindowLabelControl LabelTitle;
var UWindowLabelControl LabelDescription1;
var UWindowLabelControl LabelDescription2;
var UWindowLabelControl LabelDescription3;
var UWindowLabelControl LabelDescription4;
var UWindowComboControl ComboNetwork;
// ============================================================================
// Created
// ============================================================================
function Created() {
LabelTitle = UWindowLabelControl(CreateControl(class 'UWindowLabelControl', 20, 17, WinWidth - 40, 1));
LabelTitle.SetText("Network Access");
LabelTitle.SetFont(F_Bold);
ComboNetwork = UWindowComboControl(CreateControl(class 'UWindowComboControl', 20, 43, WinWidth - 40, 1));
ComboNetwork.SetText("Live Content Downloads");
ComboNetwork.AddItem("Full Access");
ComboNetwork.AddItem("Restricted Access");
ComboNetwork.AddItem("No Access");
ComboNetwork.SetEditable(false);
ComboNetwork.SetSelectedIndex(int(class 'Screen'.default.Network));
LabelDescription1 = UWindowLabelControl(CreateControl(class 'UWindowLabelControl', 20, 74, WinWidth - 40, 1));
LabelDescription2 = UWindowLabelControl(CreateControl(class 'UWindowLabelControl', 20, 86, WinWidth - 40, 1));
LabelDescription3 = UWindowLabelControl(CreateControl(class 'UWindowLabelControl', 20, 98, WinWidth - 40, 1));
LabelDescription4 = UWindowLabelControl(CreateControl(class 'UWindowLabelControl', 20, 110, WinWidth - 40, 1));
SetDescription();
}
// ============================================================================
// SetDescription
//
// Sets the description text for the currently selected network access option.
// ============================================================================
function SetDescription() {
if (LabelDescription1 == None)
return;
switch (ComboNetwork.GetSelectedIndex()) {
case 0:
LabelDescription1.SetText("Grants live-feed screens permission to download live");
LabelDescription2.SetText("content from the Internet even in single player mode.");
LabelDescription3.SetText("Live-feed screens usually voluntarily restrict themselves");
LabelDescription4.SetText("to network games.");
break;
case 1:
LabelDescription1.SetText("Restricts all Internet access of live-feed screens to");
LabelDescription2.SetText("network games (when you join a network game or run");
LabelDescription3.SetText("a listen server) even if they request otherwise.");
LabelDescription4.SetText("");
break;
case 2:
LabelDescription1.SetText("Prevents all live content downloads by live-feed screens.");
LabelDescription2.SetText("Not recommended.");
LabelDescription3.SetText("");
LabelDescription4.SetText("");
break;
}
}
// ============================================================================
// Notify
// ============================================================================
function Notify(UWindowDialogControl Control, byte ControlEvent) {
switch (Control) {
case ComboNetwork:
if (ControlEvent == DE_Change)
SetDescription();
break;
}
}
// ============================================================================
// Close
// ============================================================================
function Close(optional bool ByParent) {
switch (ComboNetwork.GetSelectedIndex()) {
case 0: class 'Screen'.default.Network = ConfigNetwork_Always; break;
case 1: class 'Screen'.default.Network = ConfigNetwork_Network; break;
case 2: class 'Screen'.default.Network = ConfigNetwork_Never; break;
}
class 'Screen'.static.StaticSaveConfig();
Super.Close(ByParent);
}
V VV _ P:4 Ö& 62% 6% e6p% Y6V% $ Y S Y Y~p Y ? ? Y Y~ Y / & f%- ~' %s }
s
&- C- ~- ~z sģ,
z sģ,
z s H- ~ - C Wpp W
f f ii- ~ - C f „ £ - ~ Wp W
f
W u%- '- [(- (Ō}
% - [ *- A( p6V V z
& < ~
> . %Ō j
& &
& ~p j ė j D j &Éz & / &
Ų BODY - '- '{
ß H1
ę H2
ķ H3
ō H4
ū H5
H6
F P - '- ' Eś E P X 6 {
O FONT
W BIG
a SMALL
g B
x U - ({
’’ ? Ę ?%¼z62 ? ?&ʦ ?S
^ BODY %62% 6% e6p% &
D text Y6V% $ -6~% (- '- 'S
e H1
l H2
s H3
z H4
H5
_ H6 „ & 62 6 q6p s6V $
D align $ - '- '\w @* Eś E P X 6 S
R P ? ® ?%¤z62 ? P ?&®¦ ?p- '- 'ōw @* Eś E P X 6 „ % 62 6V $
D align $ S
BR I%” E P X 6 - '- 'S
Ļ IMG Y
D src o~ Y ? ā o% o} Y z Y o& Y Y o>zė Y, MYLEVEL. Ypp Y . Y, Z. į Y Ģ w Z* T.T S Z.T d %.T t %.T T Z °.T R Z ² Y % Y , o~ z , 5 o% o} zC o% A J z o Y
}%.T T A ā
&.T R A ā
¾,.T t A ā
ß,.T d A ā
’’ z z o& } z% „ Y ,
D width .T T l
D height .T R I , d- ' lS
FONT - '„ & 62 6 .
D size 6 & 6p &
D color 6p & S
ń
BIG - '„ & 62 6 aS
S SMALL - '„ & 62 6 eS
õ B - '„ & 62 6 &
Ī e6 `ņ
ļ a6 tņ
’’S
P U - '„ & 62 -6~ 'S
’’ŃŃ}
% - z
&
&l - ( ~
< ½ % }
H
å -j Hė HŃ} H% - q I%P'>
- >
z H& H H&
, d I. T4 P H ,6 - q |. s6 . }6p . -y-6~ 6- q ,%P- q' I%- '
- A | d I l P X 6 l
} H- - [°w ;* ; a/!- g}. ; Ta g%W{. ; T g&& a¦ g#¢ h ; , P. ; T g. ; s p
Ę$ m%
ä$ m d h,
ž$ m d h
’’ b ysw b*” b r y” b > m b P b b R I%” r y y% h%- ['§w *„ uÕ- ” r E E% y > I hi” h ,” I , yś y ]r ;* @ q ; R r y* y ; - [(- - AŃ}
% - [- '- [(ĮēØØpØ Rendered slide WÖ , S u items Z r y @ V S×// ============================================================================
// ScreenSlideMap
// Copyright 2001-2002 by Mychaeel
//
// Implements a ScreenSlide that displays the positions of players in a map
// on a map of that map. Much legacy code here; if designed from scratch this
// class would be much more efficient. Compatibility is the name of the game.
// ============================================================================
class ScreenSlideMap extends ScreenSlide;
// ============================================================================
// Compiler Directives
// ============================================================================
#exec texture import file=Textures\ActorSlideMap.bmp mips=off flags=2
#exec obj load file=Textures\ScreenFonts.utx package=ScreenFonts
#exec obj load file=Textures\ScriptedScreen.utx package=ScriptedScreen
// ============================================================================
// Replication
// ============================================================================
replication {
reliable if (Role == ROLE_Authority)
FlagMaster,
InfoPlayer, LocationPlayer, HealthPlayer, FlagPlayerVisible, ZonePlayer;
}
// ============================================================================
// Types
// ============================================================================
enum EnumCoordSelection {
CoordSelection_X,
CoordSelection_Y,
CoordSelection_Z,
};
enum EnumIconsType {
IconsType_Teams,
IconsType_Classes,
};
enum EnumDisplayAlignHorz {
DisplayAlignHorz_Left,
DisplayAlignHorz_Center,
DisplayAlignHorz_Right,
};
enum EnumDisplayAlignVert {
DisplayAlignVert_Top,
DisplayAlignVert_Middle,
DisplayAlignVert_Bottom,
};
enum EnumZoneDisplay {
ZoneDisplay_Inside,
ZoneDisplay_Outside,
};
// ============================================================================
// Properties
// ============================================================================
var() Font FontPlayers;
var() Color FontPlayersColor;
var() Texture Map;
var() Texture PlayerIcons;
var() EnumIconsType PlayerIconsType;
var() int PlayerIconsWidth;
var() int PlayerIconsHeight;
var() string PlayerDisplay;
var() EnumDisplayAlignHorz PlayerDisplayAlignHorz;
var() EnumDisplayAlignVert PlayerDisplayAlignVert;
var() int PlayerDisplayPaddingTop;
var() int PlayerDisplayPaddingLeft;
var() int PlayerDisplayPaddingRight;
var() int PlayerDisplayPaddingBottom;
var() bool ShowNeutral;
var() bool ShowRed;
var() bool ShowBlue;
var() bool ShowGreen;
var() bool ShowGold;
var() bool ShowNeutralInvisible;
var() bool ShowRedInvisible;
var() bool ShowBlueInvisible;
var() bool ShowGreenInvisible;
var() bool ShowGoldInvisible;
var() bool ShowDead;
var() bool ShowSelf;
var() int MapTop;
var() int MapLeft;
var() int MapRight;
var() int MapBottom;
var() EnumCoordSelection CoordHorz;
var() EnumCoordSelection CoordVert;
var() EnumCoordSelection CoordDepth;
var() int CoordDepthMin;
var() int CoordDepthMax;
var() float UpdateInterval;
var() Sound UpdateSound;
var() float UpdateSoundVolume;
var() bool UpdateSyncBackground;
var() bool UpdateSyncIcons;
var() ZoneInfo Zone;
var() class ZoneClass;
var() EnumZoneDisplay ZoneDisplay;
// ============================================================================
// Variables
// ============================================================================
var bool FlagMaster;
var PlayerPawn PlayerLocal;
var ScreenSlideMap SlideMapMaster;
var PlayerReplicationInfo InfoPlayer[32];
var vector LocationPlayer[32]; // individual arrays for better replication
var int HealthPlayer[32];
var int FlagPlayerVisible[32];
var ZoneInfo ZonePlayer[32];
var vector LocationPlayerAck[32];
var int HealthPlayerAck[32];
var int FlagPlayerVisibleAck[32];
var ZoneInfo ZonePlayerAck[32];
var float TimeCreate;
var float TimeTick;
var float TimeUpdate;
var bool FlagUpdate;
var Texture TextureBackgroundAck;
var Texture TextureBackgroundNext;
var Texture TextureIconsAck;
var Texture TextureIconsNext;
// ============================================================================
// PreBeginPlay
// ============================================================================
event PreBeginPlay() {
local ScreenSlideMap ThisSlide;
foreach AllActors(class 'ScreenSlideMap', ThisSlide)
if (ThisSlide.FlagMaster)
break;
if (ThisSlide == None)
FlagMaster = true;
else
RemoteRole = ROLE_None;
}
// ============================================================================
// Tick
// ============================================================================
event Tick(float TimeDelta) {
local int IndexPlayer;
local Pawn ThisPawn;
if (!FlagMaster || Level.TimeSeconds < TimeTick + 0.1)
return;
for (IndexPlayer = 0; IndexPlayer < ArrayCount(InfoPlayer); IndexPlayer++)
InfoPlayer[IndexPlayer] = None;
for (ThisPawn = Level.PawnList; ThisPawn != None; ThisPawn = ThisPawn.NextPawn)
if (ThisPawn.PlayerReplicationInfo != None &&
!ThisPawn.PlayerReplicationInfo.bIsSpectator &&
ThisPawn.PlayerReplicationInfo.PlayerID < ArrayCount(InfoPlayer))
SetInfo(ThisPawn.PlayerReplicationInfo.PlayerID, ThisPawn);
IndexPlayer = 0;
for (ThisPawn = Level.PawnList; ThisPawn != None; ThisPawn = ThisPawn.NextPawn)
if (ThisPawn.PlayerReplicationInfo != None &&
!ThisPawn.PlayerReplicationInfo.bIsSpectator &&
ThisPawn.PlayerReplicationInfo.PlayerID >= ArrayCount(InfoPlayer)) {
while (IndexPlayer < ArrayCount(InfoPlayer) && InfoPlayer[IndexPlayer] != None)
IndexPlayer++;
if (IndexPlayer >= ArrayCount(InfoPlayer))
break;
SetInfo(IndexPlayer, ThisPawn);
}
TimeTick = Level.TimeSeconds;
}
// ============================================================================
// SetInfo
//
// Fills the element at the given index of the various replicated arrays with
// information about the given player. Overwrite this function if you need to
// store and replicate your own information in subclasses.
// ============================================================================
function SetInfo(int IndexPlayer, Pawn PawnPlayer) {
InfoPlayer [IndexPlayer] = PawnPlayer.PlayerReplicationInfo;
LocationPlayer[IndexPlayer] = PawnPlayer.Location;
ZonePlayer [IndexPlayer] = PawnPlayer.Region.Zone;
HealthPlayer [IndexPlayer] = PawnPlayer.Health;
FlagPlayerVisible[IndexPlayer] =
int(PawnPlayer.FindInventoryType(class 'UT_Invisibility') == None &&
PawnPlayer.FindInventoryType(class 'UT_Stealth') == None);
}
// ============================================================================
// GetInfo
//
// Fills the element at the given index of the various replicated arrays with
// information taken from the given master slide. Called on all clients.
// Overwrite this function if you need to store and replicate your own
// information in subclasses.
// ============================================================================
simulated function GetInfo(int IndexPlayer, ScreenSlideMap SlideSource) {
InfoPlayer [IndexPlayer] = SlideSource.InfoPlayer [IndexPlayer];
LocationPlayer [IndexPlayer] = SlideSource.GetLocationPlayer(IndexPlayer);
HealthPlayer [IndexPlayer] = SlideSource.HealthPlayer [IndexPlayer];
FlagPlayerVisible[IndexPlayer] = SlideSource.FlagPlayerVisible[IndexPlayer];
ZonePlayer [IndexPlayer] = SlideSource.ZonePlayer [IndexPlayer];
}
// ============================================================================
// GetLocationPlayer
//
// Access method for an element of the LocationPlayer array. It's the only one
// that cannot be directly accessed because it's too large.
// ============================================================================
simulated final function vector GetLocationPlayer(int IndexPlayer) {
return LocationPlayer[IndexPlayer];
}
// ============================================================================
// Prepare
// ============================================================================
simulated function Prepare(ScriptedTexture TextureCanvas) {
local int IndexPlayer;
local GameReplicationInfo InfoGame;
if (PlayerLocal == None)
foreach AllActors(class 'PlayerPawn', PlayerLocal)
if (Viewport(PlayerLocal.Player) != None)
break;
InfoGame = PlayerLocal.GameReplicationInfo;
if (InfoGame == None)
return;
for (IndexPlayer = 0; IndexPlayer < ArrayCount(InfoGame.PRIArray); IndexPlayer++) {
if (InfoGame.PRIArray[IndexPlayer] == None)
break;
if (InfoGame.PRIArray[IndexPlayer].bIsSpectator ||
InfoGame.PRIArray[IndexPlayer].PlayerID >= ArrayCount(InfoPlayer))
continue;
InfoPlayer[InfoGame.PRIArray[IndexPlayer].PlayerID] = InfoGame.PRIArray[IndexPlayer];
}
if (TimeCreate < 0.0)
TimeCreate = Level.TimeSeconds;
if (SlideMapMaster == None && Level.TimeSeconds < TimeCreate + 1.0)
foreach AllActors(class 'ScreenSlideMap', SlideMapMaster)
if (SlideMapMaster.FlagMaster)
break;
if (SlideMapMaster == None ||
SlideMapMaster == Self)
return;
for (IndexPlayer = 0; IndexPlayer < ArrayCount(InfoPlayer); IndexPlayer++)
GetInfo(IndexPlayer, SlideMapMaster);
}
// ============================================================================
// Draw
// ============================================================================
simulated function Draw(ScriptedTexture TextureCanvas, int Left, int Top, float Fade) {
local GameReplicationInfo InfoGame;
local int IndexPlayer;
local int IdPlayerPrev;
local int FlagDisplayed[32];
local int CoordTopPlayer;
local int CoordLeftPlayer;
local int CoordDepthPlayer;
local int OffsetTopPlayer[32];
local int OffsetLeftPlayer[32];
DrawMap(TextureCanvas, Left, Top);
if (MapTop == MapBottom || MapLeft == MapRight)
return;
if (Level.TimeSeconds > TimeUpdate + UpdateInterval) {
TimeUpdate = Level.TimeSeconds;
Update();
}
InfoGame = PlayerLocal.GameReplicationInfo;
if (InfoGame == None)
return;
for (IndexPlayer = 0; IndexPlayer < ArrayCount(InfoPlayer); IndexPlayer++) {
if (InfoPlayer[IndexPlayer] == None)
continue;
IdPlayerPrev = InfoPlayer[IndexPlayer].PlayerID;
InfoPlayer[IndexPlayer].PlayerID = IndexPlayer;
if (IsDisplayed(InfoPlayer[IndexPlayer]) &&
CalcOffset(LocationPlayerAck[IndexPlayer], OffsetLeftPlayer[IndexPlayer],
OffsetTopPlayer [IndexPlayer])) {
DrawTag(TextureCanvas, InfoPlayer[IndexPlayer], Left + OffsetLeftPlayer[IndexPlayer],
Top + OffsetTopPlayer [IndexPlayer],
PlayerIconsWidth,
PlayerIconsHeight, Fade);
FlagDisplayed[IndexPlayer] = 1;
}
InfoPlayer[IndexPlayer].PlayerID = IdPlayerPrev;
}
for (IndexPlayer = 0; IndexPlayer < ArrayCount(InfoPlayer); IndexPlayer++)
if (FlagDisplayed[IndexPlayer] != 0) {
IdPlayerPrev = InfoPlayer[IndexPlayer].PlayerID;
InfoPlayer[IndexPlayer].PlayerID = IndexPlayer;
DrawIcon(TextureCanvas, InfoPlayer[IndexPlayer],
Left + OffsetLeftPlayer[IndexPlayer],
Top + OffsetTopPlayer [IndexPlayer], Fade);
InfoPlayer[IndexPlayer].PlayerID = IdPlayerPrev;
}
}
// ============================================================================
// Update
//
// Updates all information that is displayed on the slide with current
// information replicated by the server.
// ============================================================================
simulated function Update() {
local int IndexPlayer;
for (IndexPlayer = 0; IndexPlayer < ArrayCount(LocationPlayer); IndexPlayer++) {
LocationPlayerAck [IndexPlayer] = LocationPlayer [IndexPlayer];
HealthPlayerAck [IndexPlayer] = HealthPlayer [IndexPlayer];
FlagPlayerVisibleAck[IndexPlayer] = FlagPlayerVisible[IndexPlayer];
ZonePlayerAck [IndexPlayer] = ZonePlayer [IndexPlayer];
}
if (UpdateInterval == 0.0)
return;
if (UpdateSound != None)
PlaySound(UpdateSound, , UpdateSoundVolume);
if (Background != TextureBackgroundAck) {
if (TextureBackgroundAck != None)
TextureBackgroundAck.AnimNext = TextureBackgroundNext;
TextureBackgroundNext = Background.AnimNext;
TextureBackgroundAck = Background;
Background.AnimNext = None;
}
if (PlayerIcons != TextureIconsAck) {
if (TextureIconsAck != None)
TextureIconsAck.AnimNext = TextureIconsNext;
TextureIconsNext = PlayerIcons.AnimNext;
TextureIconsAck = PlayerIcons;
PlayerIcons.AnimNext = None;
}
if (UpdateSyncBackground && Background != None && TextureBackgroundNext != None)
Background.AnimCurrent = TextureBackgroundNext;
if (UpdateSyncIcons && PlayerIcons != None && TextureIconsNext != None)
PlayerIcons.AnimCurrent = TextureIconsNext;
}
// ============================================================================
// CalcOffset
//
// Fills in the pixel offsets on the slide that corresponds to the given
// location. Returns a boolean value that tells whether the given location is
// within the displayed bounds or not.
// ============================================================================
simulated function bool CalcOffset(vector VectorItem, optional out int OffsetLeftItem,
optional out int OffsetTopItem) {
local float CoordDepthItem;
CoordDepthItem = Component(VectorItem, CoordDepth);
if (CoordDepthMin < CoordDepthMax && CoordDepthItem != Clamp(CoordDepthItem, CoordDepthMin, CoordDepthMax))
return false;
OffsetLeftItem = (Component(VectorItem, CoordHorz) - MapLeft) * ClientWidth / (MapRight - MapLeft);
OffsetTopItem = (Component(VectorItem, CoordVert) - MapTop) * ClientHeight / (MapBottom - MapTop);
return (OffsetLeftItem == Clamp(OffsetLeftItem, 0, ClientWidth)) &&
(OffsetTopItem == Clamp(OffsetTopItem, 0, ClientHeight));
}
// ============================================================================
// DrawMap
//
// Draws the background map on the slide.
// ============================================================================
simulated function DrawMap(ScriptedTexture TextureCanvas, int Left, int Top) {
if (Map != None)
TextureCanvas.DrawTile(Left, Top, ClientWidth, ClientHeight, 0, 0, Map.USize, Map.VSize, Map, Map.bMasked);
}
// ============================================================================
// DrawTag
//
// Draws the player's text tag on the screen with the given parameters at the
// given position.
// ============================================================================
simulated function DrawTag(ScriptedTexture TextureCanvas, PlayerReplicationInfo Info,
int OffsetLeft, int OffsetTop, int WidthIcon, int HeightIcon, float Fade) {
local string TextDisplay;
local int OffsetLeftText;
local int OffsetTopText;
local int OffsetLeftIcon;
local int OffsetTopIcon;
local float WidthText;
local float HeightText;
TextDisplay = PlayerDisplay;
TextDisplay = Replace(TextDisplay, "%p", Info.PlayerName);
TextDisplay = Replace(TextDisplay, "%h", HealthPlayerAck[Info.PlayerID]);
TextDisplay = Replace(TextDisplay, "%s", int(Info.Score));
if (Len(TextDisplay) > 0) {
TextureCanvas.TextSize(TextDisplay, WidthText, HeightText, FontPlayers);
OffsetTopIcon = OffsetTop - HeightIcon / 2;
OffsetLeftIcon = OffsetLeft - WidthIcon / 2;
switch (PlayerDisplayAlignHorz) {
case DisplayAlignHorz_Left:
OffsetLeftText = OffsetLeftIcon - PlayerDisplayPaddingRight - int(WidthText);
if (OffsetLeftText < 0)
OffsetLeftText = OffsetLeftIcon + WidthIcon + PlayerDisplayPaddingLeft;
break;
case DisplayAlignHorz_Center:
OffsetLeftText = OffsetLeft - int(WidthText / 2);
break;
case DisplayAlignHorz_Right:
OffsetLeftText = OffsetLeftIcon + WidthIcon + PlayerDisplayPaddingLeft;
if (OffsetLeftText + WidthText >= C