DWORD CBUtils::HSLtoRGB(BYTE InH, BYTE InS, BYTE InL)
{
float H = InH / 255.0f;
float S = InS / 255.0f;
float L = InL / 255.0f;
BYTE R, G, B;
if ( S == 0 )
{
R = L * 255;
G = L * 255;
B = L * 255;
}
else
{
float var_1, var_2;
if(L < 0.5) var_2 = L * (1.0 + S);
else var_2 = (L + S) - (S * L);
var_1 = 2.0f * L - var_2;
R = 255 * Hue2RGB(var_1, var_2, H + (1.0f / 3.0f));
G = 255 * Hue2RGB(var_1, var_2, H);
B = 255 * Hue2RGB(var_1, var_2, H - (1.0f / 3.0f));
}
return DRGBA(255, R, G, B);
}
HRESULT CPartParticle::Display(CPartEmitter* Emitter)
{
if(!m_Sprite) return E_FAIL;
if(m_IsDead) return S_OK;
m_Sprite->GetCurrentFrame();
return m_Sprite->Display(m_Pos.x, m_Pos.y,
NULL,
m_Scale, m_Scale,
DRGBA(255, 255, 255, m_CurrentAlpha),
m_Rotation,
Emitter->m_BlendMode);
}
void CBFontTT::DrawText(byte *Text, int X, int Y, int Width, TTextAlign Align, int MaxHeight, int MaxLength) {
if (Text == NULL || strcmp((char *)Text, "") == 0) return;
WideString text;
if (Game->m_TextEncoding == TEXT_UTF8) text = StringUtil::Utf8ToWide((char *)Text);
else text = StringUtil::AnsiToWide((char *)Text);
if (MaxLength >= 0 && text.length() > MaxLength) text = text.substr(0, MaxLength);
CBRenderSDL *m_Renderer = (CBRenderSDL *)Game->m_Renderer;
// find cached surface, if exists
int MinPriority = INT_MAX;
int MinIndex = -1;
CBSurface *Surface = NULL;
int textOffset = 0;
for (int i = 0; i < NUM_CACHED_TEXTS; i++) {
if (m_CachedTexts[i] == NULL) {
MinPriority = 0;
MinIndex = i;
} else {
if (m_CachedTexts[i]->m_Text == text && m_CachedTexts[i]->m_Align == Align && m_CachedTexts[i]->m_Width == Width && m_CachedTexts[i]->m_MaxHeight == MaxHeight && m_CachedTexts[i]->m_MaxLength == MaxLength) {
Surface = m_CachedTexts[i]->m_Surface;
textOffset = m_CachedTexts[i]->m_TextOffset;
m_CachedTexts[i]->m_Priority++;
m_CachedTexts[i]->m_Marked = true;
break;
} else {
if (m_CachedTexts[i]->m_Priority < MinPriority) {
MinPriority = m_CachedTexts[i]->m_Priority;
MinIndex = i;
}
}
}
}
// not found, create one
if (!Surface) {
Surface = RenderTextToTexture(text, Width, Align, MaxHeight, textOffset);
if (Surface) {
// write surface to cache
if (m_CachedTexts[MinIndex] != NULL) delete m_CachedTexts[MinIndex];
m_CachedTexts[MinIndex] = new CBCachedTTFontText;
m_CachedTexts[MinIndex]->m_Surface = Surface;
m_CachedTexts[MinIndex]->m_Align = Align;
m_CachedTexts[MinIndex]->m_Width = Width;
m_CachedTexts[MinIndex]->m_MaxHeight = MaxHeight;
m_CachedTexts[MinIndex]->m_MaxLength = MaxLength;
m_CachedTexts[MinIndex]->m_Priority = 1;
m_CachedTexts[MinIndex]->m_Text = text;
m_CachedTexts[MinIndex]->m_TextOffset = textOffset;
m_CachedTexts[MinIndex]->m_Marked = true;
}
}
// and paint it
if (Surface) {
RECT rc;
CBPlatform::SetRect(&rc, 0, 0, Surface->GetWidth(), Surface->GetHeight());
for (int i = 0; i < m_Layers.GetSize(); i++) {
uint32 Color = m_Layers[i]->m_Color;
uint32 OrigForceAlpha = m_Renderer->m_ForceAlphaColor;
if (m_Renderer->m_ForceAlphaColor != 0) {
Color = DRGBA(D3DCOLGetR(Color), D3DCOLGetG(Color), D3DCOLGetB(Color), D3DCOLGetA(m_Renderer->m_ForceAlphaColor));
m_Renderer->m_ForceAlphaColor = 0;
}
Surface->DisplayTransOffset(X, Y - textOffset, rc, Color, BLEND_NORMAL, false, false, m_Layers[i]->m_OffsetX, m_Layers[i]->m_OffsetY);
m_Renderer->m_ForceAlphaColor = OrigForceAlpha;
}
}
}
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
HRESULT CAdRegion::LoadBuffer(byte *Buffer, bool Complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(REGION)
TOKEN_TABLE(TEMPLATE)
TOKEN_TABLE(NAME)
TOKEN_TABLE(ACTIVE)
TOKEN_TABLE(ZOOM)
TOKEN_TABLE(SCALE)
TOKEN_TABLE(BLOCKED)
TOKEN_TABLE(DECORATION)
TOKEN_TABLE(POINT)
TOKEN_TABLE(ALPHA_COLOR)
TOKEN_TABLE(ALPHA)
TOKEN_TABLE(EDITOR_SELECTED_POINT)
TOKEN_TABLE(EDITOR_SELECTED)
TOKEN_TABLE(SCRIPT)
TOKEN_TABLE(CAPTION)
TOKEN_TABLE(PROPERTY)
TOKEN_TABLE(EDITOR_PROPERTY)
TOKEN_TABLE_END
byte *params;
int cmd;
CBParser parser(Game);
if (Complete) {
if (parser.GetCommand((char **)&Buffer, commands, (char **)¶ms) != TOKEN_REGION) {
Game->LOG(0, "'REGION' keyword expected.");
return E_FAIL;
}
Buffer = params;
}
int i;
for (i = 0; i < m_Points.GetSize(); i++) delete m_Points[i];
m_Points.RemoveAll();
int ar = 255, ag = 255, ab = 255, alpha = 255;
while ((cmd = parser.GetCommand((char **)&Buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
case TOKEN_TEMPLATE:
if (FAILED(LoadFile((char *)params))) cmd = PARSERR_GENERIC;
break;
case TOKEN_NAME:
SetName((char *)params);
break;
case TOKEN_CAPTION:
SetCaption((char *)params);
break;
case TOKEN_ACTIVE:
parser.ScanStr((char *)params, "%b", &m_Active);
break;
case TOKEN_BLOCKED:
parser.ScanStr((char *)params, "%b", &m_Blocked);
break;
case TOKEN_DECORATION:
parser.ScanStr((char *)params, "%b", &m_Decoration);
break;
case TOKEN_ZOOM:
case TOKEN_SCALE: {
int i;
parser.ScanStr((char *)params, "%d", &i);
m_Zoom = (float)i;
}
break;
case TOKEN_POINT: {
int x, y;
parser.ScanStr((char *)params, "%d,%d", &x, &y);
m_Points.Add(new CBPoint(x, y));
}
break;
case TOKEN_ALPHA_COLOR:
parser.ScanStr((char *)params, "%d,%d,%d", &ar, &ag, &ab);
break;
case TOKEN_ALPHA:
parser.ScanStr((char *)params, "%d", &alpha);
break;
case TOKEN_EDITOR_SELECTED:
parser.ScanStr((char *)params, "%b", &m_EditorSelected);
break;
case TOKEN_EDITOR_SELECTED_POINT:
parser.ScanStr((char *)params, "%d", &m_EditorSelectedPoint);
break;
case TOKEN_SCRIPT:
AddScript((char *)params);
break;
case TOKEN_PROPERTY:
ParseProperty(params, false);
break;
case TOKEN_EDITOR_PROPERTY:
ParseEditorProperty(params, false);
break;
}
}
if (cmd == PARSERR_TOKENNOTFOUND) {
Game->LOG(0, "Syntax error in REGION definition");
return E_FAIL;
}
CreateRegion();
m_Alpha = DRGBA(ar, ag, ab, alpha);
return S_OK;
}
void CBFontTT::DrawTextD3D(BYTE* Text, int X, int Y, int Width, TTextAlign Align, int MaxHeight, int MaxLength)
{
CBRenderD3D* m_Renderer = (CBRenderD3D*)Game->m_Renderer;
// find cached surface, if exists
int MinPriority = INT_MAX;
int MaxPriority = 0;
int MinIndex = -1;
CBSurface* Surface = NULL;
for(int i=0; i<NUM_CACHED_TEXTS; i++)
{
if(m_CachedTexts[i]==NULL)
{
MinPriority = 0;
MinIndex = i;
}
else
{
MaxPriority = max(MaxPriority, m_CachedTexts[i]->m_Priority);
if(strcmp(m_CachedTexts[i]->m_Text, (char*)Text)==0 && m_CachedTexts[i]->m_Align==Align && m_CachedTexts[i]->m_Width==Width && m_CachedTexts[i]->m_MaxHeight==MaxHeight && m_CachedTexts[i]->m_MaxLength==MaxLength)
{
Surface = m_CachedTexts[i]->m_Surface;
m_CachedTexts[i]->m_Priority++;
break;
}
else
{
if(m_CachedTexts[i]->m_Priority < MinPriority)
{
MinPriority = m_CachedTexts[i]->m_Priority;
MinIndex = i;
}
}
}
}
// not found, create one
if(!Surface)
{
if(FAILED(CreateWinFont())) return;
HDC hDC = ::CreateCompatibleDC(NULL);
::SetMapMode(hDC, MM_TEXT);
HFONT OldFont = (HFONT)::SelectObject(hDC, m_HFont);
::SetTextColor(hDC, RGB(255,255,255));
::SetBkColor(hDC, 0x00000000);
int TextX = 0;
SetTextAlign(hDC, Align, Width, &TextX);
BYTE* ConvertedText = CBTextUtils::ConvertToNative(Game->m_TextEncoding, Text, MaxLength);
//ExtTextOut(hDC, 0, 0, ETO_OPAQUE, NULL, (char*)Text, strlen((char*)Text), NULL);
int Height = FormatText(TextX, 0, ConvertedText, hDC, Width, MaxHeight);
Height = max(Height, 1);
DWORD* BitmapBits;
BITMAPINFO bmi;
memset(&bmi, 0, sizeof(BITMAPINFO));
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = (int)Width;
bmi.bmiHeader.biHeight = -(int)Height;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biCompression = BI_RGB;
bmi.bmiHeader.biBitCount = 32;
HBITMAP hbmBitmap = ::CreateDIBSection(hDC, &bmi, DIB_RGB_COLORS, (VOID**)&BitmapBits, NULL, 0);
HBITMAP OldBitmap = (HBITMAP)::SelectObject(hDC, hbmBitmap);
FormatText(TextX, 0, ConvertedText, hDC, Width, MaxHeight);
CBImage* Image = new CBImage(Game);
Image->CreateFromRaw(BitmapBits, Width, Height);
Surface = Image->CreateSurface();
delete Image;
::SelectObject(hDC, OldBitmap);
::SelectObject(hDC, OldFont);
::DeleteObject(hbmBitmap);
::DeleteDC(hDC);
DeleteWinFont();
delete [] ConvertedText;
// write surface to cache
if(m_CachedTexts[MinIndex]!=NULL) delete m_CachedTexts[MinIndex];
m_CachedTexts[MinIndex] = new CBCachedTTFontText;
m_CachedTexts[MinIndex]->m_Surface = Surface;
m_CachedTexts[MinIndex]->m_Align = Align;
m_CachedTexts[MinIndex]->m_Width = Width;
m_CachedTexts[MinIndex]->m_MaxHeight = MaxHeight;
m_CachedTexts[MinIndex]->m_MaxLength = MaxLength;
m_CachedTexts[MinIndex]->m_Priority = MaxPriority + 1;
CBUtils::SetString(&m_CachedTexts[MinIndex]->m_Text, (char*)Text);
}
// and paint it
if(Surface)
{
RECT rc;
SetRect(&rc, 0, 0, Surface->GetWidth(), Surface->GetHeight());
for(int i=0; i<m_Layers.GetSize(); i++)
{
DWORD Color = m_Layers[i]->m_Color;
DWORD OrigForceAlpha = m_Renderer->m_ForceAlphaColor;
if(m_Renderer->m_ForceAlphaColor!=0)
{
Color = DRGBA(D3DCOLGetR(Color), D3DCOLGetG(Color), D3DCOLGetB(Color), D3DCOLGetA(m_Renderer->m_ForceAlphaColor));
m_Renderer->m_ForceAlphaColor = 0;
}
Surface->DisplayTrans(X+m_Layers[i]->m_OffsetX, Y+m_Layers[i]->m_OffsetY, rc, Color);
m_Renderer->m_ForceAlphaColor = OrigForceAlpha;
}
}
}
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
HRESULT CUIWindow::LoadBuffer(BYTE* Buffer, bool Complete)
{
TOKEN_TABLE_START(commands)
TOKEN_TABLE (WINDOW)
TOKEN_TABLE (ALPHA_COLOR)
TOKEN_TABLE (ALPHA)
TOKEN_TABLE (TEMPLATE)
TOKEN_TABLE (DISABLED)
TOKEN_TABLE (VISIBLE)
TOKEN_TABLE (BACK_INACTIVE)
TOKEN_TABLE (BACK)
TOKEN_TABLE (IMAGE_INACTIVE)
TOKEN_TABLE (IMAGE)
TOKEN_TABLE (FONT_INACTIVE)
TOKEN_TABLE (FONT)
TOKEN_TABLE (TITLE_ALIGN)
TOKEN_TABLE (TITLE_RECT)
TOKEN_TABLE (TITLE)
TOKEN_TABLE (DRAG_RECT)
TOKEN_TABLE (X)
TOKEN_TABLE (Y)
TOKEN_TABLE (WIDTH)
TOKEN_TABLE (HEIGHT)
TOKEN_TABLE (FADE_ALPHA)
TOKEN_TABLE (FADE_COLOR)
TOKEN_TABLE (CURSOR)
TOKEN_TABLE (NAME)
TOKEN_TABLE (BUTTON)
TOKEN_TABLE (STATIC)
TOKEN_TABLE (TRANSPARENT)
TOKEN_TABLE (SCRIPT)
TOKEN_TABLE (CAPTION)
TOKEN_TABLE (PARENT_NOTIFY)
TOKEN_TABLE (MENU)
TOKEN_TABLE (IN_GAME)
TOKEN_TABLE (CLIP_CONTENTS)
TOKEN_TABLE (PAUSE_MUSIC)
TOKEN_TABLE (EDITOR_PROPERTY)
TOKEN_TABLE (EDIT)
TOKEN_TABLE_END
BYTE* params;
int cmd=2;
CBParser parser(Game);
int FadeR=0, FadeG=0, FadeB=0, FadeA=0;
int ar=0, ag=0, ab=0, alpha=0;
if(Complete)
{
if(parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)!=TOKEN_WINDOW)
{
Game->LOG(0, "'WINDOW' keyword expected.");
return E_FAIL;
}
Buffer = params;
}
while (cmd >= PARSERR_TOKENNOTFOUND && (cmd = parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)) >= PARSERR_TOKENNOTFOUND)
{
switch (cmd)
{
case TOKEN_TEMPLATE:
if(FAILED(LoadFile((char*)params))) cmd = PARSERR_GENERIC;
break;
case TOKEN_NAME:
SetName((char*)params);
break;
case TOKEN_CAPTION:
SetCaption((char*)params);
break;
case TOKEN_BACK:
SAFE_DELETE(m_Back);
m_Back = new CUITiledImage(Game);
if(!m_Back || FAILED(m_Back->LoadFile((char*)params)))
{
SAFE_DELETE(m_Back);
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_BACK_INACTIVE:
SAFE_DELETE(m_BackInactive);
m_BackInactive = new CUITiledImage(Game);
if(!m_BackInactive || FAILED(m_BackInactive->LoadFile((char*)params)))
{
SAFE_DELETE(m_BackInactive);
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_IMAGE:
SAFE_DELETE(m_Image);
m_Image = new CBSprite(Game);
if(!m_Image || FAILED(m_Image->LoadFile((char*)params)))
{
SAFE_DELETE(m_Image);
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_IMAGE_INACTIVE:
SAFE_DELETE(m_ImageInactive);
m_ImageInactive = new CBSprite(Game);
if(!m_ImageInactive || FAILED(m_ImageInactive->LoadFile((char*)params)))
{
SAFE_DELETE(m_ImageInactive);
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_FONT:
if(m_Font) Game->m_FontStorage->RemoveFont(m_Font);
m_Font = Game->m_FontStorage->AddFont((char*)params);
if(!m_Font) cmd = PARSERR_GENERIC;
break;
case TOKEN_FONT_INACTIVE:
if(m_FontInactive) Game->m_FontStorage->RemoveFont(m_FontInactive);
m_FontInactive = Game->m_FontStorage->AddFont((char*)params);
if(!m_FontInactive) cmd = PARSERR_GENERIC;
break;
case TOKEN_TITLE:
SetText((char*)params);
Game->m_StringTable->Expand(&m_Text);
break;
case TOKEN_TITLE_ALIGN:
if(CBPlatform::stricmp((char*)params, "left")==0) m_TitleAlign = TAL_LEFT;
else if(CBPlatform::stricmp((char*)params, "right")==0) m_TitleAlign = TAL_RIGHT;
else m_TitleAlign = TAL_CENTER;
break;
case TOKEN_TITLE_RECT:
parser.ScanStr((char*)params, "%d,%d,%d,%d", &m_TitleRect.left, &m_TitleRect.top, &m_TitleRect.right, &m_TitleRect.bottom);
break;
case TOKEN_DRAG_RECT:
parser.ScanStr((char*)params, "%d,%d,%d,%d", &m_DragRect.left, &m_DragRect.top, &m_DragRect.right, &m_DragRect.bottom);
break;
case TOKEN_X:
parser.ScanStr((char*)params, "%d", &m_PosX);
break;
case TOKEN_Y:
parser.ScanStr((char*)params, "%d", &m_PosY);
break;
case TOKEN_WIDTH:
parser.ScanStr((char*)params, "%d", &m_Width);
break;
case TOKEN_HEIGHT:
parser.ScanStr((char*)params, "%d", &m_Height);
break;
case TOKEN_CURSOR:
SAFE_DELETE(m_Cursor);
m_Cursor = new CBSprite(Game);
if(!m_Cursor || FAILED(m_Cursor->LoadFile((char*)params)))
{
SAFE_DELETE(m_Cursor);
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_BUTTON:
{
CUIButton* btn = new CUIButton(Game);
if(!btn || FAILED(btn->LoadBuffer(params, false)))
{
SAFE_DELETE(btn);
cmd = PARSERR_GENERIC;
}
else
{
btn->m_Parent = this;
m_Widgets.Add(btn);
}
}
break;
case TOKEN_STATIC:
{
CUIText* text = new CUIText(Game);
if(!text || FAILED(text->LoadBuffer(params, false)))
{
SAFE_DELETE(text);
cmd = PARSERR_GENERIC;
}
else
{
text->m_Parent = this;
m_Widgets.Add(text);
}
}
break;
case TOKEN_EDIT:
{
CUIEdit* edit = new CUIEdit(Game);
if(!edit || FAILED(edit->LoadBuffer(params, false)))
{
SAFE_DELETE(edit);
cmd = PARSERR_GENERIC;
}
else
{
edit->m_Parent = this;
m_Widgets.Add(edit);
}
}
break;
case TOKEN_WINDOW:
{
CUIWindow* win = new CUIWindow(Game);
if(!win || FAILED(win->LoadBuffer(params, false)))
{
SAFE_DELETE(win);
cmd = PARSERR_GENERIC;
}
else
{
win->m_Parent = this;
m_Widgets.Add(win);
}
}
break;
case TOKEN_TRANSPARENT:
parser.ScanStr((char*)params, "%b", &m_Transparent);
break;
case TOKEN_SCRIPT:
AddScript((char*)params);
break;
case TOKEN_PARENT_NOTIFY:
parser.ScanStr((char*)params, "%b", &m_ParentNotify);
break;
case TOKEN_PAUSE_MUSIC:
parser.ScanStr((char*)params, "%b", &m_PauseMusic);
break;
case TOKEN_DISABLED:
parser.ScanStr((char*)params, "%b", &m_Disable);
break;
case TOKEN_VISIBLE:
parser.ScanStr((char*)params, "%b", &m_Visible);
break;
case TOKEN_MENU:
parser.ScanStr((char*)params, "%b", &m_IsMenu);
break;
case TOKEN_IN_GAME:
parser.ScanStr((char*)params, "%b", &m_InGame);
break;
case TOKEN_CLIP_CONTENTS:
parser.ScanStr((char*)params, "%b", &m_ClipContents);
break;
case TOKEN_FADE_COLOR:
parser.ScanStr((char*)params, "%d,%d,%d", &FadeR, &FadeG, &FadeB);
m_FadeBackground = true;
break;
case TOKEN_FADE_ALPHA:
parser.ScanStr((char*)params, "%d", &FadeA);
m_FadeBackground = true;
break;
case TOKEN_EDITOR_PROPERTY:
ParseEditorProperty(params, false);
break;
case TOKEN_ALPHA_COLOR:
parser.ScanStr((char*)params, "%d,%d,%d", &ar, &ag, &ab);
break;
case TOKEN_ALPHA:
parser.ScanStr((char*)params, "%d", &alpha);
break;
default:
if(FAILED(Game->WindowLoadHook(this, (char**)&Buffer, (char**)params)))
{
cmd = PARSERR_GENERIC;
}
}
}
if (cmd == PARSERR_TOKENNOTFOUND)
{
Game->LOG(0, "Syntax error in WINDOW definition");
return E_FAIL;
}
if (cmd == PARSERR_GENERIC)
{
Game->LOG(0, "Error loading WINDOW definition");
return E_FAIL;
}
CorrectSize();
if(alpha != 0 && ar==0 && ag == 0 && ab == 0)
{
ar = ag = ab = 255;
}
m_AlphaColor = DRGBA(ar, ag, ab, alpha);
if(m_FadeBackground) m_FadeColor = DRGBA(FadeR, FadeG, FadeB, FadeA);
m_FocusedWidget = NULL;
return S_OK;
}
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
HRESULT CAdActor::LoadBuffer(BYTE * Buffer, bool Complete)
{
TOKEN_TABLE_START(commands)
TOKEN_TABLE (ACTOR)
TOKEN_TABLE (X)
TOKEN_TABLE (Y)
TOKEN_TABLE (TEMPLATE)
TOKEN_TABLE (NAME)
TOKEN_TABLE (SCALABLE)
TOKEN_TABLE (REGISTRABLE)
TOKEN_TABLE (INTERACTIVE)
TOKEN_TABLE (SHADOWABLE)
TOKEN_TABLE (COLORABLE)
TOKEN_TABLE (ACTIVE)
TOKEN_TABLE (WALK)
TOKEN_TABLE (STAND)
TOKEN_TABLE (TALK_SPECIAL)
TOKEN_TABLE (TALK)
TOKEN_TABLE (TURN_LEFT)
TOKEN_TABLE (TURN_RIGHT)
TOKEN_TABLE (EVENTS)
TOKEN_TABLE (FONT)
TOKEN_TABLE (CURSOR)
TOKEN_TABLE (SCRIPT)
TOKEN_TABLE (SOUND_VOLUME)
TOKEN_TABLE (SOUND_PANNING)
TOKEN_TABLE (CAPTION)
TOKEN_TABLE (PROPERTY)
TOKEN_TABLE (BLOCKED_REGION)
TOKEN_TABLE (WAYPOINTS)
TOKEN_TABLE (IGNORE_ITEMS)
TOKEN_TABLE (ROTABLE)
TOKEN_TABLE (ROTATABLE)
TOKEN_TABLE (ALPHA_COLOR)
TOKEN_TABLE (SCALE)
TOKEN_TABLE (RELATIVE_SCALE)
TOKEN_TABLE (ALPHA)
TOKEN_TABLE (EDITOR_PROPERTY)
TOKEN_TABLE (ANIMATION)
TOKEN_TABLE_END
BYTE* params;
int cmd;
CBParser parser(Game);
if(Complete)
{
if(parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)!=TOKEN_ACTOR)
{
Game->LOG(0, "'ACTOR' keyword expected.");
return E_FAIL;
}
Buffer = params;
}
CAdGame* AdGame = (CAdGame*)Game;
CAdSpriteSet* spr = NULL;
int ar=0, ag=0, ab=0, alpha=0;
while ((cmd = parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)) > 0)
{
switch (cmd)
{
case TOKEN_TEMPLATE:
if(FAILED(LoadFile((char*)params))) cmd = PARSERR_GENERIC;
break;
case TOKEN_X:
parser.ScanStr((char*)params, "%d", &m_PosX);
break;
case TOKEN_Y:
parser.ScanStr((char*)params, "%d", &m_PosY);
break;
case TOKEN_NAME:
SetName((char*)params);
break;
case TOKEN_CAPTION:
SetCaption((char*)params);
break;
case TOKEN_FONT:
SetFont((char*)params);
break;
case TOKEN_SCALABLE:
parser.ScanStr((char*)params, "%b", &m_Zoomable);
break;
case TOKEN_ROTABLE:
case TOKEN_ROTATABLE:
parser.ScanStr((char*)params, "%b", &m_Rotatable);
break;
case TOKEN_REGISTRABLE:
case TOKEN_INTERACTIVE:
parser.ScanStr((char*)params, "%b", &m_Registrable);
break;
case TOKEN_SHADOWABLE:
case TOKEN_COLORABLE:
parser.ScanStr((char*)params, "%b", &m_Shadowable);
break;
case TOKEN_ACTIVE:
parser.ScanStr((char*)params, "%b", &m_Active);
break;
case TOKEN_WALK:
SAFE_DELETE(m_WalkSprite);
spr = new CAdSpriteSet(Game, this);
if(!spr || FAILED(spr->LoadBuffer(params, true, AdGame->m_TexWalkLifeTime, CACHE_HALF))) cmd = PARSERR_GENERIC;
else m_WalkSprite = spr;
break;
case TOKEN_TALK:
spr = new CAdSpriteSet(Game, this);
if(!spr || FAILED(spr->LoadBuffer(params, true, AdGame->m_TexTalkLifeTime))) cmd = PARSERR_GENERIC;
else m_TalkSprites.Add(spr);
break;
case TOKEN_TALK_SPECIAL:
spr = new CAdSpriteSet(Game, this);
if(!spr || FAILED(spr->LoadBuffer(params, true, AdGame->m_TexTalkLifeTime))) cmd = PARSERR_GENERIC;
else m_TalkSpritesEx.Add(spr);
break;
case TOKEN_STAND:
SAFE_DELETE(m_StandSprite);
spr = new CAdSpriteSet(Game, this);
if(!spr || FAILED(spr->LoadBuffer(params, true, AdGame->m_TexStandLifeTime))) cmd = PARSERR_GENERIC;
else m_StandSprite = spr;
break;
case TOKEN_TURN_LEFT:
SAFE_DELETE(m_TurnLeftSprite);
spr = new CAdSpriteSet(Game, this);
if(!spr || FAILED(spr->LoadBuffer(params, true))) cmd = PARSERR_GENERIC;
else m_TurnLeftSprite = spr;
break;
case TOKEN_TURN_RIGHT:
SAFE_DELETE(m_TurnRightSprite);
spr = new CAdSpriteSet(Game, this);
if(!spr || FAILED(spr->LoadBuffer(params, true))) cmd = PARSERR_GENERIC;
else m_TurnRightSprite = spr;
break;
case TOKEN_SCRIPT:
AddScript((char*)params);
break;
case TOKEN_CURSOR:
SAFE_DELETE(m_Cursor);
m_Cursor = new CBSprite(Game);
if(!m_Cursor || FAILED(m_Cursor->LoadFile((char*)params)))
{
SAFE_DELETE(m_Cursor);
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_SOUND_VOLUME:
parser.ScanStr((char*)params, "%d", &m_SFXVolume);
break;
case TOKEN_SCALE:
{
int s;
parser.ScanStr((char*)params, "%d", &s);
m_Scale = (float)s;
}
break;
case TOKEN_RELATIVE_SCALE:
{
int s;
parser.ScanStr((char*)params, "%d", &s);
m_RelativeScale = (float)s;
}
break;
case TOKEN_SOUND_PANNING:
parser.ScanStr((char*)params, "%b", &m_AutoSoundPanning);
break;
case TOKEN_PROPERTY:
ParseProperty(params, false);
break;
case TOKEN_BLOCKED_REGION:
{
SAFE_DELETE(m_BlockRegion);
SAFE_DELETE(m_CurrentBlockRegion);
CBRegion* rgn = new CBRegion(Game);
CBRegion* crgn = new CBRegion(Game);
if(!rgn || !crgn || FAILED(rgn->LoadBuffer(params, false)))
{
SAFE_DELETE(m_BlockRegion);
SAFE_DELETE(m_CurrentBlockRegion);
cmd = PARSERR_GENERIC;
}
else{
m_BlockRegion = rgn;
m_CurrentBlockRegion = crgn;
m_CurrentBlockRegion->Mimic(m_BlockRegion);
}
}
break;
case TOKEN_WAYPOINTS:
{
SAFE_DELETE(m_WptGroup);
SAFE_DELETE(m_CurrentWptGroup);
CAdWaypointGroup* wpt = new CAdWaypointGroup(Game);
CAdWaypointGroup* cwpt = new CAdWaypointGroup(Game);
if(!wpt || !cwpt || FAILED(wpt->LoadBuffer(params, false)))
{
SAFE_DELETE(m_WptGroup);
SAFE_DELETE(m_CurrentWptGroup);
cmd = PARSERR_GENERIC;
}
else{
m_WptGroup = wpt;
m_CurrentWptGroup = cwpt;
m_CurrentWptGroup->Mimic(m_WptGroup);
}
}
break;
case TOKEN_IGNORE_ITEMS:
parser.ScanStr((char*)params, "%b", &m_IgnoreItems);
break;
case TOKEN_ALPHA_COLOR:
parser.ScanStr((char*)params, "%d,%d,%d", &ar, &ag, &ab);
break;
case TOKEN_ALPHA:
parser.ScanStr((char*)params, "%d", &alpha);
break;
case TOKEN_EDITOR_PROPERTY:
ParseEditorProperty(params, false);
break;
case TOKEN_ANIMATION:
{
CAdSpriteSet* Anim = new CAdSpriteSet(Game, this);
if(!Anim || FAILED(Anim->LoadBuffer(params, false))) cmd = PARSERR_GENERIC;
else m_Anims.Add(Anim);
}
break;
}
}
if (cmd == PARSERR_TOKENNOTFOUND)
{
Game->LOG(0, "Syntax error in ACTOR definition");
return E_FAIL;
}
if (cmd == PARSERR_GENERIC)
{
if(spr) delete spr;
Game->LOG(0, "Error loading ACTOR definition");
return E_FAIL;
}
if(alpha != 0 && ar==0 && ag == 0 && ab == 0)
{
ar = ag = ab = 255;
}
m_AlphaColor = DRGBA(ar, ag, ab, alpha);
m_State = m_NextState = STATE_READY;
return S_OK;
}
void CViewProps::OnPropChange(CPLProperty *Prop, CPLCategory *Cat)
{
if(!m_View) return;
CProjectDoc* Doc = m_View->GetDocument();
if(!Doc) return;
Doc->SetModifiedFlag();
//////////////////////////////////////////////////////////////////////////
if(Cat->GetID()=="startup"){
if(Prop->GetID()=="resolution-x"){
Doc->m_Settings->m_ResolutionWidth = atoi(Prop->GetValue());
}
else if(Prop->GetID()=="resolution-y"){
Doc->m_Settings->m_ResolutionHeight = atoi(Prop->GetValue());
}
else if(Prop->GetID()=="reg-path"){
SAFE_DELETE_ARRAY(Doc->m_Settings->m_RegPath);
Doc->m_Settings->m_RegPath = new char[strlen(Prop->GetValue())+1];
strcpy(Doc->m_Settings->m_RegPath, Prop->GetValue());
//CopyStr(Doc->m_Settings->m_RegPath, Prop->GetValue());
}
else if(Prop->GetID()=="require-accel"){
Doc->m_Settings->m_RequireAcceleration = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
else if(Prop->GetID()=="require-sound"){
Doc->m_Settings->m_RequireSound = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
else if(Prop->GetID()=="hwtl-mode"){
Doc->m_Settings->m_TLMode = ((CPLPropertyCombo*)Prop)->GetValueInt();
}
else if(Prop->GetID()=="use-d3d9"){
Doc->m_D3D9 = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
else if(Prop->GetID()=="allow-windowed"){
Doc->m_Settings->m_AllowWindowed = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
else if(Prop->GetID()=="allow-desktop-res"){
Doc->m_Settings->m_AllowDesktopRes = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
else if(Prop->GetID()=="allow-advanced"){
Doc->m_Settings->m_AllowAdvanced = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
else if(Prop->GetID()=="allow-access-tab"){
Doc->m_Settings->m_AllowAccessTab = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
else if(Prop->GetID()=="allow-about-tab"){
Doc->m_Settings->m_AllowAboutTab = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
}
//////////////////////////////////////////////////////////////////////////
else if(Cat->GetID()=="game"){
if(Prop->GetID()=="caption"){
Doc->Game->SetCaption((char*)LPCSTR(Prop->GetValue()));
}
else if(Prop->GetID()=="name"){
Doc->Game->SetName((char*)LPCSTR(Prop->GetValue()));
}
else if(Prop->GetID()=="subtitles"){
Doc->m_Settings->m_EdGame->m_Subtitles = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
else if(Prop->GetID()=="video-subtitles"){
Doc->m_Settings->m_EdGame->m_VideoSubtitles = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
else if(Prop->GetID()=="subtitles-speed"){
Doc->m_Settings->m_EdGame->m_SubtitlesSpeed = atoi(Prop->GetValue());
}
else if(Prop->GetID()=="talk-skip"){
if(Prop->GetValue()=="right") Doc->m_Settings->m_EdGame->m_TalkSkipButton = TALK_SKIP_RIGHT;
else if(Prop->GetValue()=="both") Doc->m_Settings->m_EdGame->m_TalkSkipButton = TALK_SKIP_BOTH;
else Doc->m_Settings->m_EdGame->m_TalkSkipButton = TALK_SKIP_LEFT;
}
}
//////////////////////////////////////////////////////////////////////////
else if(Cat->GetID()=="save"){
if(Prop->GetID()=="personal-save"){
Doc->m_Settings->m_EdGame->m_PersonalizedSave = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
else if(Prop->GetID()=="save-path"){
CBUtils::SetString(&Doc->m_Settings->m_EdGame->m_LocalSaveDir, (char*)LPCSTR(Prop->GetValue()));
}
else if(Prop->GetID()=="thumbnail-width"){
Doc->m_Settings->m_EdGame->m_ThumbnailWidth = atoi(Prop->GetValue());
}
else if(Prop->GetID()=="thumbnail-height"){
Doc->m_Settings->m_EdGame->m_ThumbnailHeight = atoi(Prop->GetValue());
}
else if(Prop->GetID()=="indicator-x"){
Doc->m_Settings->m_EdGame->m_IndicatorX = atoi(Prop->GetValue());
}
else if(Prop->GetID()=="indicator-y"){
Doc->m_Settings->m_EdGame->m_IndicatorY = atoi(Prop->GetValue());
}
else if(Prop->GetID()=="indicator-width"){
Doc->m_Settings->m_EdGame->m_IndicatorWidth = atoi(Prop->GetValue());
}
else if(Prop->GetID()=="indicator-height"){
Doc->m_Settings->m_EdGame->m_IndicatorHeight = atoi(Prop->GetValue());
}
else if(Prop->GetID()=="indicator-color"){
BYTE r, g, b;
CPLPropertyColor* ColProp = (CPLPropertyColor*)Prop;
ColProp->GetRGB(r, g, b);
Doc->m_Settings->m_EdGame->m_IndicatorColor = DRGBA(r, g, b, D3DCOLGetA(Doc->m_Settings->m_EdGame->m_IndicatorColor));
}
else if(Prop->GetID()=="indicator-alpha"){
Doc->m_Settings->m_EdGame->m_IndicatorColor = DRGBA(D3DCOLGetR(Doc->m_Settings->m_EdGame->m_IndicatorColor), D3DCOLGetG(Doc->m_Settings->m_EdGame->m_IndicatorColor), D3DCOLGetB(Doc->m_Settings->m_EdGame->m_IndicatorColor), atoi(Prop->GetValue()));
}
else if(Prop->GetID()=="save-ext"){
CBUtils::SetString(&Doc->m_Settings->m_SavedGameExt, (char*)LPCSTR(Prop->GetValue()));
}
else if(Prop->GetID()=="rich-save"){
Doc->m_Settings->m_RichSavedGames = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
}
//////////////////////////////////////////////////////////////////////////
else if(Cat->GetID()=="debug"){
if(Prop->GetID()=="debug-mode"){
Doc->m_DebugMode = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
else if(Prop->GetID()=="show-fps"){
Doc->m_ShowFPS = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
else if(Prop->GetID()=="allow-windowed"){
Doc->m_AllowWindowed = (((CPLPropertyCombo*)Prop)->GetValueInt()!=0);
}
else if(Prop->GetID()=="console-mode"){
Doc->m_ConsoleMode = ((CPLPropertyCombo*)Prop)->GetValueInt();
}
}
//////////////////////////////////////////////////////////////////////////
else if(Cat->GetID()=="package" && m_CurrentPackage){
if(Prop->GetID()=="description"){
m_CurrentPackage->m_Description = Prop->GetValue();
}
else if(Prop->GetID()=="cd"){
m_CurrentPackage->m_CD = atoi(Prop->GetValue());
}
else if(Prop->GetID()=="priority"){
m_CurrentPackage->m_Priority = atoi(Prop->GetValue());
}
}
}
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
HRESULT CAdItem::LoadBuffer(BYTE* Buffer, bool Complete)
{
TOKEN_TABLE_START(commands)
TOKEN_TABLE (ITEM)
TOKEN_TABLE (TEMPLATE)
TOKEN_TABLE (CURSOR_HOVER)
TOKEN_TABLE (CURSOR_COMBINED)
TOKEN_TABLE (CURSOR)
TOKEN_TABLE (NAME)
TOKEN_TABLE (IMAGE_HOVER)
TOKEN_TABLE (IMAGE)
TOKEN_TABLE (EVENTS)
TOKEN_TABLE (SCRIPT)
TOKEN_TABLE (CAPTION)
TOKEN_TABLE (PROPERTY)
TOKEN_TABLE (EDITOR_PROPERTY)
TOKEN_TABLE (FONT)
TOKEN_TABLE (ALPHA_COLOR)
TOKEN_TABLE (ALPHA)
TOKEN_TABLE (TALK_SPECIAL)
TOKEN_TABLE (TALK)
TOKEN_TABLE (SPRITE_HOVER)
TOKEN_TABLE (SPRITE)
TOKEN_TABLE (DISPLAY_AMOUNT)
TOKEN_TABLE (AMOUNT_OFFSET_X)
TOKEN_TABLE (AMOUNT_OFFSET_Y)
TOKEN_TABLE (AMOUNT_ALIGN)
TOKEN_TABLE (AMOUNT_STRING)
TOKEN_TABLE (AMOUNT)
TOKEN_TABLE_END
BYTE* params;
int cmd=2;
CBParser parser(Game);
if(Complete){
if(parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)!=TOKEN_ITEM){
Game->LOG(0, "'ITEM' keyword expected.");
return E_FAIL;
}
Buffer = params;
}
int ar=0, ag=0, ab=0, alpha=255;
while (cmd>0 && (cmd = parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)) > 0)
{
switch (cmd)
{
case TOKEN_TEMPLATE:
if(FAILED(LoadFile((char*)params))) cmd = PARSERR_GENERIC;
break;
case TOKEN_NAME:
SetName((char*)params);
break;
case TOKEN_FONT:
SetFont((char*)params);
break;
case TOKEN_CAPTION:
SetCaption((char*)params);
break;
case TOKEN_IMAGE:
case TOKEN_SPRITE:
SAFE_DELETE(m_Sprite);
m_Sprite = new CBSprite(Game, this);
if(!m_Sprite || FAILED(m_Sprite->LoadFile((char*)params, ((CAdGame*)Game)->m_TexItemLifeTime))){
SAFE_DELETE(m_Sprite);
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_IMAGE_HOVER:
case TOKEN_SPRITE_HOVER:
SAFE_DELETE(m_SpriteHover);
m_SpriteHover = new CBSprite(Game, this);
if(!m_SpriteHover || FAILED(m_SpriteHover->LoadFile((char*)params, ((CAdGame*)Game)->m_TexItemLifeTime))){
SAFE_DELETE(m_SpriteHover);
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_AMOUNT:
parser.ScanStr((char*)params, "%d", &m_Amount);
break;
case TOKEN_DISPLAY_AMOUNT:
parser.ScanStr((char*)params, "%b", &m_DisplayAmount);
break;
case TOKEN_AMOUNT_OFFSET_X:
parser.ScanStr((char*)params, "%d", &m_AmountOffsetX);
break;
case TOKEN_AMOUNT_OFFSET_Y:
parser.ScanStr((char*)params, "%d", &m_AmountOffsetY);
break;
case TOKEN_AMOUNT_ALIGN:
if(CBPlatform::stricmp((char*)params, "left")==0) m_AmountAlign = TAL_LEFT;
else if(CBPlatform::stricmp((char*)params, "right")==0) m_AmountAlign = TAL_RIGHT;
else m_AmountAlign = TAL_CENTER;
break;
case TOKEN_AMOUNT_STRING:
CBUtils::SetString(&m_AmountString, (char*)params);
break;
case TOKEN_TALK:
{
CBSprite* spr = new CBSprite(Game, this);
if(!spr || FAILED(spr->LoadFile((char*)params, ((CAdGame*)Game)->m_TexTalkLifeTime))) cmd = PARSERR_GENERIC;
else m_TalkSprites.Add(spr);
}
break;
case TOKEN_TALK_SPECIAL:
{
CBSprite* spr = new CBSprite(Game, this);
if(!spr || FAILED(spr->LoadFile((char*)params, ((CAdGame*)Game)->m_TexTalkLifeTime))) cmd = PARSERR_GENERIC;
else m_TalkSpritesEx.Add(spr);
}
break;
case TOKEN_CURSOR:
SAFE_DELETE(m_CursorNormal);
m_CursorNormal = new CBSprite(Game);
if(!m_CursorNormal || FAILED(m_CursorNormal->LoadFile((char*)params, ((CAdGame*)Game)->m_TexItemLifeTime))){
SAFE_DELETE(m_CursorNormal);
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_CURSOR_HOVER:
SAFE_DELETE(m_CursorHover);
m_CursorHover = new CBSprite(Game);
if(!m_CursorHover || FAILED(m_CursorHover->LoadFile((char*)params, ((CAdGame*)Game)->m_TexItemLifeTime))){
SAFE_DELETE(m_CursorHover);
cmd = PARSERR_GENERIC;
}
break;
case TOKEN_CURSOR_COMBINED:
parser.ScanStr((char*)params, "%b", &m_CursorCombined);
break;
case TOKEN_SCRIPT:
AddScript((char*)params);
break;
case TOKEN_PROPERTY:
ParseProperty(params, false);
break;
case TOKEN_ALPHA_COLOR:
parser.ScanStr((char*)params, "%d,%d,%d", &ar, &ag, &ab);
break;
case TOKEN_ALPHA:
parser.ScanStr((char*)params, "%d", &alpha);
break;
case TOKEN_EDITOR_PROPERTY:
ParseEditorProperty(params, false);
break;
}
}
if (cmd == PARSERR_TOKENNOTFOUND){
Game->LOG(0, "Syntax error in ITEM definition");
return E_FAIL;
}
if (cmd == PARSERR_GENERIC){
Game->LOG(0, "Error loading ITEM definition");
return E_FAIL;
}
if(alpha != 0 && ar==0 && ag == 0 && ab == 0){
ar = ag = ab = 255;
}
m_AlphaColor = DRGBA(ar, ag, ab, alpha);
return S_OK;
}
