TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// bool CBFont::IsTrueType(CBGame* Game, char* Filename) { TOKEN_TABLE_START(commands) TOKEN_TABLE (FONT) TOKEN_TABLE (TTFONT) TOKEN_TABLE_END BYTE* Buffer = Game->m_FileManager->ReadWholeFile(Filename); if(Buffer==NULL) return false; BYTE* WorkBuffer = Buffer; char* params; CBParser parser(Game); bool Ret = false; if(parser.GetCommand ((char**)&WorkBuffer, commands, (char**)¶ms)==TOKEN_TTFONT) Ret = true; delete [] Buffer; return Ret; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// bool AdScaleLevel::loadBuffer(byte *buffer, bool complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(SCALE_LEVEL) TOKEN_TABLE(TEMPLATE) TOKEN_TABLE(Y) TOKEN_TABLE(SCALE) TOKEN_TABLE(EDITOR_PROPERTY) TOKEN_TABLE_END byte *params; int cmd; BaseParser parser; if (complete) { if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_SCALE_LEVEL) { _gameRef->LOG(0, "'SCALE_LEVEL' keyword expected."); return STATUS_FAILED; } buffer = params; } while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) { switch (cmd) { case TOKEN_TEMPLATE: if (DID_FAIL(loadFile((char *)params))) { cmd = PARSERR_GENERIC; } break; case TOKEN_Y: parser.scanStr((char *)params, "%d", &_posY); break; case TOKEN_SCALE: { int i; parser.scanStr((char *)params, "%d", &i); _scale = (float)i; } break; case TOKEN_EDITOR_PROPERTY: parseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { _gameRef->LOG(0, "Syntax error in SCALE_LEVEL definition"); return STATUS_FAILED; } return STATUS_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// HRESULT CBEvent::LoadBuffer(BYTE * Buffer, bool Complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE (EVENT) TOKEN_TABLE (NAME) TOKEN_TABLE (SCRIPT) TOKEN_TABLE_END BYTE* params; int cmd; CBParser parser(Game); if(Complete){ if(parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)!=TOKEN_EVENT){ Game->LOG(0, "'EVENT' keyword expected."); return E_FAIL; } Buffer = params; } while ((cmd = parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)) > 0) { switch (cmd) { case TOKEN_NAME: SetName((char*)params); break; case TOKEN_SCRIPT: SetScript((char*)params); break; } } if (cmd == PARSERR_TOKENNOTFOUND){ Game->LOG(0, "Syntax error in EVENT definition"); return E_FAIL; } return S_OK; }
HRESULT CAdActor::MergeAnims(char* AnimsFilename) { TOKEN_TABLE_START(commands) TOKEN_TABLE (ANIMATION) TOKEN_TABLE_END BYTE* FileBuffer = Game->m_FileManager->ReadWholeFile(AnimsFilename); if(FileBuffer==NULL) { Game->LOG(0, "CAdActor::MergeAnims failed for file '%s'", AnimsFilename); return E_FAIL; } BYTE* Buffer = FileBuffer; BYTE* params; int cmd; CBParser parser(Game); HRESULT Ret = S_OK; while ((cmd = parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)) > 0) { switch (cmd) { case TOKEN_ANIMATION: { CAdSpriteSet* Anim = new CAdSpriteSet(Game, this); if(!Anim || FAILED(Anim->LoadBuffer(params, false))) { cmd = PARSERR_GENERIC; Ret = E_FAIL; } else m_Anims.Add(Anim); } break; } } delete [] FileBuffer; return Ret; }
bool AdActor::mergeAnims(const char *animsFilename) { TOKEN_TABLE_START(commands) TOKEN_TABLE(ANIMATION) TOKEN_TABLE_END byte *fileBuffer = BaseFileManager::getEngineInstance()->readWholeFile(animsFilename); if (fileBuffer == nullptr) { _gameRef->LOG(0, "AdActor::MergeAnims failed for file '%s'", animsFilename); return STATUS_FAILED; } byte *buffer = fileBuffer; byte *params; int cmd; BaseParser parser; bool ret = STATUS_OK; while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) { switch (cmd) { case TOKEN_ANIMATION: { AdSpriteSet *anim = new AdSpriteSet(_gameRef, this); if (!anim || DID_FAIL(anim->loadBuffer(params, false))) { cmd = PARSERR_GENERIC; ret = STATUS_FAILED; } else { _anims.add(anim); } } break; } } delete[] fileBuffer; return ret; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// HRESULT CAdSpriteSet::LoadBuffer(BYTE * Buffer, bool Complete, int LifeTime, TSpriteCacheType CacheType) { TOKEN_TABLE_START(commands) TOKEN_TABLE (SPRITESET) TOKEN_TABLE (NAME) TOKEN_TABLE (UP_LEFT) TOKEN_TABLE (DOWN_LEFT) TOKEN_TABLE (LEFT) TOKEN_TABLE (UP_RIGHT) TOKEN_TABLE (DOWN_RIGHT) TOKEN_TABLE (RIGHT) TOKEN_TABLE (UP) TOKEN_TABLE (DOWN) TOKEN_TABLE (TEMPLATE) 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_SPRITESET) { Game->LOG(0, "'SPRITESET' keyword expected."); return E_FAIL; } Buffer = params; } CBSprite* spr=NULL; while ((cmd = parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)) > 0) { switch (cmd) { case TOKEN_TEMPLATE: if(FAILED(LoadFile((char*)params, LifeTime, CacheType))) cmd = PARSERR_GENERIC; break; case TOKEN_NAME: SetName((char*)params); break; case TOKEN_LEFT: SAFE_DELETE(m_Sprites[DI_LEFT]); spr = new CBSprite(Game, m_Owner); if(!spr || FAILED(spr->LoadFile((char*)params, LifeTime, CacheType))) cmd = PARSERR_GENERIC; else m_Sprites[DI_LEFT] = spr; break; case TOKEN_RIGHT: SAFE_DELETE(m_Sprites[DI_RIGHT]); spr = new CBSprite(Game, m_Owner); if(!spr || FAILED(spr->LoadFile((char*)params, LifeTime, CacheType))) cmd = PARSERR_GENERIC; else m_Sprites[DI_RIGHT] = spr; break; case TOKEN_UP: SAFE_DELETE(m_Sprites[DI_UP]); spr = new CBSprite(Game, m_Owner); if(!spr || FAILED(spr->LoadFile((char*)params, LifeTime, CacheType))) cmd = PARSERR_GENERIC; else m_Sprites[DI_UP] = spr; break; case TOKEN_DOWN: SAFE_DELETE(m_Sprites[DI_DOWN]); spr = new CBSprite(Game, m_Owner); if(!spr || FAILED(spr->LoadFile((char*)params, LifeTime, CacheType))) cmd = PARSERR_GENERIC; else m_Sprites[DI_DOWN] = spr; break; case TOKEN_UP_LEFT: SAFE_DELETE(m_Sprites[DI_UPLEFT]); spr = new CBSprite(Game, m_Owner); if(!spr || FAILED(spr->LoadFile((char*)params, LifeTime, CacheType))) cmd = PARSERR_GENERIC; else m_Sprites[DI_UPLEFT] = spr; break; case TOKEN_UP_RIGHT: SAFE_DELETE(m_Sprites[DI_UPRIGHT]); spr = new CBSprite(Game, m_Owner); if(!spr || FAILED(spr->LoadFile((char*)params, LifeTime, CacheType))) cmd = PARSERR_GENERIC; else m_Sprites[DI_UPRIGHT] = spr; break; case TOKEN_DOWN_LEFT: SAFE_DELETE(m_Sprites[DI_DOWNLEFT]); spr = new CBSprite(Game, m_Owner); if(!spr || FAILED(spr->LoadFile((char*)params, LifeTime, CacheType))) cmd = PARSERR_GENERIC; else m_Sprites[DI_DOWNLEFT] = spr; break; case TOKEN_DOWN_RIGHT: SAFE_DELETE(m_Sprites[DI_DOWNRIGHT]); spr = new CBSprite(Game, m_Owner); if(!spr || FAILED(spr->LoadFile((char*)params, LifeTime, CacheType))) cmd = PARSERR_GENERIC; else m_Sprites[DI_DOWNRIGHT] = spr; break; case TOKEN_EDITOR_PROPERTY: ParseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { Game->LOG(0, "Syntax error in SPRITESET definition"); return E_FAIL; } if (cmd == PARSERR_GENERIC) { Game->LOG(0, "Error loading SPRITESET definition"); if(spr) delete spr; return E_FAIL; } return S_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// HRESULT CAdTalkDef::LoadBuffer(byte *Buffer, bool Complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(TALK) TOKEN_TABLE(TEMPLATE) TOKEN_TABLE(ACTION) TOKEN_TABLE(DEFAULT_SPRITESET_FILE) TOKEN_TABLE(DEFAULT_SPRITESET) TOKEN_TABLE(DEFAULT_SPRITE) 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_TALK) { Game->LOG(0, "'TALK' keyword expected."); return E_FAIL; } Buffer = params; } 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_ACTION: { CAdTalkNode *Node = new CAdTalkNode(Game); if (Node && SUCCEEDED(Node->LoadBuffer(params, false))) m_Nodes.Add(Node); else { delete Node; Node = NULL; cmd = PARSERR_GENERIC; } } break; case TOKEN_DEFAULT_SPRITE: CBUtils::SetString(&m_DefaultSpriteFilename, (char *)params); break; case TOKEN_DEFAULT_SPRITESET_FILE: CBUtils::SetString(&m_DefaultSpriteSetFilename, (char *)params); break; case TOKEN_DEFAULT_SPRITESET: { delete m_DefaultSpriteSet; m_DefaultSpriteSet = new CAdSpriteSet(Game); if (!m_DefaultSpriteSet || FAILED(m_DefaultSpriteSet->LoadBuffer(params, false))) { delete m_DefaultSpriteSet; m_DefaultSpriteSet = NULL; cmd = PARSERR_GENERIC; } } break; case TOKEN_EDITOR_PROPERTY: ParseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { Game->LOG(0, "Syntax error in TALK definition"); return E_FAIL; } if (cmd == PARSERR_GENERIC) { Game->LOG(0, "Error loading TALK definition"); return E_FAIL; } delete m_DefaultSprite; delete m_DefaultSpriteSet; m_DefaultSprite = NULL; m_DefaultSpriteSet = NULL; if (m_DefaultSpriteFilename) { m_DefaultSprite = new CBSprite(Game); if (!m_DefaultSprite || FAILED(m_DefaultSprite->LoadFile(m_DefaultSpriteFilename))) return E_FAIL; } if (m_DefaultSpriteSetFilename) { m_DefaultSpriteSet = new CAdSpriteSet(Game); if (!m_DefaultSpriteSet || FAILED(m_DefaultSpriteSet->LoadFile(m_DefaultSpriteSetFilename))) return E_FAIL; } return S_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// HRESULT CUITiledImage::LoadBuffer(byte *Buffer, bool Complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(TILED_IMAGE) TOKEN_TABLE(TEMPLATE) TOKEN_TABLE(IMAGE) TOKEN_TABLE(UP_LEFT) TOKEN_TABLE(UP_RIGHT) TOKEN_TABLE(UP_MIDDLE) TOKEN_TABLE(DOWN_LEFT) TOKEN_TABLE(DOWN_RIGHT) TOKEN_TABLE(DOWN_MIDDLE) TOKEN_TABLE(MIDDLE_LEFT) TOKEN_TABLE(MIDDLE_RIGHT) TOKEN_TABLE(MIDDLE_MIDDLE) TOKEN_TABLE(VERTICAL_TILES) TOKEN_TABLE(HORIZONTAL_TILES) TOKEN_TABLE(EDITOR_PROPERTY) TOKEN_TABLE_END byte *params; int cmd; CBParser parser(Game); bool HTiles = false, VTiles = false; int H1 = 0, H2 = 0, H3 = 0; int V1 = 0, V2 = 0, V3 = 0; if (Complete) { if (parser.GetCommand((char **)&Buffer, commands, (char **)¶ms) != TOKEN_TILED_IMAGE) { Game->LOG(0, "'TILED_IMAGE' keyword expected."); return E_FAIL; } Buffer = params; } 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_IMAGE: SAFE_DELETE(m_Image); m_Image = new CBSubFrame(Game); if (!m_Image || FAILED(m_Image->SetSurface((char *)params))) { SAFE_DELETE(m_Image); cmd = PARSERR_GENERIC; } break; case TOKEN_UP_LEFT: parser.ScanStr((char *)params, "%d,%d,%d,%d", &m_UpLeft.left, &m_UpLeft.top, &m_UpLeft.right, &m_UpLeft.bottom); break; case TOKEN_UP_RIGHT: parser.ScanStr((char *)params, "%d,%d,%d,%d", &m_UpRight.left, &m_UpRight.top, &m_UpRight.right, &m_UpRight.bottom); break; case TOKEN_UP_MIDDLE: parser.ScanStr((char *)params, "%d,%d,%d,%d", &m_UpMiddle.left, &m_UpMiddle.top, &m_UpMiddle.right, &m_UpMiddle.bottom); break; case TOKEN_DOWN_LEFT: parser.ScanStr((char *)params, "%d,%d,%d,%d", &m_DownLeft.left, &m_DownLeft.top, &m_DownLeft.right, &m_DownLeft.bottom); break; case TOKEN_DOWN_RIGHT: parser.ScanStr((char *)params, "%d,%d,%d,%d", &m_DownRight.left, &m_DownRight.top, &m_DownRight.right, &m_DownRight.bottom); break; case TOKEN_DOWN_MIDDLE: parser.ScanStr((char *)params, "%d,%d,%d,%d", &m_DownMiddle.left, &m_DownMiddle.top, &m_DownMiddle.right, &m_DownMiddle.bottom); break; case TOKEN_MIDDLE_LEFT: parser.ScanStr((char *)params, "%d,%d,%d,%d", &m_MiddleLeft.left, &m_MiddleLeft.top, &m_MiddleLeft.right, &m_MiddleLeft.bottom); break; case TOKEN_MIDDLE_RIGHT: parser.ScanStr((char *)params, "%d,%d,%d,%d", &m_MiddleRight.left, &m_MiddleRight.top, &m_MiddleRight.right, &m_MiddleRight.bottom); break; case TOKEN_MIDDLE_MIDDLE: parser.ScanStr((char *)params, "%d,%d,%d,%d", &m_MiddleMiddle.left, &m_MiddleMiddle.top, &m_MiddleMiddle.right, &m_MiddleMiddle.bottom); break; case TOKEN_HORIZONTAL_TILES: parser.ScanStr((char *)params, "%d,%d,%d", &H1, &H2, &H3); HTiles = true; break; case TOKEN_VERTICAL_TILES: parser.ScanStr((char *)params, "%d,%d,%d", &V1, &V2, &V3); VTiles = true; break; case TOKEN_EDITOR_PROPERTY: ParseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { Game->LOG(0, "Syntax error in TILED_IMAGE definition"); return E_FAIL; } if (cmd == PARSERR_GENERIC) { Game->LOG(0, "Error loading TILED_IMAGE definition"); return E_FAIL; } if (VTiles && HTiles) { // up row CBPlatform::SetRect(&m_UpLeft, 0, 0, H1, V1); CBPlatform::SetRect(&m_UpMiddle, H1, 0, H1 + H2, V1); CBPlatform::SetRect(&m_UpRight, H1 + H2, 0, H1 + H2 + H3, V1); // middle row CBPlatform::SetRect(&m_MiddleLeft, 0, V1, H1, V1 + V2); CBPlatform::SetRect(&m_MiddleMiddle, H1, V1, H1 + H2, V1 + V2); CBPlatform::SetRect(&m_MiddleRight, H1 + H2, V1, H1 + H2 + H3, V1 + V2); // down row CBPlatform::SetRect(&m_DownLeft, 0, V1 + V2, H1, V1 + V2 + V3); CBPlatform::SetRect(&m_DownMiddle, H1, V1 + V2, H1 + H2, V1 + V2 + V3); CBPlatform::SetRect(&m_DownRight, H1 + H2, V1 + V2, H1 + H2 + H3, V1 + V2 + V3); } // default if (m_Image && m_Image->m_Surface) { int Width = m_Image->m_Surface->GetWidth() / 3; int Height = m_Image->m_Surface->GetHeight() / 3; if (CBPlatform::IsRectEmpty(&m_UpLeft)) CBPlatform::SetRect(&m_UpLeft, 0, 0, Width, Height); if (CBPlatform::IsRectEmpty(&m_UpMiddle)) CBPlatform::SetRect(&m_UpMiddle, Width, 0, 2 * Width, Height); if (CBPlatform::IsRectEmpty(&m_UpRight)) CBPlatform::SetRect(&m_UpRight, 2 * Width, 0, 3 * Width, Height); if (CBPlatform::IsRectEmpty(&m_MiddleLeft)) CBPlatform::SetRect(&m_MiddleLeft, 0, Height, Width, 2 * Height); if (CBPlatform::IsRectEmpty(&m_MiddleMiddle)) CBPlatform::SetRect(&m_MiddleMiddle, Width, Height, 2 * Width, 2 * Height); if (CBPlatform::IsRectEmpty(&m_MiddleRight)) CBPlatform::SetRect(&m_MiddleRight, 2 * Width, Height, 3 * Width, 2 * Height); if (CBPlatform::IsRectEmpty(&m_DownLeft)) CBPlatform::SetRect(&m_DownLeft, 0, 2 * Height, Width, 3 * Height); if (CBPlatform::IsRectEmpty(&m_DownMiddle)) CBPlatform::SetRect(&m_DownMiddle, Width, 2 * Height, 2 * Width, 3 * Height); if (CBPlatform::IsRectEmpty(&m_DownRight)) CBPlatform::SetRect(&m_DownRight, 2 * Width, 2 * Height, 3 * Width, 3 * Height); } return S_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// HRESULT CAdInventoryBox::LoadBuffer(BYTE* Buffer, bool Complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE (INVENTORY_BOX) TOKEN_TABLE (TEMPLATE) TOKEN_TABLE (WINDOW) TOKEN_TABLE (EXCLUSIVE) TOKEN_TABLE (ALWAYS_VISIBLE) TOKEN_TABLE (AREA) TOKEN_TABLE (SPACING) TOKEN_TABLE (ITEM_WIDTH) TOKEN_TABLE (ITEM_HEIGHT) TOKEN_TABLE (SCROLL_BY) TOKEN_TABLE (NAME) TOKEN_TABLE (CAPTION) TOKEN_TABLE (HIDE_SELECTED) TOKEN_TABLE (EDITOR_PROPERTY) TOKEN_TABLE_END BYTE* params; int cmd=2; CBParser parser(Game); bool always_visible=false; m_Exclusive = false; if(Complete) { if(parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)!=TOKEN_INVENTORY_BOX) { Game->LOG(0, "'INVENTORY_BOX' keyword expected."); return E_FAIL; } Buffer = params; } 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_CAPTION: SetCaption((char*)params); break; case TOKEN_WINDOW: SAFE_DELETE(m_Window); m_Window = new CUIWindow(Game); if(!m_Window || FAILED(m_Window->LoadBuffer(params, false))) { SAFE_DELETE(m_Window); cmd = PARSERR_GENERIC; } else Game->RegisterObject(m_Window); break; case TOKEN_AREA: parser.ScanStr((char*)params, "%d,%d,%d,%d", &m_ItemsArea.left, &m_ItemsArea.top, &m_ItemsArea.right, &m_ItemsArea.bottom); break; case TOKEN_EXCLUSIVE: parser.ScanStr((char*)params, "%b", &m_Exclusive); break; case TOKEN_HIDE_SELECTED: parser.ScanStr((char*)params, "%b", &m_HideSelected); break; case TOKEN_ALWAYS_VISIBLE: parser.ScanStr((char*)params, "%b", &always_visible); break; case TOKEN_SPACING: parser.ScanStr((char*)params, "%d", &m_Spacing); break; case TOKEN_ITEM_WIDTH: parser.ScanStr((char*)params, "%d", &m_ItemWidth); break; case TOKEN_ITEM_HEIGHT: parser.ScanStr((char*)params, "%d", &m_ItemHeight); break; case TOKEN_SCROLL_BY: parser.ScanStr((char*)params, "%d", &m_ScrollBy); break; case TOKEN_EDITOR_PROPERTY: ParseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { Game->LOG(0, "Syntax error in INVENTORY_BOX definition"); return E_FAIL; } if (cmd == PARSERR_GENERIC) { Game->LOG(0, "Error loading INVENTORY_BOX definition"); return E_FAIL; } if(m_Exclusive) { SAFE_DELETE(m_CloseButton); m_CloseButton = new CUIButton(Game); if(m_CloseButton) { m_CloseButton->SetName("close"); m_CloseButton->SetListener(this, m_CloseButton, 0); m_CloseButton->m_Parent = m_Window; } } m_Visible = always_visible; if(m_Window) { for(int i=0; i<m_Window->m_Widgets.GetSize(); i++) { if(!m_Window->m_Widgets[i]->m_ListenerObject) m_Window->m_Widgets[i]->SetListener(this, m_Window->m_Widgets[i], 0); } } return S_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////// HRESULT CBSprite::LoadBuffer(BYTE* Buffer, bool Complete, int LifeTime, TSpriteCacheType CacheType) { TOKEN_TABLE_START(commands) TOKEN_TABLE (CONTINUOUS) TOKEN_TABLE (SPRITE) TOKEN_TABLE (LOOPING) TOKEN_TABLE (FRAME) TOKEN_TABLE (NAME) TOKEN_TABLE (PRECISE) TOKEN_TABLE (EDITOR_MUTED) TOKEN_TABLE (STREAMED_KEEP_LOADED) TOKEN_TABLE (STREAMED) TOKEN_TABLE (SCRIPT) TOKEN_TABLE (EDITOR_BG_FILE) TOKEN_TABLE (EDITOR_BG_OFFSET_X) TOKEN_TABLE (EDITOR_BG_OFFSET_Y) TOKEN_TABLE (EDITOR_BG_ALPHA) TOKEN_TABLE (EDITOR_PROPERTY) TOKEN_TABLE_END BYTE* params; int cmd; CBParser parser(Game); Cleanup(); if(Complete) { if(parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)!=TOKEN_SPRITE) { Game->LOG(0, "'SPRITE' keyword expected."); return E_FAIL; } Buffer = params; } int frame_count = 1; CBFrame* frame; while ((cmd = parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)) > 0) { switch (cmd) { case TOKEN_CONTINUOUS: parser.ScanStr((char*)params, "%b", &m_Continuous); break; case TOKEN_EDITOR_MUTED: parser.ScanStr((char*)params, "%b", &m_EditorMuted); break; case TOKEN_SCRIPT: AddScript((char*)params); break; case TOKEN_LOOPING: parser.ScanStr((char*)params, "%b", &m_Looping); break; case TOKEN_PRECISE: parser.ScanStr((char*)params, "%b", &m_Precise); break; case TOKEN_STREAMED: parser.ScanStr((char*)params, "%b", &m_Streamed); if(m_Streamed && LifeTime==-1) { LifeTime = 500; CacheType = CACHE_ALL; } break; case TOKEN_STREAMED_KEEP_LOADED: parser.ScanStr((char*)params, "%b", &m_StreamedKeepLoaded); break; case TOKEN_NAME: SetName((char*)params); break; case TOKEN_EDITOR_BG_FILE: if(Game->m_EditorMode) { SAFE_DELETE_ARRAY(m_EditorBgFile); m_EditorBgFile = new char[strlen((char*)params)+1]; if(m_EditorBgFile) strcpy(m_EditorBgFile, (char*)params); } break; case TOKEN_EDITOR_BG_OFFSET_X: parser.ScanStr((char*)params, "%d", &m_EditorBgOffsetX); break; case TOKEN_EDITOR_BG_OFFSET_Y: parser.ScanStr((char*)params, "%d", &m_EditorBgOffsetY); break; case TOKEN_EDITOR_BG_ALPHA: parser.ScanStr((char*)params, "%d", &m_EditorBgAlpha); m_EditorBgAlpha = min(m_EditorBgAlpha, 255); m_EditorBgAlpha = max(m_EditorBgAlpha, 0); break; case TOKEN_FRAME: { int FrameLifeTime = LifeTime; if(CacheType==CACHE_HALF && frame_count%2!=1) FrameLifeTime = -1; frame = new CBFrame(Game); if(FAILED(frame->LoadBuffer(params, FrameLifeTime, m_StreamedKeepLoaded))) { delete frame; Game->LOG(0, "Error parsing frame %d", frame_count); return E_FAIL; } m_Frames.Add(frame); frame_count++; if(m_CurrentFrame==-1) m_CurrentFrame = 0; } break; case TOKEN_EDITOR_PROPERTY: ParseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { Game->LOG(0, "Syntax error in SPRITE definition"); return E_FAIL; } m_CanBreak = !m_Continuous; return S_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// HRESULT CBScriptHolder::ParseProperty(BYTE * Buffer, bool Complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE (PROPERTY) TOKEN_TABLE (NAME) TOKEN_TABLE (VALUE) TOKEN_TABLE_END BYTE* params; int cmd; CBParser parser(Game); if(Complete) { if(parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)!=TOKEN_PROPERTY) { Game->LOG(0, "'PROPERTY' keyword expected."); return E_FAIL; } Buffer = params; } char* PropName=NULL; char* PropValue=NULL; while ((cmd = parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)) > 0) { switch (cmd) { case TOKEN_NAME: SAFE_DELETE_ARRAY(PropName); PropName = new char[strlen((char*)params)+1]; if(PropName) strcpy(PropName, (char*)params); else cmd = PARSERR_GENERIC; break; case TOKEN_VALUE: SAFE_DELETE_ARRAY(PropValue); PropValue = new char[strlen((char*)params)+1]; if(PropValue) strcpy(PropValue, (char*)params); else cmd = PARSERR_GENERIC; break; } } if (cmd == PARSERR_TOKENNOTFOUND) { SAFE_DELETE_ARRAY(PropName); SAFE_DELETE_ARRAY(PropValue); Game->LOG(0, "Syntax error in PROPERTY definition"); return E_FAIL; } if (cmd == PARSERR_GENERIC || PropName==NULL || PropValue==NULL) { SAFE_DELETE_ARRAY(PropName); SAFE_DELETE_ARRAY(PropValue); Game->LOG(0, "Error loading PROPERTY definition"); return E_FAIL; } CScValue* val = new CScValue(Game); val->SetString(PropValue); ScSetProperty(PropName, val); delete val; SAFE_DELETE_ARRAY(PropName); SAFE_DELETE_ARRAY(PropValue); return S_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// bool AdRegion::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; BaseParser parser; if (complete) { if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_REGION) { _gameRef->LOG(0, "'REGION' keyword expected."); return STATUS_FAILED; } buffer = params; } for (uint32 i = 0; i < _points.size(); i++) { delete _points[i]; } _points.clear(); 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 (DID_FAIL(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", &_active); break; case TOKEN_BLOCKED: parser.scanStr((char *)params, "%b", &_blocked); break; case TOKEN_DECORATION: parser.scanStr((char *)params, "%b", &_decoration); break; case TOKEN_ZOOM: case TOKEN_SCALE: { int j; parser.scanStr((char *)params, "%d", &j); _zoom = (float)j; } break; case TOKEN_POINT: { int x, y; parser.scanStr((char *)params, "%d,%d", &x, &y); _points.add(new BasePoint(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", &_editorSelected); break; case TOKEN_EDITOR_SELECTED_POINT: parser.scanStr((char *)params, "%d", &_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) { _gameRef->LOG(0, "Syntax error in REGION definition"); return STATUS_FAILED; } createRegion(); _alpha = BYTETORGBA(ar, ag, ab, alpha); return STATUS_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// bool UIEntity::loadBuffer(byte *buffer, bool complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(ENTITY_CONTAINER) TOKEN_TABLE(TEMPLATE) TOKEN_TABLE(DISABLED) TOKEN_TABLE(VISIBLE) TOKEN_TABLE(X) TOKEN_TABLE(Y) TOKEN_TABLE(NAME) TOKEN_TABLE(ENTITY) TOKEN_TABLE(SCRIPT) TOKEN_TABLE(EDITOR_PROPERTY) TOKEN_TABLE_END byte *params; int cmd = 2; BaseParser parser; if (complete) { if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_ENTITY_CONTAINER) { _gameRef->LOG(0, "'ENTITY_CONTAINER' keyword expected."); return STATUS_FAILED; } buffer = params; } while (cmd > 0 && (cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) { switch (cmd) { case TOKEN_TEMPLATE: if (DID_FAIL(loadFile((char *)params))) { cmd = PARSERR_GENERIC; } break; case TOKEN_NAME: setName((char *)params); break; case TOKEN_X: parser.scanStr((char *)params, "%d", &_posX); break; case TOKEN_Y: parser.scanStr((char *)params, "%d", &_posY); break; case TOKEN_DISABLED: parser.scanStr((char *)params, "%b", &_disable); break; case TOKEN_VISIBLE: parser.scanStr((char *)params, "%b", &_visible); break; case TOKEN_ENTITY: if (DID_FAIL(setEntity((char *)params))) { cmd = PARSERR_GENERIC; } break; case TOKEN_SCRIPT: addScript((char *)params); break; case TOKEN_EDITOR_PROPERTY: parseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { _gameRef->LOG(0, "Syntax error in ENTITY_CONTAINER definition"); return STATUS_FAILED; } if (cmd == PARSERR_GENERIC) { _gameRef->LOG(0, "Error loading ENTITY_CONTAINER definition"); return STATUS_FAILED; } correctSize(); if (_gameRef->_editorMode) { _width = 50; _height = 50; } return STATUS_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// bool BaseGameSettings::loadSettings(const char *filename) { TOKEN_TABLE_START(commands) TOKEN_TABLE(SETTINGS) TOKEN_TABLE(GAME) TOKEN_TABLE(STRING_TABLE) TOKEN_TABLE(RESOLUTION) TOKEN_TABLE(REQUIRE_3D_ACCELERATION) TOKEN_TABLE(REQUIRE_SOUND) TOKEN_TABLE(HWTL_MODE) TOKEN_TABLE(ALLOW_WINDOWED_MODE) TOKEN_TABLE(ALLOW_ACCESSIBILITY_TAB) TOKEN_TABLE(ALLOW_ABOUT_TAB) TOKEN_TABLE(ALLOW_ADVANCED) TOKEN_TABLE(ALLOW_DESKTOP_RES) TOKEN_TABLE(REGISTRY_PATH) TOKEN_TABLE(RICH_SAVED_GAMES) TOKEN_TABLE(SAVED_GAME_EXT) TOKEN_TABLE(GUID) TOKEN_TABLE_END byte *origBuffer = BaseFileManager::getEngineInstance()->readWholeFile(filename); if (origBuffer == nullptr) { BaseEngine::LOG(0, "BaseGame::LoadSettings failed for file '%s'", filename); return STATUS_FAILED; } bool ret = STATUS_OK; byte *buffer = origBuffer; byte *params; int cmd; BaseParser parser; if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_SETTINGS) { BaseEngine::LOG(0, "'SETTINGS' keyword expected in game settings file."); return STATUS_FAILED; } buffer = params; while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) { switch (cmd) { case TOKEN_GAME: delete[] _gameFile; _gameFile = new char[strlen((char *)params) + 1]; if (_gameFile) { strcpy(_gameFile, (char *)params); } break; case TOKEN_STRING_TABLE: if (DID_FAIL(_stringTable->loadFile((char *)params))) { cmd = PARSERR_GENERIC; } break; case TOKEN_RESOLUTION: parser.scanStr((char *)params, "%d,%d", &_resWidth, &_resHeight); break; case TOKEN_REQUIRE_3D_ACCELERATION: parser.scanStr((char *)params, "%b", &_requireAcceleration); break; case TOKEN_REQUIRE_SOUND: parser.scanStr((char *)params, "%b", &_requireSound); break; case TOKEN_HWTL_MODE: parser.scanStr((char *)params, "%d", &_TLMode); break; case TOKEN_ALLOW_WINDOWED_MODE: parser.scanStr((char *)params, "%b", &_allowWindowed); break; case TOKEN_ALLOW_DESKTOP_RES: parser.scanStr((char *)params, "%b", &_allowDesktopRes); break; case TOKEN_ALLOW_ADVANCED: parser.scanStr((char *)params, "%b", &_allowAdvanced); break; case TOKEN_ALLOW_ACCESSIBILITY_TAB: parser.scanStr((char *)params, "%b", &_allowAccessTab); break; case TOKEN_ALLOW_ABOUT_TAB: parser.scanStr((char *)params, "%b", &_allowAboutTab); break; case TOKEN_REGISTRY_PATH: //BaseEngine::instance().getRegistry()->setBasePath((char *)params); break; case TOKEN_RICH_SAVED_GAMES: parser.scanStr((char *)params, "%b", &_richSavedGames); break; case TOKEN_SAVED_GAME_EXT: _savedGameExt = (char *)params; break; case TOKEN_GUID: break; } } if (cmd == PARSERR_TOKENNOTFOUND) { BaseEngine::LOG(0, "Syntax error in game settings '%s'", filename); ret = STATUS_FAILED; } if (cmd == PARSERR_GENERIC) { BaseEngine::LOG(0, "Error loading game settings '%s'", filename); ret = STATUS_FAILED; } _allowWindowed = true; // TODO: These two settings should probably be cleaned out altogether. _compressedSavegames = true; delete[] origBuffer; return ret; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// HRESULT CAdWaypointGroup::LoadBuffer(BYTE * Buffer, bool Complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE (WAYPOINTS) TOKEN_TABLE (TEMPLATE) TOKEN_TABLE (NAME) TOKEN_TABLE (POINT) TOKEN_TABLE (EDITOR_SELECTED_POINT) TOKEN_TABLE (EDITOR_SELECTED) 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_WAYPOINTS){ Game->LOG(0, "'WAYPOINTS' keyword expected."); return E_FAIL; } Buffer = params; } 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_POINT: { int x,y; parser.ScanStr((char*)params, "%d,%d", &x, &y); m_Points.Add(new CBPoint(x, y)); } 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_PROPERTY: ParseProperty(params, false); break; case TOKEN_EDITOR_PROPERTY: ParseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND){ Game->LOG(0, "Syntax error in WAYPOINTS definition"); return E_FAIL; } return S_OK; }
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; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// bool UIText::loadBuffer(byte *buffer, bool complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(STATIC) TOKEN_TABLE(TEMPLATE) TOKEN_TABLE(DISABLED) TOKEN_TABLE(VISIBLE) TOKEN_TABLE(BACK) TOKEN_TABLE(IMAGE) TOKEN_TABLE(FONT) TOKEN_TABLE(TEXT_ALIGN) TOKEN_TABLE(VERTICAL_ALIGN) TOKEN_TABLE(TEXT) TOKEN_TABLE(X) TOKEN_TABLE(Y) TOKEN_TABLE(WIDTH) TOKEN_TABLE(HEIGHT) TOKEN_TABLE(CURSOR) TOKEN_TABLE(NAME) TOKEN_TABLE(SCRIPT) TOKEN_TABLE(CAPTION) TOKEN_TABLE(PARENT_NOTIFY) TOKEN_TABLE(EDITOR_PROPERTY) TOKEN_TABLE_END byte *params; int cmd = 2; BaseParser parser; if (complete) { if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_STATIC) { _gameRef->LOG(0, "'STATIC' keyword expected."); return STATUS_FAILED; } buffer = params; } while (cmd > 0 && (cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) { switch (cmd) { case TOKEN_TEMPLATE: if (DID_FAIL(loadFile((char *)params))) { cmd = PARSERR_GENERIC; } break; case TOKEN_NAME: setName((char *)params); break; case TOKEN_CAPTION: setCaption((char *)params); break; case TOKEN_BACK: delete _back; _back = new UITiledImage(_gameRef); if (!_back || DID_FAIL(_back->loadFile((char *)params))) { delete _back; _back = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_IMAGE: delete _image; _image = new BaseSprite(_gameRef); if (!_image || DID_FAIL(_image->loadFile((char *)params))) { delete _image; _image = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_FONT: if (_font) { _gameRef->_fontStorage->removeFont(_font); } _font = _gameRef->_fontStorage->addFont((char *)params); if (!_font) { cmd = PARSERR_GENERIC; } break; case TOKEN_TEXT: setText((char *)params); _gameRef->expandStringByStringTable(&_text); break; case TOKEN_TEXT_ALIGN: if (scumm_stricmp((char *)params, "left") == 0) { _textAlign = TAL_LEFT; } else if (scumm_stricmp((char *)params, "right") == 0) { _textAlign = TAL_RIGHT; } else { _textAlign = TAL_CENTER; } break; case TOKEN_VERTICAL_ALIGN: if (scumm_stricmp((char *)params, "top") == 0) { _verticalAlign = VAL_TOP; } else if (scumm_stricmp((char *)params, "bottom") == 0) { _verticalAlign = VAL_BOTTOM; } else { _verticalAlign = VAL_CENTER; } break; case TOKEN_X: parser.scanStr((char *)params, "%d", &_posX); break; case TOKEN_Y: parser.scanStr((char *)params, "%d", &_posY); break; case TOKEN_WIDTH: parser.scanStr((char *)params, "%d", &_width); break; case TOKEN_HEIGHT: parser.scanStr((char *)params, "%d", &_height); break; case TOKEN_CURSOR: delete _cursor; _cursor = new BaseSprite(_gameRef); if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) { delete _cursor; _cursor = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_SCRIPT: addScript((char *)params); break; case TOKEN_PARENT_NOTIFY: parser.scanStr((char *)params, "%b", &_parentNotify); break; case TOKEN_DISABLED: parser.scanStr((char *)params, "%b", &_disable); break; case TOKEN_VISIBLE: parser.scanStr((char *)params, "%b", &_visible); break; case TOKEN_EDITOR_PROPERTY: parseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { _gameRef->LOG(0, "Syntax error in STATIC definition"); return STATUS_FAILED; } if (cmd == PARSERR_GENERIC) { _gameRef->LOG(0, "Error loading STATIC definition"); return STATUS_FAILED; } correctSize(); return STATUS_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// bool UIButton::loadBuffer(byte *buffer, bool complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(BUTTON) TOKEN_TABLE(TEMPLATE) TOKEN_TABLE(DISABLED) TOKEN_TABLE(VISIBLE) TOKEN_TABLE(FOCUSABLE) TOKEN_TABLE(BACK_HOVER) TOKEN_TABLE(BACK_PRESS) TOKEN_TABLE(BACK_DISABLE) TOKEN_TABLE(BACK_FOCUS) TOKEN_TABLE(BACK) TOKEN_TABLE(CENTER_IMAGE) TOKEN_TABLE(IMAGE_HOVER) TOKEN_TABLE(IMAGE_PRESS) TOKEN_TABLE(IMAGE_DISABLE) TOKEN_TABLE(IMAGE_FOCUS) TOKEN_TABLE(IMAGE) TOKEN_TABLE(FONT_HOVER) TOKEN_TABLE(FONT_PRESS) TOKEN_TABLE(FONT_DISABLE) TOKEN_TABLE(FONT_FOCUS) TOKEN_TABLE(FONT) TOKEN_TABLE(TEXT_ALIGN) TOKEN_TABLE(TEXT) TOKEN_TABLE(X) TOKEN_TABLE(Y) TOKEN_TABLE(WIDTH) TOKEN_TABLE(HEIGHT) TOKEN_TABLE(CURSOR) TOKEN_TABLE(NAME) TOKEN_TABLE(EVENTS) TOKEN_TABLE(SCRIPT) TOKEN_TABLE(CAPTION) TOKEN_TABLE(PARENT_NOTIFY) TOKEN_TABLE(PRESSED) TOKEN_TABLE(PIXEL_PERFECT) TOKEN_TABLE(EDITOR_PROPERTY) TOKEN_TABLE_END byte *params; int cmd = 2; BaseParser parser; if (complete) { if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_BUTTON) { _gameRef->LOG(0, "'BUTTON' keyword expected."); return STATUS_FAILED; } buffer = params; } while (cmd > 0 && (cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) { switch (cmd) { case TOKEN_TEMPLATE: if (DID_FAIL(loadFile((char *)params))) { cmd = PARSERR_GENERIC; } break; case TOKEN_NAME: setName((char *)params); break; case TOKEN_CAPTION: setCaption((char *)params); break; case TOKEN_BACK: delete _back; _back = new UITiledImage(_gameRef); if (!_back || DID_FAIL(_back->loadFile((char *)params))) { delete _back; _back = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_BACK_HOVER: delete _backHover; _backHover = new UITiledImage(_gameRef); if (!_backHover || DID_FAIL(_backHover->loadFile((char *)params))) { delete _backHover; _backHover = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_BACK_PRESS: delete _backPress; _backPress = new UITiledImage(_gameRef); if (!_backPress || DID_FAIL(_backPress->loadFile((char *)params))) { delete _backPress; _backPress = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_BACK_DISABLE: delete _backDisable; _backDisable = new UITiledImage(_gameRef); if (!_backDisable || DID_FAIL(_backDisable->loadFile((char *)params))) { delete _backDisable; _backDisable = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_BACK_FOCUS: delete _backFocus; _backFocus = new UITiledImage(_gameRef); if (!_backFocus || DID_FAIL(_backFocus->loadFile((char *)params))) { delete _backFocus; _backFocus = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_IMAGE: delete _image; _image = new BaseSprite(_gameRef); if (!_image || DID_FAIL(_image->loadFile((char *)params))) { delete _image; _image = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_IMAGE_HOVER: delete _imageHover; _imageHover = new BaseSprite(_gameRef); if (!_imageHover || DID_FAIL(_imageHover->loadFile((char *)params))) { delete _imageHover; _imageHover = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_IMAGE_PRESS: delete _imagePress; _imagePress = new BaseSprite(_gameRef); if (!_imagePress || DID_FAIL(_imagePress->loadFile((char *)params))) { delete _imagePress; _imagePress = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_IMAGE_DISABLE: delete _imageDisable; _imageDisable = new BaseSprite(_gameRef); if (!_imageDisable || DID_FAIL(_imageDisable->loadFile((char *)params))) { delete _imageDisable; _imageDisable = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_IMAGE_FOCUS: delete _imageFocus; _imageFocus = new BaseSprite(_gameRef); if (!_imageFocus || DID_FAIL(_imageFocus->loadFile((char *)params))) { delete _imageFocus; _imageFocus = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_FONT: if (_font) { _gameRef->_fontStorage->removeFont(_font); } _font = _gameRef->_fontStorage->addFont((char *)params); if (!_font) { cmd = PARSERR_GENERIC; } break; case TOKEN_FONT_HOVER: if (_fontHover) { _gameRef->_fontStorage->removeFont(_fontHover); } _fontHover = _gameRef->_fontStorage->addFont((char *)params); if (!_fontHover) { cmd = PARSERR_GENERIC; } break; case TOKEN_FONT_PRESS: if (_fontPress) { _gameRef->_fontStorage->removeFont(_fontPress); } _fontPress = _gameRef->_fontStorage->addFont((char *)params); if (!_fontPress) { cmd = PARSERR_GENERIC; } break; case TOKEN_FONT_DISABLE: if (_fontDisable) { _gameRef->_fontStorage->removeFont(_fontDisable); } _fontDisable = _gameRef->_fontStorage->addFont((char *)params); if (!_fontDisable) { cmd = PARSERR_GENERIC; } break; case TOKEN_FONT_FOCUS: if (_fontFocus) { _gameRef->_fontStorage->removeFont(_fontFocus); } _fontFocus = _gameRef->_fontStorage->addFont((char *)params); if (!_fontFocus) { cmd = PARSERR_GENERIC; } break; case TOKEN_TEXT: setText((char *)params); _gameRef->_stringTable->expand(&_text); break; case TOKEN_TEXT_ALIGN: if (scumm_stricmp((char *)params, "left") == 0) { _align = TAL_LEFT; } else if (scumm_stricmp((char *)params, "right") == 0) { _align = TAL_RIGHT; } else { _align = TAL_CENTER; } break; case TOKEN_X: parser.scanStr((char *)params, "%d", &_posX); break; case TOKEN_Y: parser.scanStr((char *)params, "%d", &_posY); break; case TOKEN_WIDTH: parser.scanStr((char *)params, "%d", &_width); break; case TOKEN_HEIGHT: parser.scanStr((char *)params, "%d", &_height); break; case TOKEN_CURSOR: delete _cursor; _cursor = new BaseSprite(_gameRef); if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) { delete _cursor; _cursor = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_SCRIPT: addScript((char *)params); break; case TOKEN_PARENT_NOTIFY: parser.scanStr((char *)params, "%b", &_parentNotify); break; case TOKEN_DISABLED: parser.scanStr((char *)params, "%b", &_disable); break; case TOKEN_VISIBLE: parser.scanStr((char *)params, "%b", &_visible); break; case TOKEN_FOCUSABLE: parser.scanStr((char *)params, "%b", &_canFocus); break; case TOKEN_CENTER_IMAGE: parser.scanStr((char *)params, "%b", &_centerImage); break; case TOKEN_PRESSED: parser.scanStr((char *)params, "%b", &_stayPressed); break; case TOKEN_PIXEL_PERFECT: parser.scanStr((char *)params, "%b", &_pixelPerfect); break; case TOKEN_EDITOR_PROPERTY: parseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { _gameRef->LOG(0, "Syntax error in BUTTON definition"); return STATUS_FAILED; } if (cmd == PARSERR_GENERIC) { _gameRef->LOG(0, "Error loading BUTTON definition"); return STATUS_FAILED; } correctSize(); return STATUS_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// bool AdEntity::loadBuffer(byte *buffer, bool complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(ENTITY) TOKEN_TABLE(SPRITE) 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(EVENTS) TOKEN_TABLE(FONT) TOKEN_TABLE(TALK_SPECIAL) TOKEN_TABLE(TALK) TOKEN_TABLE(CURSOR) TOKEN_TABLE(REGION) TOKEN_TABLE(BLOCKED_REGION) TOKEN_TABLE(EDITOR_SELECTED) TOKEN_TABLE(SCRIPT) TOKEN_TABLE(SOUND_START_TIME) TOKEN_TABLE(SOUND_VOLUME) TOKEN_TABLE(SOUND_PANNING) TOKEN_TABLE(SOUND) TOKEN_TABLE(SUBTYPE) TOKEN_TABLE(CAPTION) TOKEN_TABLE(PROPERTY) 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(ITEM) TOKEN_TABLE(WALK_TO_X) TOKEN_TABLE(WALK_TO_Y) TOKEN_TABLE(WALK_TO_DIR) TOKEN_TABLE(SAVE_STATE) TOKEN_TABLE_END byte *params; int cmd; BaseParser parser; if (complete) { if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_ENTITY) { _gameRef->LOG(0, "'ENTITY' keyword expected."); return STATUS_FAILED; } buffer = params; } AdGame *adGame = (AdGame *)_gameRef; BaseSprite *spr = nullptr; 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 (DID_FAIL(loadFile((char *)params))) { cmd = PARSERR_GENERIC; } break; case TOKEN_X: parser.scanStr((char *)params, "%d", &_posX); break; case TOKEN_Y: parser.scanStr((char *)params, "%d", &_posY); break; case TOKEN_SPRITE: { delete _sprite; _sprite = nullptr; spr = new BaseSprite(_gameRef, this); if (!spr || DID_FAIL(spr->loadFile((char *)params))) { cmd = PARSERR_GENERIC; } else { _sprite = spr; } } break; case TOKEN_TALK: { spr = new BaseSprite(_gameRef, this); if (!spr || DID_FAIL(spr->loadFile((char *)params, adGame->_texTalkLifeTime))) { cmd = PARSERR_GENERIC; } else { _talkSprites.add(spr); } } break; case TOKEN_TALK_SPECIAL: { spr = new BaseSprite(_gameRef, this); if (!spr || DID_FAIL(spr->loadFile((char *)params, adGame->_texTalkLifeTime))) { cmd = PARSERR_GENERIC; } else { _talkSpritesEx.add(spr); } } break; case TOKEN_NAME: setName((char *)params); break; case TOKEN_ITEM: setItem((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", &_zoomable); break; case TOKEN_SCALE: { int s; parser.scanStr((char *)params, "%d", &s); _scale = (float)s; } break; case TOKEN_RELATIVE_SCALE: { int s; parser.scanStr((char *)params, "%d", &s); _relativeScale = (float)s; } break; case TOKEN_ROTABLE: case TOKEN_ROTATABLE: parser.scanStr((char *)params, "%b", &_rotatable); break; case TOKEN_REGISTRABLE: case TOKEN_INTERACTIVE: parser.scanStr((char *)params, "%b", &_registrable); break; case TOKEN_SHADOWABLE: case TOKEN_COLORABLE: parser.scanStr((char *)params, "%b", &_shadowable); break; case TOKEN_ACTIVE: parser.scanStr((char *)params, "%b", &_active); break; case TOKEN_CURSOR: delete _cursor; _cursor = new BaseSprite(_gameRef); if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) { delete _cursor; _cursor = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_EDITOR_SELECTED: parser.scanStr((char *)params, "%b", &_editorSelected); break; case TOKEN_REGION: { if (_region) { _gameRef->unregisterObject(_region); } _region = nullptr; BaseRegion *rgn = new BaseRegion(_gameRef); if (!rgn || DID_FAIL(rgn->loadBuffer(params, false))) { cmd = PARSERR_GENERIC; } else { _region = rgn; _gameRef->registerObject(_region); } } break; case TOKEN_BLOCKED_REGION: { delete _blockRegion; _blockRegion = nullptr; delete _currentBlockRegion; _currentBlockRegion = nullptr; BaseRegion *rgn = new BaseRegion(_gameRef); BaseRegion *crgn = new BaseRegion(_gameRef); if (!rgn || !crgn || DID_FAIL(rgn->loadBuffer(params, false))) { delete _blockRegion; _blockRegion = nullptr; delete _currentBlockRegion; _currentBlockRegion = nullptr; cmd = PARSERR_GENERIC; } else { _blockRegion = rgn; _currentBlockRegion = crgn; _currentBlockRegion->mimic(_blockRegion); } } break; case TOKEN_WAYPOINTS: { delete _wptGroup; _wptGroup = nullptr; delete _currentWptGroup; _currentWptGroup = nullptr; AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef); AdWaypointGroup *cwpt = new AdWaypointGroup(_gameRef); if (!wpt || !cwpt || DID_FAIL(wpt->loadBuffer(params, false))) { delete _wptGroup; _wptGroup = nullptr; delete _currentWptGroup; _currentWptGroup = nullptr; cmd = PARSERR_GENERIC; } else { _wptGroup = wpt; _currentWptGroup = cwpt; _currentWptGroup->mimic(_wptGroup); } } break; case TOKEN_SCRIPT: addScript((char *)params); break; case TOKEN_SUBTYPE: { if (scumm_stricmp((char *)params, "sound") == 0) { delete _sprite; _sprite = nullptr; if (_gameRef->_editorMode) { spr = new BaseSprite(_gameRef, this); if (!spr || DID_FAIL(spr->loadFile("entity_sound.sprite"))) { cmd = PARSERR_GENERIC; } else { _sprite = spr; } } if (_gameRef->_editorMode) { _editorOnly = true; } _zoomable = false; _rotatable = false; _registrable = _gameRef->_editorMode; _shadowable = false; _subtype = ENTITY_SOUND; } } break; case TOKEN_SOUND: playSFX((char *)params, false, false); break; case TOKEN_SOUND_START_TIME: parser.scanStr((char *)params, "%d", &_sFXStart); break; case TOKEN_SOUND_VOLUME: parser.scanStr((char *)params, "%d", &_sFXVolume); break; case TOKEN_SOUND_PANNING: parser.scanStr((char *)params, "%b", &_autoSoundPanning); break; case TOKEN_SAVE_STATE: parser.scanStr((char *)params, "%b", &_saveState); break; case TOKEN_PROPERTY: parseProperty(params, false); break; case TOKEN_IGNORE_ITEMS: parser.scanStr((char *)params, "%b", &_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_WALK_TO_X: parser.scanStr((char *)params, "%d", &_walkToX); break; case TOKEN_WALK_TO_Y: parser.scanStr((char *)params, "%d", &_walkToY); break; case TOKEN_WALK_TO_DIR: { int i; parser.scanStr((char *)params, "%d", &i); if (i < 0) { i = 0; } if (i >= NUM_DIRECTIONS) { i = DI_NONE; } _walkToDir = (TDirection)i; } break; } } if (cmd == PARSERR_TOKENNOTFOUND) { _gameRef->LOG(0, "Syntax error in ENTITY definition"); return STATUS_FAILED; } if (cmd == PARSERR_GENERIC) { _gameRef->LOG(0, "Error loading ENTITY definition"); if (spr) { delete spr; } return STATUS_FAILED; } if (_region && _sprite) { _gameRef->LOG(0, "Warning: Entity '%s' has both sprite and region.", getName()); } updatePosition(); if (alpha != 0 && ar == 0 && ag == 0 && ab == 0) { ar = ag = ab = 255; } _alphaColor = BYTETORGBA(ar, ag, ab, alpha); _state = STATE_READY; if (_item && ((AdGame *)_gameRef)->isItemTaken(_item)) { _active = false; } return STATUS_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// bool AdResponseBox::loadBuffer(byte *buffer, bool complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(RESPONSE_BOX) TOKEN_TABLE(TEMPLATE) TOKEN_TABLE(FONT_HOVER) TOKEN_TABLE(FONT) TOKEN_TABLE(AREA) TOKEN_TABLE(HORIZONTAL) TOKEN_TABLE(SPACING) TOKEN_TABLE(WINDOW) TOKEN_TABLE(CURSOR) TOKEN_TABLE(TEXT_ALIGN) TOKEN_TABLE(VERTICAL_ALIGN) TOKEN_TABLE(EDITOR_PROPERTY) TOKEN_TABLE_END byte *params; int cmd; BaseParser parser; if (complete) { if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_RESPONSE_BOX) { _gameRef->LOG(0, "'RESPONSE_BOX' keyword expected."); return STATUS_FAILED; } buffer = params; } while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) { switch (cmd) { case TOKEN_TEMPLATE: if (DID_FAIL(loadFile((char *)params))) { cmd = PARSERR_GENERIC; } break; case TOKEN_WINDOW: delete _window; _window = new UIWindow(_gameRef); if (!_window || DID_FAIL(_window->loadBuffer(params, false))) { delete _window; _window = nullptr; cmd = PARSERR_GENERIC; } else if (_shieldWindow) { _shieldWindow->_parent = _window; } break; case TOKEN_FONT: if (_font) { _gameRef->_fontStorage->removeFont(_font); } _font = _gameRef->_fontStorage->addFont((char *)params); if (!_font) { cmd = PARSERR_GENERIC; } break; case TOKEN_FONT_HOVER: if (_fontHover) { _gameRef->_fontStorage->removeFont(_fontHover); } _fontHover = _gameRef->_fontStorage->addFont((char *)params); if (!_fontHover) { cmd = PARSERR_GENERIC; } break; case TOKEN_AREA: parser.scanStr((char *)params, "%d,%d,%d,%d", &_responseArea.left, &_responseArea.top, &_responseArea.right, &_responseArea.bottom); break; case TOKEN_HORIZONTAL: parser.scanStr((char *)params, "%b", &_horizontal); break; case TOKEN_TEXT_ALIGN: if (scumm_stricmp((char *)params, "center") == 0) { _align = TAL_CENTER; } else if (scumm_stricmp((char *)params, "right") == 0) { _align = TAL_RIGHT; } else { _align = TAL_LEFT; } break; case TOKEN_VERTICAL_ALIGN: if (scumm_stricmp((char *)params, "top") == 0) { _verticalAlign = VAL_TOP; } else if (scumm_stricmp((char *)params, "center") == 0) { _verticalAlign = VAL_CENTER; } else { _verticalAlign = VAL_BOTTOM; } break; case TOKEN_SPACING: parser.scanStr((char *)params, "%d", &_spacing); break; case TOKEN_EDITOR_PROPERTY: parseEditorProperty(params, false); break; case TOKEN_CURSOR: delete _cursor; _cursor = new BaseSprite(_gameRef); if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) { delete _cursor; _cursor = nullptr; cmd = PARSERR_GENERIC; } break; } } if (cmd == PARSERR_TOKENNOTFOUND) { _gameRef->LOG(0, "Syntax error in RESPONSE_BOX definition"); return STATUS_FAILED; } if (_window) { for (uint32 i = 0; i < _window->_widgets.size(); i++) { if (!_window->_widgets[i]->_listenerObject) { _window->_widgets[i]->setListener(this, _window->_widgets[i], 0); } } } return STATUS_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// bool AdTalkNode::loadBuffer(byte *buffer, bool complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(ACTION) TOKEN_TABLE(SPRITESET_FILE) TOKEN_TABLE(SPRITESET) TOKEN_TABLE(SPRITE) TOKEN_TABLE(START_TIME) TOKEN_TABLE(END_TIME) TOKEN_TABLE(COMMENT) TOKEN_TABLE(PRECACHE) TOKEN_TABLE(EDITOR_PROPERTY) TOKEN_TABLE_END byte *params; int cmd; BaseParser parser; if (complete) { if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_ACTION) { _gameRef->LOG(0, "'ACTION' keyword expected."); return STATUS_FAILED; } buffer = params; } _endTime = 0; _playToEnd = false; _preCache = false; while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) { switch (cmd) { case TOKEN_SPRITE: BaseUtils::setString(&_spriteFilename, (char *)params); break; case TOKEN_SPRITESET_FILE: BaseUtils::setString(&_spriteSetFilename, (char *)params); break; case TOKEN_SPRITESET: { delete _spriteSet; _spriteSet = new AdSpriteSet(_gameRef); if (!_spriteSet || DID_FAIL(_spriteSet->loadBuffer(params, false))) { delete _spriteSet; _spriteSet = nullptr; cmd = PARSERR_GENERIC; } } break; case TOKEN_START_TIME: parser.scanStr((char *)params, "%d", &_startTime); break; case TOKEN_END_TIME: parser.scanStr((char *)params, "%d", &_endTime); break; case TOKEN_PRECACHE: parser.scanStr((char *)params, "%b", &_preCache); break; case TOKEN_COMMENT: if (_gameRef->_editorMode) { BaseUtils::setString(&_comment, (char *)params); } break; case TOKEN_EDITOR_PROPERTY: parseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { _gameRef->LOG(0, "Syntax error in ACTION definition"); return STATUS_FAILED; } if (cmd == PARSERR_GENERIC) { _gameRef->LOG(0, "Error loading ACTION definition"); return STATUS_FAILED; } if (_endTime == 0) { _playToEnd = true; } else { _playToEnd = false; } if (_preCache && _spriteFilename) { delete _sprite; _sprite = new BaseSprite(_gameRef); if (!_sprite || DID_FAIL(_sprite->loadFile(_spriteFilename))) { return STATUS_FAILED; } } if (_preCache && _spriteSetFilename) { delete _spriteSet; _spriteSet = new AdSpriteSet(_gameRef); if (!_spriteSet || DID_FAIL(_spriteSet->loadFile(_spriteSetFilename))) { return STATUS_FAILED; } } return STATUS_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// bool AdActor::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; BaseParser parser; if (complete) { if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_ACTOR) { _gameRef->LOG(0, "'ACTOR' keyword expected."); return STATUS_FAILED; } buffer = params; } AdGame *adGame = (AdGame *)_gameRef; AdSpriteSet *spr = nullptr; 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 (DID_FAIL(loadFile((char *)params))) { cmd = PARSERR_GENERIC; } break; case TOKEN_X: parser.scanStr((char *)params, "%d", &_posX); break; case TOKEN_Y: parser.scanStr((char *)params, "%d", &_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", &_zoomable); break; case TOKEN_ROTABLE: case TOKEN_ROTATABLE: parser.scanStr((char *)params, "%b", &_rotatable); break; case TOKEN_REGISTRABLE: case TOKEN_INTERACTIVE: parser.scanStr((char *)params, "%b", &_registrable); break; case TOKEN_SHADOWABLE: case TOKEN_COLORABLE: parser.scanStr((char *)params, "%b", &_shadowable); break; case TOKEN_ACTIVE: parser.scanStr((char *)params, "%b", &_active); break; case TOKEN_WALK: delete _walkSprite; _walkSprite = nullptr; spr = new AdSpriteSet(_gameRef, this); if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texWalkLifeTime, CACHE_HALF))) { cmd = PARSERR_GENERIC; } else { _walkSprite = spr; } break; case TOKEN_TALK: spr = new AdSpriteSet(_gameRef, this); if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texTalkLifeTime))) { cmd = PARSERR_GENERIC; } else { _talkSprites.add(spr); } break; case TOKEN_TALK_SPECIAL: spr = new AdSpriteSet(_gameRef, this); if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texTalkLifeTime))) { cmd = PARSERR_GENERIC; } else { _talkSpritesEx.add(spr); } break; case TOKEN_STAND: delete _standSprite; _standSprite = nullptr; spr = new AdSpriteSet(_gameRef, this); if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texStandLifeTime))) { cmd = PARSERR_GENERIC; } else { _standSprite = spr; } break; case TOKEN_TURN_LEFT: delete _turnLeftSprite; _turnLeftSprite = nullptr; spr = new AdSpriteSet(_gameRef, this); if (!spr || DID_FAIL(spr->loadBuffer(params, true))) { cmd = PARSERR_GENERIC; } else { _turnLeftSprite = spr; } break; case TOKEN_TURN_RIGHT: delete _turnRightSprite; _turnRightSprite = nullptr; spr = new AdSpriteSet(_gameRef, this); if (!spr || DID_FAIL(spr->loadBuffer(params, true))) { cmd = PARSERR_GENERIC; } else { _turnRightSprite = spr; } break; case TOKEN_SCRIPT: addScript((char *)params); break; case TOKEN_CURSOR: delete _cursor; _cursor = new BaseSprite(_gameRef); if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) { delete _cursor; _cursor = nullptr; cmd = PARSERR_GENERIC; } break; case TOKEN_SOUND_VOLUME: parser.scanStr((char *)params, "%d", &_sFXVolume); break; case TOKEN_SCALE: { int s; parser.scanStr((char *)params, "%d", &s); _scale = (float)s; } break; case TOKEN_RELATIVE_SCALE: { int s; parser.scanStr((char *)params, "%d", &s); _relativeScale = (float)s; } break; case TOKEN_SOUND_PANNING: parser.scanStr((char *)params, "%b", &_autoSoundPanning); break; case TOKEN_PROPERTY: parseProperty(params, false); break; case TOKEN_BLOCKED_REGION: { delete _blockRegion; delete _currentBlockRegion; _blockRegion = nullptr; _currentBlockRegion = nullptr; BaseRegion *rgn = new BaseRegion(_gameRef); BaseRegion *crgn = new BaseRegion(_gameRef); if (!rgn || !crgn || DID_FAIL(rgn->loadBuffer(params, false))) { delete _blockRegion; delete _currentBlockRegion; _blockRegion = nullptr; _currentBlockRegion = nullptr; cmd = PARSERR_GENERIC; } else { _blockRegion = rgn; _currentBlockRegion = crgn; _currentBlockRegion->mimic(_blockRegion); } } break; case TOKEN_WAYPOINTS: { delete _wptGroup; delete _currentWptGroup; _wptGroup = nullptr; _currentWptGroup = nullptr; AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef); AdWaypointGroup *cwpt = new AdWaypointGroup(_gameRef); if (!wpt || !cwpt || DID_FAIL(wpt->loadBuffer(params, false))) { delete _wptGroup; delete _currentWptGroup; _wptGroup = nullptr; _currentWptGroup = nullptr; cmd = PARSERR_GENERIC; } else { _wptGroup = wpt; _currentWptGroup = cwpt; _currentWptGroup->mimic(_wptGroup); } } break; case TOKEN_IGNORE_ITEMS: parser.scanStr((char *)params, "%b", &_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: { AdSpriteSet *anim = new AdSpriteSet(_gameRef, this); if (!anim || DID_FAIL(anim->loadBuffer(params, false))) { cmd = PARSERR_GENERIC; } else { _anims.add(anim); } } break; } } if (cmd == PARSERR_TOKENNOTFOUND) { _gameRef->LOG(0, "Syntax error in ACTOR definition"); return STATUS_FAILED; } if (cmd == PARSERR_GENERIC) { if (spr) { delete spr; } _gameRef->LOG(0, "Error loading ACTOR definition"); return STATUS_FAILED; } if (alpha != 0 && ar == 0 && ag == 0 && ab == 0) { ar = ag = ab = 255; } _alphaColor = BYTETORGBA(ar, ag, ab, alpha); _state = _nextState = STATE_READY; return STATUS_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// HRESULT CUIEntity::LoadBuffer(byte *Buffer, bool Complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(ENTITY_CONTAINER) TOKEN_TABLE(TEMPLATE) TOKEN_TABLE(DISABLED) TOKEN_TABLE(VISIBLE) TOKEN_TABLE(X) TOKEN_TABLE(Y) TOKEN_TABLE(NAME) TOKEN_TABLE(ENTITY) TOKEN_TABLE(SCRIPT) TOKEN_TABLE(EDITOR_PROPERTY) TOKEN_TABLE_END byte *params; int cmd = 2; CBParser parser(Game); if (Complete) { if (parser.GetCommand((char **)&Buffer, commands, (char **)¶ms) != TOKEN_ENTITY_CONTAINER) { Game->LOG(0, "'ENTITY_CONTAINER' keyword expected."); return E_FAIL; } Buffer = params; } 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_X: parser.ScanStr((char *)params, "%d", &m_PosX); break; case TOKEN_Y: parser.ScanStr((char *)params, "%d", &m_PosY); 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_ENTITY: if (FAILED(SetEntity((char *)params))) cmd = PARSERR_GENERIC; break; case TOKEN_SCRIPT: AddScript((char *)params); break; case TOKEN_EDITOR_PROPERTY: ParseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { Game->LOG(0, "Syntax error in ENTITY_CONTAINER definition"); return E_FAIL; } if (cmd == PARSERR_GENERIC) { Game->LOG(0, "Error loading ENTITY_CONTAINER definition"); return E_FAIL; } CorrectSize(); if (Game->m_EditorMode) { m_Width = 50; m_Height = 50; } return S_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// HRESULT CUIButton::LoadBuffer(byte *Buffer, bool Complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(BUTTON) TOKEN_TABLE(TEMPLATE) TOKEN_TABLE(DISABLED) TOKEN_TABLE(VISIBLE) TOKEN_TABLE(FOCUSABLE) TOKEN_TABLE(BACK_HOVER) TOKEN_TABLE(BACK_PRESS) TOKEN_TABLE(BACK_DISABLE) TOKEN_TABLE(BACK_FOCUS) TOKEN_TABLE(BACK) TOKEN_TABLE(CENTER_IMAGE) TOKEN_TABLE(IMAGE_HOVER) TOKEN_TABLE(IMAGE_PRESS) TOKEN_TABLE(IMAGE_DISABLE) TOKEN_TABLE(IMAGE_FOCUS) TOKEN_TABLE(IMAGE) TOKEN_TABLE(FONT_HOVER) TOKEN_TABLE(FONT_PRESS) TOKEN_TABLE(FONT_DISABLE) TOKEN_TABLE(FONT_FOCUS) TOKEN_TABLE(FONT) TOKEN_TABLE(TEXT_ALIGN) TOKEN_TABLE(TEXT) TOKEN_TABLE(X) TOKEN_TABLE(Y) TOKEN_TABLE(WIDTH) TOKEN_TABLE(HEIGHT) TOKEN_TABLE(CURSOR) TOKEN_TABLE(NAME) TOKEN_TABLE(EVENTS) TOKEN_TABLE(SCRIPT) TOKEN_TABLE(CAPTION) TOKEN_TABLE(PARENT_NOTIFY) TOKEN_TABLE(PRESSED) TOKEN_TABLE(PIXEL_PERFECT) TOKEN_TABLE(EDITOR_PROPERTY) TOKEN_TABLE_END byte *params; int cmd = 2; CBParser parser(Game); if (Complete) { if (parser.GetCommand((char **)&Buffer, commands, (char **)¶ms) != TOKEN_BUTTON) { Game->LOG(0, "'BUTTON' keyword expected."); return E_FAIL; } Buffer = params; } 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_CAPTION: SetCaption((char *)params); break; case TOKEN_BACK: delete m_Back; m_Back = new CUITiledImage(Game); if (!m_Back || FAILED(m_Back->LoadFile((char *)params))) { delete m_Back; m_Back = NULL; cmd = PARSERR_GENERIC; } break; case TOKEN_BACK_HOVER: delete m_BackHover; m_BackHover = new CUITiledImage(Game); if (!m_BackHover || FAILED(m_BackHover->LoadFile((char *)params))) { delete m_BackHover; m_BackHover = NULL; cmd = PARSERR_GENERIC; } break; case TOKEN_BACK_PRESS: delete m_BackPress; m_BackPress = new CUITiledImage(Game); if (!m_BackPress || FAILED(m_BackPress->LoadFile((char *)params))) { delete m_BackPress; m_BackPress = NULL; cmd = PARSERR_GENERIC; } break; case TOKEN_BACK_DISABLE: delete m_BackDisable; m_BackDisable = new CUITiledImage(Game); if (!m_BackDisable || FAILED(m_BackDisable->LoadFile((char *)params))) { delete m_BackDisable; m_BackDisable = NULL; cmd = PARSERR_GENERIC; } break; case TOKEN_BACK_FOCUS: delete m_BackFocus; m_BackFocus = new CUITiledImage(Game); if (!m_BackFocus || FAILED(m_BackFocus->LoadFile((char *)params))) { delete m_BackFocus; m_BackFocus = NULL; cmd = PARSERR_GENERIC; } break; case TOKEN_IMAGE: delete m_Image; m_Image = new CBSprite(Game); if (!m_Image || FAILED(m_Image->LoadFile((char *)params))) { delete m_Image; m_Image = NULL; cmd = PARSERR_GENERIC; } break; case TOKEN_IMAGE_HOVER: delete m_ImageHover; m_ImageHover = new CBSprite(Game); if (!m_ImageHover || FAILED(m_ImageHover->LoadFile((char *)params))) { delete m_ImageHover; m_ImageHover = NULL; cmd = PARSERR_GENERIC; } break; case TOKEN_IMAGE_PRESS: delete m_ImagePress; m_ImagePress = new CBSprite(Game); if (!m_ImagePress || FAILED(m_ImagePress->LoadFile((char *)params))) { delete m_ImagePress; m_ImagePress = NULL; cmd = PARSERR_GENERIC; } break; case TOKEN_IMAGE_DISABLE: delete m_ImageDisable; m_ImageDisable = new CBSprite(Game); if (!m_ImageDisable || FAILED(m_ImageDisable->LoadFile((char *)params))) { delete m_ImageDisable; m_ImageDisable = NULL; cmd = PARSERR_GENERIC; } break; case TOKEN_IMAGE_FOCUS: delete m_ImageFocus; m_ImageFocus = new CBSprite(Game); if (!m_ImageFocus || FAILED(m_ImageFocus->LoadFile((char *)params))) { delete m_ImageFocus; m_ImageFocus = NULL; 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_HOVER: if (m_FontHover) Game->m_FontStorage->RemoveFont(m_FontHover); m_FontHover = Game->m_FontStorage->AddFont((char *)params); if (!m_FontHover) cmd = PARSERR_GENERIC; break; case TOKEN_FONT_PRESS: if (m_FontPress) Game->m_FontStorage->RemoveFont(m_FontPress); m_FontPress = Game->m_FontStorage->AddFont((char *)params); if (!m_FontPress) cmd = PARSERR_GENERIC; break; case TOKEN_FONT_DISABLE: if (m_FontDisable) Game->m_FontStorage->RemoveFont(m_FontDisable); m_FontDisable = Game->m_FontStorage->AddFont((char *)params); if (!m_FontDisable) cmd = PARSERR_GENERIC; break; case TOKEN_FONT_FOCUS: if (m_FontFocus) Game->m_FontStorage->RemoveFont(m_FontFocus); m_FontFocus = Game->m_FontStorage->AddFont((char *)params); if (!m_FontFocus) cmd = PARSERR_GENERIC; break; case TOKEN_TEXT: SetText((char *)params); Game->m_StringTable->Expand(&m_Text); break; case TOKEN_TEXT_ALIGN: if (scumm_stricmp((char *)params, "left") == 0) m_Align = TAL_LEFT; else if (scumm_stricmp((char *)params, "right") == 0) m_Align = TAL_RIGHT; else m_Align = TAL_CENTER; 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: delete m_Cursor; m_Cursor = new CBSprite(Game); if (!m_Cursor || FAILED(m_Cursor->LoadFile((char *)params))) { delete m_Cursor; m_Cursor = NULL; cmd = PARSERR_GENERIC; } break; case TOKEN_SCRIPT: AddScript((char *)params); break; case TOKEN_PARENT_NOTIFY: parser.ScanStr((char *)params, "%b", &m_ParentNotify); 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_FOCUSABLE: parser.ScanStr((char *)params, "%b", &m_CanFocus); break; case TOKEN_CENTER_IMAGE: parser.ScanStr((char *)params, "%b", &m_CenterImage); break; case TOKEN_PRESSED: parser.ScanStr((char *)params, "%b", &m_StayPressed); break; case TOKEN_PIXEL_PERFECT: parser.ScanStr((char *)params, "%b", &m_PixelPerfect); break; case TOKEN_EDITOR_PROPERTY: ParseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { Game->LOG(0, "Syntax error in BUTTON definition"); return E_FAIL; } if (cmd == PARSERR_GENERIC) { Game->LOG(0, "Error loading BUTTON definition"); return E_FAIL; } CorrectSize(); return S_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// bool AdTalkDef::loadBuffer(byte *buffer, bool complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(TALK) TOKEN_TABLE(TEMPLATE) TOKEN_TABLE(ACTION) TOKEN_TABLE(DEFAULT_SPRITESET_FILE) TOKEN_TABLE(DEFAULT_SPRITESET) TOKEN_TABLE(DEFAULT_SPRITE) TOKEN_TABLE(EDITOR_PROPERTY) TOKEN_TABLE_END byte *params; int cmd; BaseParser parser; if (complete) { if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_TALK) { _gameRef->LOG(0, "'TALK' keyword expected."); return STATUS_FAILED; } buffer = params; } while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) { switch (cmd) { case TOKEN_TEMPLATE: if (DID_FAIL(loadFile((char *)params))) { cmd = PARSERR_GENERIC; } break; case TOKEN_ACTION: { AdTalkNode *node = new AdTalkNode(_gameRef); if (node && DID_SUCCEED(node->loadBuffer(params, false))) { _nodes.add(node); } else { delete node; node = nullptr; cmd = PARSERR_GENERIC; } } break; case TOKEN_DEFAULT_SPRITE: BaseUtils::setString(&_defaultSpriteFilename, (char *)params); break; case TOKEN_DEFAULT_SPRITESET_FILE: BaseUtils::setString(&_defaultSpriteSetFilename, (char *)params); break; case TOKEN_DEFAULT_SPRITESET: { delete _defaultSpriteSet; _defaultSpriteSet = new AdSpriteSet(_gameRef); if (!_defaultSpriteSet || DID_FAIL(_defaultSpriteSet->loadBuffer(params, false))) { delete _defaultSpriteSet; _defaultSpriteSet = nullptr; cmd = PARSERR_GENERIC; } } break; case TOKEN_EDITOR_PROPERTY: parseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { _gameRef->LOG(0, "Syntax error in TALK definition"); return STATUS_FAILED; } if (cmd == PARSERR_GENERIC) { _gameRef->LOG(0, "Error loading TALK definition"); return STATUS_FAILED; } delete _defaultSprite; delete _defaultSpriteSet; _defaultSprite = nullptr; _defaultSpriteSet = nullptr; if (_defaultSpriteFilename) { _defaultSprite = new BaseSprite(_gameRef); if (!_defaultSprite || DID_FAIL(_defaultSprite->loadFile(_defaultSpriteFilename))) { return STATUS_FAILED; } } if (_defaultSpriteSetFilename) { _defaultSpriteSet = new AdSpriteSet(_gameRef); if (!_defaultSpriteSet || DID_FAIL(_defaultSpriteSet->loadFile(_defaultSpriteSetFilename))) { return STATUS_FAILED; } } return STATUS_OK; }
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 ////////////////////////////////////////////////////////////////////////// bool UIEdit::loadBuffer(byte *buffer, bool complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(TEMPLATE) TOKEN_TABLE(DISABLED) TOKEN_TABLE(VISIBLE) TOKEN_TABLE(BACK) TOKEN_TABLE(IMAGE) TOKEN_TABLE(FONT_SELECTED) TOKEN_TABLE(FONT) TOKEN_TABLE(TEXT) TOKEN_TABLE(X) TOKEN_TABLE(Y) TOKEN_TABLE(WIDTH) TOKEN_TABLE(HEIGHT) TOKEN_TABLE(CURSOR_BLINK_RATE) TOKEN_TABLE(CURSOR) TOKEN_TABLE(FRAME_WIDTH) TOKEN_TABLE(NAME) TOKEN_TABLE(SCRIPT) TOKEN_TABLE(PARENT_NOTIFY) TOKEN_TABLE(MAX_LENGTH) TOKEN_TABLE(EDITOR_PROPERTY) TOKEN_TABLE(EDIT) TOKEN_TABLE(CAPTION) TOKEN_TABLE_END byte *params; int cmd = 2; BaseParser parser; if (complete) { if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_EDIT) { _gameRef->LOG(0, "'EDIT' keyword expected."); return STATUS_FAILED; } buffer = params; } while (cmd > 0 && (cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) { switch (cmd) { case TOKEN_TEMPLATE: if (DID_FAIL(loadFile((char *)params))) { cmd = PARSERR_GENERIC; } break; case TOKEN_NAME: setName((char *)params); break; case TOKEN_BACK: delete _back; _back = new UITiledImage(_gameRef); if (!_back || DID_FAIL(_back->loadFile((char *)params))) { delete _back; _back = NULL; cmd = PARSERR_GENERIC; } break; case TOKEN_IMAGE: delete _image; _image = new BaseSprite(_gameRef); if (!_image || DID_FAIL(_image->loadFile((char *)params))) { delete _image; _image = NULL; cmd = PARSERR_GENERIC; } break; case TOKEN_FONT: if (_font) { _gameRef->_fontStorage->removeFont(_font); } _font = _gameRef->_fontStorage->addFont((char *)params); if (!_font) { cmd = PARSERR_GENERIC; } break; case TOKEN_FONT_SELECTED: if (_fontSelected) { _gameRef->_fontStorage->removeFont(_fontSelected); } _fontSelected = _gameRef->_fontStorage->addFont((char *)params); if (!_fontSelected) { cmd = PARSERR_GENERIC; } break; case TOKEN_TEXT: setText((char *)params); _gameRef->_stringTable->expand(&_text); break; case TOKEN_X: parser.scanStr((char *)params, "%d", &_posX); break; case TOKEN_Y: parser.scanStr((char *)params, "%d", &_posY); break; case TOKEN_WIDTH: parser.scanStr((char *)params, "%d", &_width); break; case TOKEN_HEIGHT: parser.scanStr((char *)params, "%d", &_height); break; case TOKEN_MAX_LENGTH: parser.scanStr((char *)params, "%d", &_maxLength); break; case TOKEN_CAPTION: setCaption((char *)params); break; case TOKEN_CURSOR: delete _cursor; _cursor = new BaseSprite(_gameRef); if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) { delete _cursor; _cursor = NULL; cmd = PARSERR_GENERIC; } break; case TOKEN_CURSOR_BLINK_RATE: parser.scanStr((char *)params, "%d", &_cursorBlinkRate); break; case TOKEN_FRAME_WIDTH: parser.scanStr((char *)params, "%d", &_frameWidth); break; case TOKEN_SCRIPT: addScript((char *)params); break; case TOKEN_PARENT_NOTIFY: parser.scanStr((char *)params, "%b", &_parentNotify); break; case TOKEN_DISABLED: parser.scanStr((char *)params, "%b", &_disable); break; case TOKEN_VISIBLE: parser.scanStr((char *)params, "%b", &_visible); break; case TOKEN_EDITOR_PROPERTY: parseEditorProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { _gameRef->LOG(0, "Syntax error in EDIT definition"); return STATUS_FAILED; } if (cmd == PARSERR_GENERIC) { _gameRef->LOG(0, "Error loading EDIT definition"); return STATUS_FAILED; } correctSize(); return STATUS_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// bool BaseScriptHolder::parseProperty(byte *buffer, bool complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(PROPERTY) TOKEN_TABLE(NAME) TOKEN_TABLE(VALUE) TOKEN_TABLE_END byte *params; int cmd; BaseParser parser; if (complete) { if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_PROPERTY) { _gameRef->LOG(0, "'PROPERTY' keyword expected."); return STATUS_FAILED; } buffer = params; } char *propName = NULL; char *propValue = NULL; while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) { switch (cmd) { case TOKEN_NAME: delete[] propName; propName = new char[strlen((char *)params) + 1]; if (propName) { strcpy(propName, (char *)params); } else { cmd = PARSERR_GENERIC; } break; case TOKEN_VALUE: delete[] propValue; propValue = new char[strlen((char *)params) + 1]; if (propValue) { strcpy(propValue, (char *)params); } else { cmd = PARSERR_GENERIC; } break; } } if (cmd == PARSERR_TOKENNOTFOUND) { delete[] propName; delete[] propValue; propName = NULL; propValue = NULL; _gameRef->LOG(0, "Syntax error in PROPERTY definition"); return STATUS_FAILED; } if (cmd == PARSERR_GENERIC || propName == NULL || propValue == NULL) { delete[] propName; delete[] propValue; propName = NULL; propValue = NULL; _gameRef->LOG(0, "Error loading PROPERTY definition"); return STATUS_FAILED; } ScValue *val = new ScValue(_gameRef); val->setString(propValue); scSetProperty(propName, val); delete val; delete[] propName; delete[] propValue; propName = NULL; propValue = NULL; return STATUS_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// bool BaseRegion::loadBuffer(byte *buffer, bool complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE(REGION) TOKEN_TABLE(TEMPLATE) TOKEN_TABLE(NAME) TOKEN_TABLE(ACTIVE) TOKEN_TABLE(POINT) TOKEN_TABLE(CAPTION) TOKEN_TABLE(SCRIPT) TOKEN_TABLE(EDITOR_SELECTED_POINT) TOKEN_TABLE(PROPERTY) TOKEN_TABLE_END byte *params; int cmd; BaseParser parser; if (complete) { if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_REGION) { _gameRef->LOG(0, "'REGION' keyword expected."); return STATUS_FAILED; } buffer = params; } for (uint32 i = 0; i < _points.size(); i++) { delete _points[i]; } _points.clear(); while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) { switch (cmd) { case TOKEN_TEMPLATE: if (DID_FAIL(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", &_active); break; case TOKEN_POINT: { int x, y; parser.scanStr((char *)params, "%d,%d", &x, &y); _points.add(new BasePoint(x, y)); } break; case TOKEN_SCRIPT: addScript((char *)params); break; case TOKEN_EDITOR_SELECTED_POINT: parser.scanStr((char *)params, "%d", &_editorSelectedPoint); break; case TOKEN_PROPERTY: parseProperty(params, false); break; } } if (cmd == PARSERR_TOKENNOTFOUND) { _gameRef->LOG(0, "Syntax error in REGION definition"); return STATUS_FAILED; } createRegion(); return STATUS_OK; }
TOKEN_DEF_END ////////////////////////////////////////////////////////////////////////// HRESULT CBEventSet::LoadBuffer(BYTE * Buffer, bool Complete) { TOKEN_TABLE_START(commands) TOKEN_TABLE (EVENTS) TOKEN_TABLE (EVENT) TOKEN_TABLE (TEMPLATE) TOKEN_TABLE (INIT) TOKEN_TABLE (SHUTDOWN) TOKEN_TABLE (LEFT_CLICK) TOKEN_TABLE (RIGHT_CLICK) TOKEN_TABLE (MIDDLE_CLICK) TOKEN_TABLE (LEFT_RELEASE) TOKEN_TABLE (RIGHT_RELEASE) TOKEN_TABLE (MIDDLE_RELEASE) TOKEN_TABLE (LEFT_DBLCLICK) TOKEN_TABLE (PRESS) TOKEN_TABLE (MOUSE_OVER) TOKEN_TABLE (IDLE) TOKEN_TABLE_END BYTE* params; int cmd; CBParser parser(Game); if(Complete) { if(parser.GetCommand ((char**)&Buffer, commands, (char**)¶ms)!=TOKEN_EVENTS) { Game->LOG(0, "'EVENTS' keyword expected."); return E_FAIL; } Buffer = params; } 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_INIT: m_Events.Add(new CBEvent(Game, EVENT_INIT, (char*)params)); break; case TOKEN_SHUTDOWN: m_Events.Add(new CBEvent(Game, EVENT_SHUTDOWN, (char*)params)); break; case TOKEN_LEFT_CLICK: m_Events.Add(new CBEvent(Game, EVENT_LEFT_CLICK, (char*)params)); break; case TOKEN_RIGHT_CLICK: m_Events.Add(new CBEvent(Game, EVENT_RIGHT_CLICK, (char*)params)); break; case TOKEN_MIDDLE_CLICK: m_Events.Add(new CBEvent(Game, EVENT_MIDDLE_CLICK, (char*)params)); break; case TOKEN_LEFT_RELEASE: m_Events.Add(new CBEvent(Game, EVENT_LEFT_RELEASE, (char*)params)); break; case TOKEN_RIGHT_RELEASE: m_Events.Add(new CBEvent(Game, EVENT_RIGHT_RELEASE, (char*)params)); break; case TOKEN_MIDDLE_RELEASE: m_Events.Add(new CBEvent(Game, EVENT_MIDDLE_RELEASE, (char*)params)); break; case TOKEN_LEFT_DBLCLICK: m_Events.Add(new CBEvent(Game, EVENT_LEFT_DBLCLICK, (char*)params)); break; case TOKEN_PRESS: m_Events.Add(new CBEvent(Game, EVENT_PRESS, (char*)params)); break; case TOKEN_MOUSE_OVER: m_Events.Add(new CBEvent(Game, EVENT_MOUSE_OVER, (char*)params)); break; case TOKEN_IDLE: m_Events.Add(new CBEvent(Game, EVENT_IDLE, (char*)params)); break; case TOKEN_EVENT: { CBEvent* event = new CBEvent(Game); if(event && SUCCEEDED(event->LoadBuffer(params, false))) m_Events.Add(event); else { SAFE_DELETE(event); } } break; } } if (cmd == PARSERR_TOKENNOTFOUND) { Game->LOG(0, "Syntax error in EVENTS definition"); return E_FAIL; } return S_OK; }