uint32 BaseUtils::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 = (byte)(L * 255);
G = (byte)(L * 255);
B = (byte)(L * 255);
} else {
float var1, var2;
if (L < 0.5) {
var2 = L * (1.0 + S);
} else {
var2 = (L + S) - (S * L);
}
var1 = 2.0f * L - var2;
R = (byte)(255 * Hue2RGB(var1, var2, H + (1.0f / 3.0f)));
G = (byte)(255 * Hue2RGB(var1, var2, H));
B = (byte)(255 * Hue2RGB(var1, var2, H - (1.0f / 3.0f)));
}
return BYTETORGBA(255, R, G, B);
}
bool PartParticle::display(PartEmitter *emitter) {
if (!_sprite) {
return STATUS_FAILED;
}
if (_isDead) {
return STATUS_OK;
}
_sprite->getCurrentFrame();
return _sprite->display((int)_pos.x, (int)_pos.y,
nullptr,
_scale, _scale,
BYTETORGBA(255, 255, 255, _currentAlpha),
_rotation,
emitter->_blendMode);
}
void BaseFontTT::drawText(const byte *text, int x, int y, int width, TTextAlign align, int maxHeight, int maxLength) {
if (text == nullptr || strcmp((const char *)text, "") == 0) {
return;
}
WideString textStr;
// TODO: Why do we still insist on Widestrings everywhere?
// HACK: J.U.L.I.A. uses CP1252, we need to fix that,
// And we still don't have any UTF8-support.
if (_gameRef->_textEncoding == TEXT_UTF8) {
textStr = StringUtil::utf8ToWide((const char *)text);
} else {
textStr = StringUtil::ansiToWide((const char *)text);
}
if (maxLength >= 0 && textStr.size() > (uint32)maxLength) {
textStr = WideString(textStr.c_str(), (uint32)maxLength);
}
//text = text.substr(0, MaxLength); // TODO: Remove
BaseRenderer *renderer = _gameRef->_renderer;
// find cached surface, if exists
uint32 minUseTime = UINT_MAX;
int minIndex = -1;
BaseSurface *surface = nullptr;
int textOffset = 0;
for (int i = 0; i < NUM_CACHED_TEXTS; i++) {
if (_cachedTexts[i] == nullptr) {
minUseTime = 0;
minIndex = i;
} else {
if (_cachedTexts[i]->_text == textStr && _cachedTexts[i]->_align == align && _cachedTexts[i]->_width == width && _cachedTexts[i]->_maxHeight == maxHeight && _cachedTexts[i]->_maxLength == maxLength) {
surface = _cachedTexts[i]->_surface;
textOffset = _cachedTexts[i]->_textOffset;
_cachedTexts[i]->_marked = true;
_cachedTexts[i]->_lastUsed = g_system->getMillis();
break;
} else {
if (_cachedTexts[i]->_lastUsed < minUseTime) {
minUseTime = _cachedTexts[i]->_lastUsed;
minIndex = i;
}
}
}
}
// not found, create one
if (!surface) {
debugC(kWintermuteDebugFont, "Draw text: %s", text);
surface = renderTextToTexture(textStr, width, align, maxHeight, textOffset);
if (surface) {
// write surface to cache
if (_cachedTexts[minIndex] != nullptr) {
delete _cachedTexts[minIndex];
}
_cachedTexts[minIndex] = new BaseCachedTTFontText;
_cachedTexts[minIndex]->_surface = surface;
_cachedTexts[minIndex]->_align = align;
_cachedTexts[minIndex]->_width = width;
_cachedTexts[minIndex]->_maxHeight = maxHeight;
_cachedTexts[minIndex]->_maxLength = maxLength;
_cachedTexts[minIndex]->_text = textStr;
_cachedTexts[minIndex]->_textOffset = textOffset;
_cachedTexts[minIndex]->_marked = true;
_cachedTexts[minIndex]->_lastUsed = g_system->getMillis();
}
}
// and paint it
if (surface) {
Rect32 rc;
rc.setRect(0, 0, surface->getWidth(), surface->getHeight());
for (uint32 i = 0; i < _layers.size(); i++) {
uint32 color = _layers[i]->_color;
uint32 origForceAlpha = renderer->_forceAlphaColor;
if (renderer->_forceAlphaColor != 0) {
color = BYTETORGBA(RGBCOLGetR(color), RGBCOLGetG(color), RGBCOLGetB(color), RGBCOLGetA(renderer->_forceAlphaColor));
renderer->_forceAlphaColor = 0;
}
surface->displayTransOffset(x, y - textOffset, rc, color, Graphics::BLEND_NORMAL, false, false, _layers[i]->_offsetX, _layers[i]->_offsetY);
renderer->_forceAlphaColor = origForceAlpha;
}
}
}
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
//////////////////////////////////////////////////////////////////////////
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;
}
uint32 BaseFader::getCurrentColor() const {
return BYTETORGBA(_red, _green, _blue, _currentAlpha);
}
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;
}
