aboutsummaryrefslogtreecommitdiff
path: root/engines/director/lingo/lingo-the.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'engines/director/lingo/lingo-the.cpp')
-rw-r--r--engines/director/lingo/lingo-the.cpp646
1 files changed, 646 insertions, 0 deletions
diff --git a/engines/director/lingo/lingo-the.cpp b/engines/director/lingo/lingo-the.cpp
new file mode 100644
index 0000000000..2bf6cfb724
--- /dev/null
+++ b/engines/director/lingo/lingo-the.cpp
@@ -0,0 +1,646 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "director/lingo/lingo.h"
+#include "director/sprite.h"
+
+namespace Director {
+
+class Sprite;
+
+TheEntity entities[] = {
+ { kTheBeepOn, "beepOn", false }, // D2 property
+ { kTheButtonStyle, "buttonStyle", false }, // D2 p
+ { kTheCast, "cast", true },
+ { kTheCenterStage, "centerStage", false }, // D2 p
+ { kTheCheckBoxAccess, "checkBoxAccess", false }, // D2 p
+ { kTheCheckBoxType, "checkBoxType", false }, // D2 p
+ { kTheClickOn, "clickOn", false }, // D2 function
+ { kTheColorDepth, "colorDepth", false }, // D2 p
+ { kTheColorQD, "colorQD", false }, // D2 f
+ { kTheCommandDown, "commandDown", false }, // D2 f
+ { kTheControlDown, "controlDown", false }, // D2 f
+ { kTheDoubleClick, "doubleClick", false }, // D2 f
+ { kTheExitLock, "exitLock", false }, // D2 p
+ { kTheFixStageSize, "fixStageSize", false }, // D2 p
+ { kTheFloatPrecision, "floatPrecision", false },
+ { kTheFrame, "frame", false }, // D2 f
+ { kTheFreeBlock, "freeBlock", false }, // D2 f
+ { kTheFreeBytes, "freeBytes", false }, // D2 f
+ { kTheFullColorPermit, "fullColorPermit", false }, // D2 p
+ { kTheImageDirect, "imageDirect", false }, // D2 p
+ { kTheItemDelimiter, "itemDelimiter", false },
+ { kTheKey, "key", false }, // D2 f
+ { kTheKeyCode, "keyCode", false }, // D2 f
+ { kTheKeyDownScript, "keyDownScript", false }, // D2 p
+ { kTheLastClick, "lastClick", false }, // D2 f
+ { kTheLastEvent, "lastEvent", false }, // D2 f
+ { kTheLastFrame, "lastFrame", false },
+ { kTheLastKey, "lastKey", false }, // D2 f
+ { kTheLastRoll, "lastRoll", false }, // D2 f
+ { kTheMachineType, "machineType", false }, // D2 f
+ { kTheMemorySize, "memorySize", false }, // D2 f
+ { kTheMenu, "menu", true },
+ { kTheMenus, "menus", false },
+ { kTheMenuItem, "menuitem", true },
+ { kTheMenuItems, "menuitems", false },
+ { kTheMouseDown, "mouseDown", false }, // D2 f
+ { kTheMouseDownScript, "mouseDownScript", false }, // D2 p
+ { kTheMouseH, "mouseH", false }, // D2 f
+ { kTheMouseUp, "mouseUp", false }, // D2 f
+ { kTheMouseUpScript, "mouseUpScript", false }, // D2 p
+ { kTheMouseV, "mouseV", false }, // D2 f
+ { kTheMovie, "movie", false }, // D2 f
+ { kTheMultiSound, "multiSound", false },
+ { kTheOptionDown, "optionDown", false }, // D2 f
+ { kThePathName, "pathName", false }, // D2 f
+ { kThePauseState, "pauseState", false }, // D2 f
+ { kThePerFrameHook, "perFrameHook", false }, // D2 p
+ { kThePreloadEventAbort,"preloadEventAbort",false },
+ { kTheResult, "result", false }, // D2 f
+ { kTheRightMouseDown, "rightMouseDown", false },
+ { kTheRightMouseUp, "rightMouseUp", false },
+ { kTheRomanLingo, "romanLingo", false },
+ { kTheSelection, "selection", false }, // D2 f
+ { kTheShiftDown, "shiftDown", false }, // D2 f
+ { kTheSoundEnabled, "soundEnabled", false }, // D2 p
+ { kTheSoundLevel, "soundLevel", false }, // D2 p
+ { kTheSprite, "sprite", true },
+ { kTheSqrt, "sqrt", false }, // D2 f
+ { kTheStage, "stage", false },
+ { kTheStageBottom, "stageBottom", false }, // D2 f
+ { kTheStageLeft, "stageLeft", false }, // D2 f
+ { kTheStageRight, "stageRight", false }, // D2 f
+ { kTheStageTop, "stageTop", false }, // D2 f
+ { kTheStillDown, "stillDown", false }, // D2 f
+ { kTheSwitchColorDepth, "switchColorDepth", false }, // D2 p
+ { kTheTicks, "ticks", false }, // D2 f
+ { kTheTimeoutKeydown, "timeoutKeydown", false }, // D2 p
+ { kTheTimeoutLapsed, "timeoutLapsed", false }, // D2 p
+ { kTheTimeoutLength, "timeoutLength", false }, // D2 p
+ { kTheTimeoutMouse, "timeoutMouse", false }, // D2 p
+ { kTheTimeoutPlay, "timeoutPlay", false }, // D2 p
+ { kTheTimeoutScript, "timeoutScript", false }, // D2 p
+ { kTheTimer, "timer", false }, // D2 p
+ { kTheWindow, "window", false },
+ { kTheNOEntity, NULL, false }
+};
+
+TheEntityField fields[] = {
+ { kTheSprite, "backColor", kTheBackColor }, // D2 p
+ { kTheSprite, "blend", kTheBlend },
+ { kTheSprite, "bottom", kTheBottom }, // D2 p
+ { kTheSprite, "castNum", kTheCastNum }, // D2 p
+ { kTheSprite, "constraint", kTheConstraint }, // D2 p
+ { kTheSprite, "cursor", kTheCursor }, // D2 p
+ { kTheSprite, "editableText", kTheEditableText },
+ { kTheSprite, "foreColor", kTheForeColor }, // D2 p
+ { kTheSprite, "height", kTheHeight }, // D2 p
+ { kTheSprite, "immediate", kTheImmediate }, // D2 p
+ { kTheSprite, "ink", kTheInk }, // D2 p
+ { kTheSprite, "left", kTheLeft }, // D2 p
+ { kTheSprite, "lineSize", kTheLineSize }, // D2 p
+ { kTheSprite, "locH", kTheLocH }, // D2 p
+ { kTheSprite, "locV", kTheLocV }, // D2 p
+ { kTheSprite, "moveable", kTheMoveable },
+ { kTheSprite, "movieRate", kTheMovieRate },
+ { kTheSprite, "movieTime", kTheMovieTime },
+ { kTheSprite, "pattern", kThePattern }, // D2 p
+ { kTheSprite, "puppet", kThePuppet }, // D2 p
+ { kTheSprite, "right", kTheRight }, // D2 p
+ { kTheSprite, "scriptNum", kTheScriptNum },
+ { kTheSprite, "startTime", kTheStartTime },
+ { kTheSprite, "stretch", kTheStrech }, // D2 p
+ { kTheSprite, "stopTime", kTheStopTime },
+ { kTheSprite, "top", kTheTop }, // D2 p
+ { kTheSprite, "trails", kTheTrails },
+ { kTheSprite, "type", kTheType }, // D2 p
+ { kTheSprite, "visible", kTheVisible },
+ { kTheSprite, "volume", kTheVolume },
+ { kTheSprite, "width", kTheWidth }, // D2 p
+
+ // Common cast fields
+ { kTheCast, "castType", kTheCastType },
+ { kTheCast, "filename", kTheFilename },
+ { kTheCast, "height", kTheHeight },
+ { kTheCast, "loaded", kTheLoaded },
+ { kTheCast, "modified", kTheModified },
+ { kTheCast, "name", kTheName },
+ { kTheCast, "number", kTheNumber },
+ { kTheCast, "rect", kTheRect },
+ { kTheCast, "purgePriority",kThePurgePriority }, // 0 Never purge, 1 Purge Last, 2 Purge next, 2 Purge normal
+ { kTheCast, "scriptText", kTheScriptText },
+ { kTheCast, "width", kTheWidth },
+
+ // Shape fields
+ { kTheCast, "backColor", kTheBackColor },
+ { kTheCast, "foreColor", kTheForeColor },
+
+ // Digital video fields
+ { kTheCast, "controller", kTheController },
+ { kTheCast, "directToStage",kTheDirectToStage },
+ { kTheCast, "frameRate", kTheFrameRate },
+ { kTheCast, "loop", kTheLoop },
+ { kTheCast, "pausedAtStart",kThePausedAtStart },
+ { kTheCast, "preload", kThePreload },
+ { kTheCast, "sound", kTheSound }, // 0-1 off-on
+
+ // Bitmap fields
+ { kTheCast, "depth", kTheDepth },
+ { kTheCast, "regPoint", kTheRegPoint },
+ { kTheCast, "palette", kThePalette },
+ { kTheCast, "picture", kThePicture },
+
+ // TextCast fields
+ { kTheCast, "hilite", kTheHilite }, // D2 p
+ { kTheCast, "selEnd", kTheSelEnd }, // D2 p
+ { kTheCast, "selStart", kTheSelStart }, // D2 p
+ { kTheCast, "size", kTheSize },
+ { kTheCast, "text", kTheText }, // D2 p
+
+ { kTheWindow, "drawRect", kTheDrawRect },
+ { kTheWindow, "filename", kTheFilename },
+ { kTheWindow, "sourceRect", kTheSourceRect },
+ { kTheWindow, "visible", kTheVisible },
+
+ { kTheMenuItem, "checkmark", kTheCheckMark },
+ { kTheMenuItem, "enabled", kTheEnabled },
+ { kTheMenuItem, "name", kTheName },
+ { kTheMenuItem, "script", kTheScript },
+
+ { kTheMenu, "name", kTheName },
+
+ { kTheMenuItems,"number", kTheNumber },
+ { kTheMenus, "number", kTheNumber },
+
+ { kTheNOEntity, NULL, kTheNOField }
+};
+
+void Lingo::initTheEntities() {
+ TheEntity *e = entities;
+
+ while (e->entity != kTheNOEntity) {
+ _theEntities[e->name] = e;
+ e++;
+ }
+
+ TheEntityField *f = fields;
+
+ while (f->entity != kTheNOEntity) {
+ _theEntityFields[Common::String::format("%d%s", f->entity, f->name)] = f;
+ f++;
+ }
+}
+
+void Lingo::setTheEntity(int entity, Datum &id, int field, Datum &d) {
+ switch (entity) {
+ case kTheSprite:
+ setTheSprite(id, field, d);
+ break;
+ case kThePerFrameHook:
+ warning("STUB: setting the perframehook");
+ break;
+ case kTheFloatPrecision:
+ _floatPrecision = d.toInt();
+ _floatPrecision = MAX(0, MIN(_floatPrecision, 19)); // 0 to 19
+ _floatPrecisionFormat = Common::String::format("%%.%df", _floatPrecision);
+ warning("set to %d: %s", _floatPrecision, _floatPrecisionFormat.c_str());
+ break;
+ default:
+ warning("Unprocessed setting field %d of entity %d", field, entity);
+ }
+}
+
+void Lingo::setTheSprite(Datum &id1, int field, Datum &d) {
+ int id = 0;
+
+ if (id1.type == INT) {
+ id = id1.u.i;
+ } else {
+ warning("Unknown the sprite id type: %s", id1.type2str());
+ return;
+ }
+
+ d.toInt(); // Enforce Integer
+
+ if (!_vm->_currentScore) {
+ warning("The sprite %d field %d setting over non-active score", id, field);
+ return;
+ }
+
+ Sprite *sprite = _vm->_currentScore->getSpriteById(id);
+
+ if (!sprite)
+ return;
+
+ switch (field) {
+ case kTheCastNum:
+ if (_vm->_currentScore->_casts.contains(d.u.i)) {
+ sprite->_cast = _vm->_currentScore->_casts[d.u.i];
+ sprite->_castId = d.u.i;
+ }
+ break;
+ case kTheWidth:
+ sprite->_width = d.u.i;
+ break;
+ case kTheHeight:
+ sprite->_height = d.u.i;
+ break;
+ case kTheTrails:
+ sprite->_trails = d.u.i;
+ break;
+ case kTheInk:
+ sprite->_ink = static_cast<InkType>(d.u.i);
+ break;
+ case kTheLocH:
+ sprite->_startPoint.x = d.u.i;
+ break;
+ case kTheLocV:
+ sprite->_startPoint.y = d.u.i;
+ break;
+ case kTheConstraint:
+ sprite->_constraint = d.u.i;
+ break;
+ case kTheMoveable:
+ sprite->_moveable = d.u.i;
+ break;
+ case kTheBackColor:
+ sprite->_backColor = d.u.i;
+ break;
+ case kTheForeColor:
+ sprite->_foreColor = d.u.i;
+ break;
+ case kTheLeft:
+ sprite->_left = d.u.i;
+ break;
+ case kTheRight:
+ sprite->_right = d.u.i;
+ break;
+ case kTheTop:
+ sprite->_top = d.u.i;
+ break;
+ case kTheBottom:
+ sprite->_bottom = d.u.i;
+ break;
+ case kTheBlend:
+ sprite->_blend = d.u.i;
+ break;
+ case kTheVisible:
+ sprite->_visible = (d.u.i == 0 ? false : true);
+ break;
+ case kTheType:
+ sprite->_type = static_cast<SpriteType>(d.u.i);
+ break;
+ case kTheMovieRate:
+ sprite->_movieRate = d.u.i;
+ break;
+ case kTheMovieTime:
+ sprite->_movieTime = d.u.i;
+ break;
+ case kTheStopTime:
+ sprite->_stopTime = d.u.i;
+ break;
+ case kTheStartTime:
+ sprite->_startTime = d.u.i;
+ break;
+ case kTheStretch:
+ sprite->_stretch = d.u.i;
+ break;
+ case kTheVolume:
+ sprite->_volume = d.u.i;
+ break;
+ case kTheLineSize:
+ sprite->_lineSize = d.u.i;
+ break;
+ case kTheEditableText:
+ sprite->_editableText = *d.toString();
+ break;
+ default:
+ warning("Unprocessed setting field %d of sprite", field);
+ }
+}
+
+Datum Lingo::getTheEntity(int entity, Datum &id, int field) {
+ Datum d;
+
+ switch (entity) {
+ case kTheSprite:
+ d = getTheSprite(id, field);
+ break;
+ case kTheCast:
+ d = getTheCast(id, field);
+ break;
+ case kThePerFrameHook:
+ warning("STUB: getting the perframehook");
+ break;
+ case kTheFloatPrecision:
+ d.type = INT;
+ d.u.i = _floatPrecision;
+ break;
+ case kTheSqrt:
+ id.toFloat();
+ d.type = FLOAT;
+ d.u.f = sqrt(id.u.f);
+ break;
+ default:
+ warning("Unprocessed getting field %d of entity %d", field, entity);
+ d.type = VOID;
+ }
+
+ return d;
+}
+
+Datum Lingo::getTheSprite(Datum &id1, int field) {
+ Datum d;
+ int id = 0;
+
+ if (id1.type == INT) {
+ id = id1.u.i;
+ } else {
+ warning("Unknown the sprite id type: %s", id1.type2str());
+ return d;
+ }
+
+ if (!_vm->_currentScore) {
+ warning("The sprite %d field %d setting over non-active score", id, field);
+ return d;
+ }
+
+ Sprite *sprite = _vm->_currentScore->getSpriteById(id);
+
+ if (!sprite)
+ return d;
+
+ d.type = INT;
+
+ switch (field) {
+ case kTheCastNum:
+ d.u.i = sprite->_castId;
+ break;
+ case kTheWidth:
+ d.u.i = sprite->_width;
+ break;
+ case kTheHeight:
+ d.u.i = sprite->_height;
+ break;
+ case kTheTrails:
+ d.u.i = sprite->_trails;
+ break;
+ case kTheInk:
+ d.u.i = sprite->_ink;
+ break;
+ case kTheLocH:
+ d.u.i = sprite->_startPoint.x;
+ break;
+ case kTheLocV:
+ d.u.i = sprite->_startPoint.y;
+ break;
+ case kTheConstraint:
+ d.u.i = sprite->_constraint;
+ break;
+ case kTheMoveable:
+ d.u.i = sprite->_moveable;
+ break;
+ case kTheBackColor:
+ d.u.i = sprite->_backColor;
+ break;
+ case kTheForeColor:
+ d.u.i = sprite->_foreColor;
+ break;
+ case kTheLeft:
+ d.u.i = sprite->_left;
+ break;
+ case kTheRight:
+ d.u.i = sprite->_right;
+ break;
+ case kTheBottom:
+ d.u.i = sprite->_bottom;
+ break;
+ case kTheTop:
+ d.u.i = sprite->_top;
+ break;
+ case kTheBlend:
+ d.u.i = sprite->_blend;
+ break;
+ case kTheVisible:
+ d.u.i = (sprite->_visible ? 1 : 0);
+ break;
+ case kTheType:
+ d.u.i = sprite->_type;
+ break;
+ case kTheMovieRate:
+ d.u.i = sprite->_movieRate;
+ break;
+ case kTheMovieTime:
+ d.u.i = sprite->_movieTime;
+ break;
+ case kTheStopTime:
+ d.u.i = sprite->_stopTime;
+ break;
+ case kTheStartTime:
+ d.u.i = sprite->_startTime;
+ break;
+ case kTheVolume:
+ d.u.i = sprite->_volume;
+ break;
+ case kTheStretch:
+ d.u.i = sprite->_stretch;
+ break;
+ case kTheLineSize:
+ d.u.i = sprite->_lineSize;
+ break;
+ case kTheEditableText:
+ d.toString();
+ d.u.s = &sprite->_editableText;
+ break;
+ default:
+ warning("Unprocessed getting field %d of sprite", field);
+ d.type = VOID;
+ }
+
+ return d;
+}
+
+Datum Lingo::getTheCast(Datum &id1, int field) {
+ Datum d;
+ int id = 0;
+
+ if (id1.type == INT) {
+ id = id1.u.i;
+ } else {
+ warning("Unknown the cast id type: %s", id1.type2str());
+ return d;
+ }
+
+ if (!_vm->_currentScore) {
+ warning("The cast %d field %d setting over non-active score", id, field);
+ return d;
+ }
+
+ Cast *cast;
+ CastInfo *castInfo;
+ if (!_vm->_currentScore->_casts.contains(id)) {
+ if (field == kTheLoaded) {
+ d.type = INT;
+ d.u.i = 0;
+ }
+
+ return d;
+ } else {
+ warning("The cast %d found", id);
+ }
+
+ cast = _vm->_currentScore->_casts[id];
+ castInfo = _vm->_currentScore->_castsInfo[id];
+
+ d.type = INT;
+
+ switch (field) {
+ case kTheCastType:
+ d.u.i = cast->type;
+ break;
+ case kTheFilename:
+ d.toString();
+ d.u.s = &castInfo->fileName;
+ break;
+ case kTheName:
+ d.toString();
+ d.u.s = &castInfo->name;
+ break;
+ case kTheScriptText:
+ d.toString();
+ d.u.s = &castInfo->script;
+ break;
+ case kTheWidth:
+ d.u.i = cast->initialRect.width();
+ break;
+ case kTheHeight:
+ d.u.i = cast->initialRect.height();
+ break;
+ case kTheBackColor:
+ {
+ if (cast->type != kCastShape) {
+ warning("Field %d of cast %d not found", field, id);
+ d.type = VOID;
+ return d;
+ }
+
+ ShapeCast *shape = static_cast<ShapeCast *>(_vm->_currentScore->_casts[id]);
+ d.u.i = shape->bgCol;
+ }
+ break;
+ case kTheForeColor:
+ {
+ if (cast->type != kCastShape) {
+ warning("Field %d of cast %d not found", field, id);
+ d.type = VOID;
+ return d;
+ }
+
+ ShapeCast *shape = static_cast<ShapeCast *>(_vm->_currentScore->_casts[id]);
+ d.u.i = shape->fgCol;
+ }
+ break;
+ case kTheLoaded:
+ d.u.i = 1; //Not loaded handled above
+ break;
+ default:
+ warning("Unprocessed getting field %d of cast %d", field, id);
+ d.type = VOID;
+ //TODO find out about String fields
+ }
+
+ return d;
+}
+
+void Lingo::setTheCast(Datum &id1, int field, Datum &d) {
+ int id = 0;
+
+ if (id1.type == INT) {
+ id = id1.u.i;
+ } else {
+ warning("Unknown the cast id type: %s", id1.type2str());
+ return;
+ }
+
+ if (!_vm->_currentScore) {
+ warning("The cast %d field %d setting over non-active score", id, field);
+ return;
+ }
+
+ Cast *cast = _vm->_currentScore->_casts[id];
+ CastInfo *castInfo = _vm->_currentScore->_castsInfo[id];
+
+ if (!cast) {
+ warning("The cast %d found", id);
+ return;
+ }
+
+ switch (field) {
+ case kTheCastType:
+ cast->type = static_cast<CastType>(d.u.i);
+ cast->modified = 1;
+ break;
+ case kTheFilename:
+ castInfo->fileName = *d.u.s;
+ break;
+ case kTheName:
+ castInfo->name = *d.u.s;
+ break;
+ case kTheScriptText:
+ castInfo->script = *d.u.s;
+ break;
+ case kTheWidth:
+ cast->initialRect.setWidth(d.u.i);
+ cast->modified = 1;
+ break;
+ case kTheHeight:
+ cast->initialRect.setHeight(d.u.i);
+ cast->modified = 1;
+ break;
+ case kTheBackColor:
+ {
+ if (cast->type != kCastShape) {
+ warning("Field %d of cast %d not found", field, id);
+ }
+ ShapeCast *shape = static_cast<ShapeCast *>(_vm->_currentScore->_casts[id]);
+ shape->bgCol = d.u.i;
+ shape->modified = 1;
+ }
+ break;
+ case kTheForeColor:
+ {
+ if (cast->type != kCastShape) {
+ warning("Field %d of cast %d not found", field, id);
+ return;
+ }
+ ShapeCast *shape = static_cast<ShapeCast *>(_vm->_currentScore->_casts[id]);
+ shape->fgCol = d.u.i;
+ shape->modified = 1;
+ }
+ break;
+ default:
+ warning("Unprocessed getting field %d of cast %d", field, id);
+ }
+}
+
+} // End of namespace Director
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-24 04:48:35 +0000