[Scummvm-git-logs] scummvm master -> 485a229007159c2069c8a340036fc10769151e2e

mgerhardy martin.gerhardy at gmail.com
Fri Feb 26 10:19:49 UTC 2021


This automated email contains information about 13 new commits which have been
pushed to the 'scummvm' repo located at https://github.com/scummvm/scummvm .

Summary:
b917ec2ad3 TWINE: convert ExtraListStruct positions to Vec3
56b9d68bb0 TWINE: replaced magic number with constant
c702e0955e TWINE: use Vec3 operators
d1b67f614e TWINE: converted projPosScreen to Vec3
a7aaa2c7db TWINE: converted baseRotPos to Vec3
517f51ae05 TWINE: converted orthoProjPos to Vec3
89921cac57 TWINE: converted projPosScreen to Vec3
718ef4a58f TWINE: converted destXYZ to Vec3
9743f36d95 TWINE: converted Renderer class members to Vec3
9275999d9b TWINE: hide min/max values of inventory items
bbe4083ab0 TWINE: use a few of the inventory setters to ensure the item amount boundaries
b45b3bb6c0 TWINE: don't clamp the given values to short
485a229007 AGS: fixed potential buffer overflows due to missing null byte


Commit: b917ec2ad31978d8a1dd59d45a29ae71b20ad214
    https://github.com/scummvm/scummvm/commit/b917ec2ad31978d8a1dd59d45a29ae71b20ad214
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2021-02-26T11:11:20+01:00

Commit Message:
TWINE: convert ExtraListStruct positions to Vec3

Changed paths:
    engines/twine/renderer/redraw.cpp
    engines/twine/scene/collision.cpp
    engines/twine/scene/extra.cpp
    engines/twine/scene/extra.h
    engines/twine/scene/movements.cpp


diff --git a/engines/twine/renderer/redraw.cpp b/engines/twine/renderer/redraw.cpp
index 199eaf5cc0..8a720113ac 100644
--- a/engines/twine/renderer/redraw.cpp
+++ b/engines/twine/renderer/redraw.cpp
@@ -280,23 +280,23 @@ int32 Redraw::fillExtraDrawingList(int32 drawListPos) {
 			if (_engine->lbaTime - extra->spawnTime > 35) {
 				extra->spawnTime = _engine->lbaTime;
 				extra->type &= ~ExtraType::TIME_IN;
-				_engine->_sound->playSample(Samples::ItemPopup, 1, extra->x, extra->y, extra->z);
+				_engine->_sound->playSample(Samples::ItemPopup, 1, extra->pos);
 			}
 			continue;
 		}
 		if ((extra->type & ExtraType::TIME_OUT) || (extra->type & ExtraType::FLASH) || (extra->payload.lifeTime + extra->spawnTime - 150 < _engine->lbaTime) || (!((_engine->lbaTime + extra->spawnTime) & 8))) {
-			_engine->_renderer->projectPositionOnScreen(extra->x - _engine->_grid->camera.x, extra->y - _engine->_grid->camera.y, extra->z - _engine->_grid->camera.z);
+			_engine->_renderer->projectPositionOnScreen(extra->pos.x - _engine->_grid->camera.x, extra->pos.y - _engine->_grid->camera.y, extra->pos.z - _engine->_grid->camera.z);
 
 			if (_engine->_renderer->projPosX > -50 && _engine->_renderer->projPosX < _engine->width() + 40 && _engine->_renderer->projPosY > -30 && _engine->_renderer->projPosY < _engine->height() + 100) {
-				drawList[drawListPos].posValue = extra->x - _engine->_grid->camera.x + extra->z - _engine->_grid->camera.z;
+				drawList[drawListPos].posValue = extra->pos.x - _engine->_grid->camera.x + extra->pos.z - _engine->_grid->camera.z;
 				drawList[drawListPos].actorIdx = i;
 				drawList[drawListPos].type = DrawListType::DrawExtras;
 				drawListPos++;
 
 				if (_engine->cfgfile.ShadowMode == 2 && !(extra->info0 & 0x8000)) {
-					_engine->_movements->getShadowPosition(extra->x, extra->y, extra->z);
+					_engine->_movements->getShadowPosition(extra->pos.x, extra->pos.y, extra->pos.z);
 
-					drawList[drawListPos].posValue = extra->x - _engine->_grid->camera.x + extra->z - _engine->_grid->camera.z - 1;
+					drawList[drawListPos].posValue = extra->pos.x - _engine->_grid->camera.x + extra->pos.z - _engine->_grid->camera.z - 1;
 					drawList[drawListPos].actorIdx = 0;
 					drawList[drawListPos].type = DrawListType::DrawShadows;
 					drawList[drawListPos].x = _engine->_actor->shadowCoord.x;
@@ -461,7 +461,7 @@ void Redraw::processDrawListExtras(const DrawListStruct &drawCmd) {
 	int32 actorIdx = drawCmd.actorIdx;
 	ExtraListStruct *extra = &_engine->_extra->extraList[actorIdx];
 
-	_engine->_renderer->projectPositionOnScreen(extra->x - _engine->_grid->camera.x, extra->y - _engine->_grid->camera.y, extra->z - _engine->_grid->camera.z);
+	_engine->_renderer->projectPositionOnScreen(extra->pos - _engine->_grid->camera);
 
 	if (extra->info0 & 0x8000) {
 		_engine->_extra->drawExtraSpecial(actorIdx, _engine->_renderer->projPosX, _engine->_renderer->projPosY);
diff --git a/engines/twine/scene/collision.cpp b/engines/twine/scene/collision.cpp
index 154523c2f2..edbe22eb90 100644
--- a/engines/twine/scene/collision.cpp
+++ b/engines/twine/scene/collision.cpp
@@ -464,12 +464,12 @@ void Collision::stopFalling() { // ReceptionObj()
 
 int32 Collision::checkExtraCollisionWithActors(ExtraListStruct *extra, int32 actorIdx) {
 	const BoundingBox *bbox = _engine->_resources->spriteBoundingBox.bbox(extra->info0);
-	const int32 xLeft = bbox->mins.x + extra->x;
-	const int32 xRight = bbox->maxs.x + extra->x;
-	const int32 yLeft = bbox->mins.y + extra->y;
-	const int32 yRight = bbox->maxs.y + extra->y;
-	const int32 zLeft = bbox->mins.z + extra->z;
-	const int32 zRight = bbox->maxs.z + extra->z;
+	const int32 xLeft = bbox->mins.x + extra->pos.x;
+	const int32 xRight = bbox->maxs.x + extra->pos.x;
+	const int32 yLeft = bbox->mins.y + extra->pos.y;
+	const int32 yRight = bbox->maxs.y + extra->pos.y;
+	const int32 zLeft = bbox->mins.z + extra->pos.z;
+	const int32 zRight = bbox->maxs.z + extra->pos.z;
 
 	for (int32 a = 0; a < _engine->_scene->sceneNumActors; a++) {
 		const ActorStruct *actorTest = _engine->_scene->getActor(a);
@@ -522,24 +522,24 @@ bool Collision::checkExtraCollisionWithBricks(int32 x, int32 y, int32 z, int32 o
 int32 Collision::checkExtraCollisionWithExtra(ExtraListStruct *extra, int32 extraIdx) const {
 	int32 index = extra->info0;
 	const BoundingBox *bbox = _engine->_resources->spriteBoundingBox.bbox(index);
-	const int32 xLeft = bbox->mins.x + extra->x;
-	const int32 xRight = bbox->maxs.x + extra->x;
-	const int32 yLeft = bbox->mins.y + extra->y;
-	const int32 yRight = bbox->maxs.y + extra->y;
-	const int32 zLeft = bbox->mins.z + extra->z;
-	const int32 zRight = bbox->maxs.z + extra->z;
+	const int32 xLeft = bbox->mins.x + extra->pos.x;
+	const int32 xRight = bbox->maxs.x + extra->pos.x;
+	const int32 yLeft = bbox->mins.y + extra->pos.y;
+	const int32 yRight = bbox->maxs.y + extra->pos.y;
+	const int32 zLeft = bbox->mins.z + extra->pos.z;
+	const int32 zRight = bbox->maxs.z + extra->pos.z;
 
 	for (int32 i = 0; i < EXTRA_MAX_ENTRIES; i++) {
 		const ExtraListStruct *extraTest = &_engine->_extra->extraList[i];
 		if (i != extraIdx && extraTest->info0 != -1) {
 			// TODO: shouldn't this be extraTest->info0 as index?
 			const BoundingBox *testbbox = _engine->_resources->spriteBoundingBox.bbox(++index);
-			const int32 xLeftTest = testbbox->mins.x + extraTest->x;
-			const int32 xRightTest = testbbox->maxs.x + extraTest->x;
-			const int32 yLeftTest = testbbox->mins.y + extraTest->y;
-			const int32 yRightTest = testbbox->maxs.y + extraTest->y;
-			const int32 zLeftTest = testbbox->mins.z + extraTest->z;
-			const int32 zRightTest = testbbox->maxs.z + extraTest->z;
+			const int32 xLeftTest = testbbox->mins.x + extraTest->pos.x;
+			const int32 xRightTest = testbbox->maxs.x + extraTest->pos.x;
+			const int32 yLeftTest = testbbox->mins.y + extraTest->pos.y;
+			const int32 yRightTest = testbbox->maxs.y + extraTest->pos.y;
+			const int32 zLeftTest = testbbox->mins.z + extraTest->pos.z;
+			const int32 zRightTest = testbbox->maxs.z + extraTest->pos.z;
 
 			if (xLeft < xLeftTest) {
 				if (xLeft < xRightTest && xRight > xLeftTest && yLeft < yRightTest && yRight > yLeftTest && zLeft < zRightTest && zRight > zLeftTest) {
diff --git a/engines/twine/scene/extra.cpp b/engines/twine/scene/extra.cpp
index 2b557dcc61..9251393909 100644
--- a/engines/twine/scene/extra.cpp
+++ b/engines/twine/scene/extra.cpp
@@ -115,12 +115,12 @@ int32 Extra::addExtra(int32 actorIdx, int32 x, int32 y, int32 z, int32 spriteIdx
 		extra->info0 = spriteIdx;
 		extra->type = ExtraType::UNK7;
 		extra->info1 = 0;
-		extra->x = x;
-		extra->y = y;
-		extra->z = z;
+		extra->pos.x = x;
+		extra->pos.y = y;
+		extra->pos.z = z;
 		extra->payload.actorIdx = actorIdx;
 		extra->spawnTime = targetActor;
-		extra->destZ = maxSpeed;
+		extra->destPos.z = maxSpeed;
 		extra->strengthOfHit = strengthOfHit;
 
 		_engine->_movements->setActorAngle(ANGLE_0, maxSpeed, ANGLE_17, &extra->trackActorMove);
@@ -140,9 +140,9 @@ int32 Extra::addExtraExplode(int32 x, int32 y, int32 z) {
 		extra->info0 = SPRITEHQR_EXPLOSION_FIRST_FRAME;
 		extra->type = ExtraType::TIME_OUT | ExtraType::EXPLOSION;
 		extra->info1 = 0;
-		extra->x = x;
-		extra->y = y;
-		extra->z = z;
+		extra->pos.x = x;
+		extra->pos.y = y;
+		extra->pos.z = z;
 		extra->payload.lifeTime = 40;
 		extra->spawnTime = _engine->lbaTime;
 		extra->strengthOfHit = 0;
@@ -162,18 +162,18 @@ void Extra::resetExtras() {
 void Extra::throwExtra(ExtraListStruct *extra, int32 xAngle, int32 yAngle, int32 x, int32 extraAngle) { // InitFly
 	extra->type |= ExtraType::FLY;
 
-	extra->lastX = extra->x;
-	extra->lastY = extra->y;
-	extra->lastZ = extra->z;
+	extra->lastPos.x = extra->pos.x;
+	extra->lastPos.y = extra->pos.y;
+	extra->lastPos.z = extra->pos.z;
 
 	_engine->_movements->rotateActor(x, 0, xAngle);
 
-	extra->destY = -_engine->_renderer->destZ;
+	extra->destPos.y = -_engine->_renderer->destZ;
 
 	_engine->_movements->rotateActor(0, _engine->_renderer->destX, yAngle);
 
-	extra->destX = _engine->_renderer->destX;
-	extra->destZ = _engine->_renderer->destZ;
+	extra->destPos.x = _engine->_renderer->destX;
+	extra->destPos.z = _engine->_renderer->destZ;
 
 	extra->angle = extraAngle;
 	extra->spawnTime = _engine->lbaTime;
@@ -193,9 +193,9 @@ int32 Extra::addExtraSpecial(int32 x, int32 y, int32 z, ExtraSpecialType type) {
 		if (type == ExtraSpecialType::kHitStars) {
 			extra->type = ExtraType::TIME_OUT | ExtraType::UNK3;
 
-			extra->x = x;
-			extra->y = y;
-			extra->z = z;
+			extra->pos.x = x;
+			extra->pos.y = y;
+			extra->pos.z = z;
 
 			// same as InitFly
 			throwExtra(extra, _engine->getRandomNumber(ANGLE_90) + ANGLE_45, _engine->getRandomNumber(ANGLE_360), 50, 20);
@@ -205,9 +205,9 @@ int32 Extra::addExtraSpecial(int32 x, int32 y, int32 z, ExtraSpecialType type) {
 		} else if (type == ExtraSpecialType::kExplodeCloud) {
 			extra->type = ExtraType::TIME_OUT;
 
-			extra->x = x;
-			extra->y = y;
-			extra->z = z;
+			extra->pos.x = x;
+			extra->pos.y = y;
+			extra->pos.z = z;
 
 			extra->strengthOfHit = 0;
 			extra->spawnTime = _engine->lbaTime;
@@ -266,9 +266,9 @@ int32 Extra::addExtraBonus(int32 x, int32 y, int32 z, int32 xAngle, int32 yAngle
 			extra->type = ExtraFlag::STOP_COL | ExtraFlag::TAKABLE | ExtraFlag::BONUS;
 		}*/
 
-		extra->x = x;
-		extra->y = y;
-		extra->z = z;
+		extra->pos.x = x;
+		extra->pos.y = y;
+		extra->pos.z = z;
 
 		// same as InitFly
 		throwExtra(extra, xAngle, yAngle, 40, ToAngle(15));
@@ -290,9 +290,9 @@ int32 Extra::addExtraThrow(int32 actorIdx, int32 x, int32 y, int32 z, int32 spri
 		}
 		extra->info0 = spriteIdx;
 		extra->type = ExtraType::UNK2 | ExtraType::UNK3 | ExtraType::UNK8 | ExtraType::WAIT_NO_COL;
-		extra->x = x;
-		extra->y = y;
-		extra->z = z;
+		extra->pos.x = x;
+		extra->pos.y = y;
+		extra->pos.z = z;
 
 		// same as InitFly
 		throwExtra(extra, xAngle, yAngle, xRotPoint, extraAngle);
@@ -317,12 +317,12 @@ int32 Extra::addExtraAiming(int32 actorIdx, int32 x, int32 y, int32 z, int32 spr
 		extra->info0 = spriteIdx;
 		extra->type = ExtraType::UNK7;
 		extra->info1 = 0;
-		extra->x = x;
-		extra->y = y;
-		extra->z = z;
+		extra->pos.x = x;
+		extra->pos.y = y;
+		extra->pos.z = z;
 		extra->payload.actorIdx = actorIdx;
 		extra->spawnTime = targetActorIdx;
-		extra->destZ = finalAngle;
+		extra->destPos.z = finalAngle;
 		extra->strengthOfHit = strengthOfHit;
 		_engine->_movements->setActorAngle(ANGLE_0, finalAngle, ANGLE_17, &extra->trackActorMove);
 		const ActorStruct *actor = _engine->_scene->getActor(targetActorIdx);
@@ -356,14 +356,14 @@ int32 Extra::addExtraAimingAtKey(int32 actorIdx, int32 x, int32 y, int32 z, int3
 		extra->info0 = spriteIdx;
 		extra->type = ExtraType::UNK9;
 		extra->info1 = 0;
-		extra->x = x;
-		extra->y = y;
-		extra->z = z;
+		extra->pos.x = x;
+		extra->pos.y = y;
+		extra->pos.z = z;
 		extra->payload.extraIdx = extraIdx;
-		extra->destZ = 4000;
+		extra->destPos.z = 4000;
 		extra->strengthOfHit = 0;
 		_engine->_movements->setActorAngle(ANGLE_0, 4000, ANGLE_17, &extra->trackActorMove);
-		extra->angle = _engine->_movements->getAngleAndSetTargetActorDistance(x, z, extraList[extraIdx].x, extraList[extraIdx].z);
+		extra->angle = _engine->_movements->getAngleAndSetTargetActorDistance(x, z, extraList[extraIdx].pos.x, extraList[extraIdx].pos.z);
 
 		return i;
 	}
@@ -534,22 +534,22 @@ void Extra::drawExtraSpecial(int32 extraIdx, int32 x, int32 y) {
 }
 
 void Extra::processMagicballBounce(ExtraListStruct *extra, int32 x, int32 y, int32 z) {
-	if (_engine->_grid->getBrickShape(x, extra->y, z) != ShapeType::kNone) {
-		extra->destY = -extra->destY;
+	if (_engine->_grid->getBrickShape(x, extra->pos.y, z) != ShapeType::kNone) {
+		extra->destPos.y = -extra->destPos.y;
 	}
-	if (_engine->_grid->getBrickShape(extra->x, y, z) != ShapeType::kNone) {
-		extra->destX = -extra->destX;
+	if (_engine->_grid->getBrickShape(extra->pos.x, y, z) != ShapeType::kNone) {
+		extra->destPos.x = -extra->destPos.x;
 	}
-	if (_engine->_grid->getBrickShape(x, y, extra->z) != ShapeType::kNone) {
-		extra->destZ = -extra->destZ;
+	if (_engine->_grid->getBrickShape(x, y, extra->pos.z) != ShapeType::kNone) {
+		extra->destPos.z = -extra->destPos.z;
 	}
 
-	extra->x = x;
-	extra->lastX = x;
-	extra->y = y;
-	extra->lastY = y;
-	extra->z = z;
-	extra->lastZ = z;
+	extra->pos.x = x;
+	extra->lastPos.x = x;
+	extra->pos.y = y;
+	extra->lastPos.y = y;
+	extra->pos.z = z;
+	extra->lastPos.z = z;
 
 	extra->spawnTime = _engine->lbaTime;
 }
@@ -584,20 +584,20 @@ void Extra::processExtras() {
 		}
 		// process extra moving
 		if (extra->type & ExtraType::FLY) {
-			currentExtraX = extra->x;
-			currentExtraY = extra->y;
-			currentExtraZ = extra->z;
+			currentExtraX = extra->pos.x;
+			currentExtraY = extra->pos.y;
+			currentExtraZ = extra->pos.z;
 
-			const int32 currentExtraSpeedX = extra->destX * deltaT;
-			extra->x = currentExtraSpeedX + extra->lastX;
+			const int32 currentExtraSpeedX = extra->destPos.x * deltaT;
+			extra->pos.x = currentExtraSpeedX + extra->lastPos.x;
 
-			const int32 currentExtraSpeedY = extra->destY * deltaT;
-			extra->y = currentExtraSpeedY + extra->lastY - ABS(extra->angle * deltaT * deltaT / 16);
+			const int32 currentExtraSpeedY = extra->destPos.y * deltaT;
+			extra->pos.y = currentExtraSpeedY + extra->lastPos.y - ABS(extra->angle * deltaT * deltaT / 16);
 
-			extra->z = extra->destZ * deltaT + extra->lastZ;
+			extra->pos.z = extra->destPos.z * deltaT + extra->lastPos.z;
 
 			// check if extra is out of scene
-			if (extra->y < 0 || extra->x < 0 || extra->x > 0x7E00 || extra->z < 0 || extra->z > 0x7E00) {
+			if (extra->pos.y < 0 || extra->pos.x < 0 || extra->pos.x > 0x7E00 || extra->pos.z < 0 || extra->pos.z > 0x7E00) { // SCENE_SIZE_MAX
 				// if extra is Magic Ball
 				if (i == _engine->_gameState->magicBallIdx) {
 					int32 spriteIdx = SPRITEHQR_MAGICBALL_YELLOW_TRANS;
@@ -609,7 +609,7 @@ void Extra::processExtras() {
 						spriteIdx = SPRITEHQR_MAGICBALL_RED_TRANS;
 					}
 
-					_engine->_gameState->magicBallIdx = addExtra(-1, extra->x, extra->y, extra->z, spriteIdx, 0, 10000, 0);
+					_engine->_gameState->magicBallIdx = addExtra(-1, extra->pos.x, extra->pos.y, extra->pos.z, spriteIdx, 0, 10000, 0);
 				}
 
 				// if can take extra on ground
@@ -639,7 +639,7 @@ void Extra::processExtras() {
 			currentExtraY = actor->pos.y + 1000;
 			currentExtraZ = actor->pos.z;
 
-			const int32 tmpAngle = _engine->_movements->getAngleAndSetTargetActorDistance(extra->x, extra->z, currentExtraX, currentExtraZ);
+			const int32 tmpAngle = _engine->_movements->getAngleAndSetTargetActorDistance(extra->pos.x, extra->pos.z, currentExtraX, currentExtraZ);
 			const int32 angle = ClampAngle(tmpAngle - extra->angle);
 
 			if (angle > ANGLE_140 && angle < ANGLE_210) {
@@ -655,20 +655,20 @@ void Extra::processExtras() {
 				continue;
 			}
 
-			const int32 angle2 = _engine->_movements->getAngleAndSetTargetActorDistance(extra->y, 0, currentExtraY, _engine->_movements->targetActorDistance);
+			const int32 angle2 = _engine->_movements->getAngleAndSetTargetActorDistance(extra->pos.y, 0, currentExtraY, _engine->_movements->targetActorDistance);
 			int32 pos = extra->trackActorMove.getRealAngle(_engine->lbaTime);
 			if (!pos) {
 				pos = 1;
 			}
 
 			_engine->_movements->rotateActor(pos, 0, angle2);
-			extra->y -= _engine->_renderer->destZ;
+			extra->pos.y -= _engine->_renderer->destZ;
 
 			_engine->_movements->rotateActor(0, _engine->_renderer->destX, tmpAngle);
-			extra->x += _engine->_renderer->destX;
-			extra->z += _engine->_renderer->destZ;
+			extra->pos.x += _engine->_renderer->destX;
+			extra->pos.z += _engine->_renderer->destZ;
 
-			_engine->_movements->setActorAngle(ANGLE_0, extra->destZ, ANGLE_17, &extra->trackActorMove);
+			_engine->_movements->setActorAngle(ANGLE_0, extra->destPos.z, ANGLE_17, &extra->trackActorMove);
 
 			if (actorIdxAttacked == _engine->_collision->checkExtraCollisionWithActors(extra, actorIdx)) {
 				if (i == _engine->_gameState->magicBallIdx) {
@@ -685,14 +685,14 @@ void Extra::processExtras() {
 			ExtraListStruct *extraKey = &extraList[extra->payload.extraIdx];
 			const int32 extraIdx = extra->payload.extraIdx;
 
-			const int32 tmpAngle = _engine->_movements->getAngleAndSetTargetActorDistance(extra->x, extra->z, extraKey->x, extraKey->z);
+			const int32 tmpAngle = _engine->_movements->getAngleAndSetTargetActorDistance(extra->pos.x, extra->pos.z, extraKey->pos.x, extraKey->pos.z);
 			const int32 angle = ClampAngle(tmpAngle - extra->angle);
 
 			if (angle > ANGLE_140 && angle < ANGLE_210) {
 				_engine->_sound->playSample(Samples::ItemFound, 1, _engine->_scene->sceneHero->pos, OWN_ACTOR_SCENE_INDEX);
 
 				if (extraKey->info1 > 1) {
-					_engine->_renderer->projectPositionOnScreen(extraKey->x - _engine->_grid->camera.x, extraKey->y - _engine->_grid->camera.y, extraKey->z - _engine->_grid->camera.z);
+					_engine->_renderer->projectPositionOnScreen(extraKey->pos.x - _engine->_grid->camera.x, extraKey->pos.y - _engine->_grid->camera.y, extraKey->pos.z - _engine->_grid->camera.z);
 					_engine->_redraw->addOverlay(OverlayType::koNumber, extraKey->info1, _engine->_renderer->projPosX, _engine->_renderer->projPosY, COLOR_BLACK, OverlayPosType::koNormal, 2);
 				}
 
@@ -702,10 +702,10 @@ void Extra::processExtras() {
 				extraKey->info0 = -1;
 
 				extra->info0 = -1;
-				_engine->_gameState->magicBallIdx = addExtra(-1, extra->x, extra->y, extra->z, SPRITEHQR_KEY, 0, 8000, 0);
+				_engine->_gameState->magicBallIdx = addExtra(-1, extra->pos.x, extra->pos.y, extra->pos.z, SPRITEHQR_KEY, 0, 8000, 0);
 				continue;
 			}
-			const int32 angle2 = _engine->_movements->getAngleAndSetTargetActorDistance(extra->y, 0, extraKey->y, _engine->_movements->targetActorDistance);
+			const int32 angle2 = _engine->_movements->getAngleAndSetTargetActorDistance(extra->pos.y, 0, extraKey->pos.y, _engine->_movements->targetActorDistance);
 			int32 pos = extra->trackActorMove.getRealAngle(_engine->lbaTime);
 
 			if (!pos) {
@@ -713,19 +713,19 @@ void Extra::processExtras() {
 			}
 
 			_engine->_movements->rotateActor(pos, 0, angle2);
-			extra->y -= _engine->_renderer->destZ;
+			extra->pos.y -= _engine->_renderer->destZ;
 
 			_engine->_movements->rotateActor(0, _engine->_renderer->destX, tmpAngle);
-			extra->x += _engine->_renderer->destX;
-			extra->z += _engine->_renderer->destZ;
+			extra->pos.x += _engine->_renderer->destX;
+			extra->pos.z += _engine->_renderer->destZ;
 
-			_engine->_movements->setActorAngle(ANGLE_0, extra->destZ, ANGLE_17, &extra->trackActorMove);
+			_engine->_movements->setActorAngle(ANGLE_0, extra->destPos.z, ANGLE_17, &extra->trackActorMove);
 
 			if (extraIdx == _engine->_collision->checkExtraCollisionWithExtra(extra, _engine->_gameState->magicBallIdx)) {
 				_engine->_sound->playSample(Samples::ItemFound, 1, _engine->_scene->sceneHero->pos, OWN_ACTOR_SCENE_INDEX);
 
 				if (extraKey->info1 > 1) {
-					_engine->_renderer->projectPositionOnScreen(extraKey->x - _engine->_grid->camera.x, extraKey->y - _engine->_grid->camera.y, extraKey->z - _engine->_grid->camera.z);
+					_engine->_renderer->projectPositionOnScreen(extraKey->pos.x - _engine->_grid->camera.x, extraKey->pos.y - _engine->_grid->camera.y, extraKey->pos.z - _engine->_grid->camera.z);
 					_engine->_redraw->addOverlay(OverlayType::koNumber, extraKey->info1, _engine->_renderer->projPosX, _engine->_renderer->projPosY, COLOR_BLACK, OverlayPosType::koNormal, 2);
 				}
 
@@ -735,7 +735,7 @@ void Extra::processExtras() {
 				extraKey->info0 = -1;
 
 				extra->info0 = -1;
-				_engine->_gameState->magicBallIdx = addExtra(-1, extra->x, extra->y, extra->z, SPRITEHQR_KEY, 0, 8000, 0);
+				_engine->_gameState->magicBallIdx = addExtra(-1, extra->pos.x, extra->pos.y, extra->pos.z, SPRITEHQR_KEY, 0, 8000, 0);
 				continue;
 			}
 			if (extraKey->info0 == -1) {
@@ -749,7 +749,7 @@ void Extra::processExtras() {
 				}
 
 				extra->info0 = -1;
-				_engine->_gameState->magicBallIdx = addExtra(-1, extra->x, extra->y, extra->z, spriteIdx, 0, 8000, 0);
+				_engine->_gameState->magicBallIdx = addExtra(-1, extra->pos.x, extra->pos.y, extra->pos.z, spriteIdx, 0, 8000, 0);
 				continue;
 			}
 		}
@@ -767,7 +767,7 @@ void Extra::processExtras() {
 						spriteIdx = SPRITEHQR_MAGICBALL_RED_TRANS;
 					}
 
-					_engine->_gameState->magicBallIdx = addExtra(-1, extra->x, extra->y, extra->z, spriteIdx, 0, 10000, 0);
+					_engine->_gameState->magicBallIdx = addExtra(-1, extra->pos.x, extra->pos.y, extra->pos.z, spriteIdx, 0, 10000, 0);
 				}
 
 				extra->info0 = -1;
@@ -778,7 +778,7 @@ void Extra::processExtras() {
 		if (extra->type & ExtraType::UNK3) {
 			int32 process = 0;
 
-			if (_engine->_collision->checkExtraCollisionWithBricks(currentExtraX, currentExtraY, currentExtraZ, extra->x, extra->y, extra->z)) {
+			if (_engine->_collision->checkExtraCollisionWithBricks(currentExtraX, currentExtraY, currentExtraZ, extra->pos.x, extra->pos.y, extra->pos.z)) {
 				// if not touch the ground
 				if (!(extra->type & ExtraType::WAIT_NO_COL)) {
 					process = 1;
@@ -797,7 +797,7 @@ void Extra::processExtras() {
 				}
 				// if extra is magic ball
 				if (i == _engine->_gameState->magicBallIdx) {
-					_engine->_sound->playSample(Samples::Hit, 1, extra->x, extra->y, extra->z);
+					_engine->_sound->playSample(Samples::Hit, 1, extra->pos);
 
 					// cant bounce with not magic points
 					if (_engine->_gameState->magicBallNumBounce <= 0) {
@@ -810,7 +810,7 @@ void Extra::processExtras() {
 							spriteIdx = SPRITEHQR_MAGICBALL_RED_TRANS;
 						}
 
-						_engine->_gameState->magicBallIdx = addExtra(-1, extra->x, extra->y, extra->z, spriteIdx, 0, 10000, 0);
+						_engine->_gameState->magicBallIdx = addExtra(-1, extra->pos.x, extra->pos.y, extra->pos.z, spriteIdx, 0, 10000, 0);
 
 						extra->info0 = -1;
 						continue;
@@ -828,7 +828,7 @@ void Extra::processExtras() {
 								spriteIdx = SPRITEHQR_MAGICBALL_RED_TRANS;
 							}
 
-							_engine->_gameState->magicBallIdx = addExtra(-1, extra->x, extra->y, extra->z, spriteIdx, 0, 10000, 0);
+							_engine->_gameState->magicBallIdx = addExtra(-1, extra->pos.x, extra->pos.y, extra->pos.z, spriteIdx, 0, 10000, 0);
 
 							extra->info0 = -1;
 							continue;
@@ -845,7 +845,7 @@ void Extra::processExtras() {
 		if (extra->type & ExtraType::STOP_COL) {
 			int32 process = 0;
 
-			if (_engine->_collision->checkExtraCollisionWithBricks(currentExtraX, currentExtraY, currentExtraZ, extra->x, extra->y, extra->z)) {
+			if (_engine->_collision->checkExtraCollisionWithBricks(currentExtraX, currentExtraY, currentExtraZ, extra->pos.x, extra->pos.y, extra->pos.z)) {
 				// if not touch the ground
 				if (!(extra->type & ExtraType::WAIT_NO_COL)) {
 					process = 1;
@@ -859,7 +859,7 @@ void Extra::processExtras() {
 
 			if (process) {
 				const BoundingBox *bbox = _engine->_resources->spriteBoundingBox.bbox(extra->info0);
-				extra->y = (_engine->_collision->collision.y * BRICK_HEIGHT) + BRICK_HEIGHT - bbox->mins.y;
+				extra->pos.y = (_engine->_collision->collision.y * BRICK_HEIGHT) + BRICK_HEIGHT - bbox->mins.y;
 				extra->type &= ~(ExtraType::STOP_COL | ExtraType::FLY);
 				continue;
 			}
@@ -868,10 +868,10 @@ void Extra::processExtras() {
 		if ((extra->type & ExtraType::TAKABLE) && !(extra->type & ExtraType::FLY)) {
 			// if hero touch extra
 			if (_engine->_collision->checkExtraCollisionWithActors(extra, -1) == 0) {
-				_engine->_sound->playSample(Samples::ItemFound, 1, extra->x, extra->y, extra->z);
+				_engine->_sound->playSample(Samples::ItemFound, 1, extra->pos);
 
 				if (extra->info1 > 1 && !_engine->_input->isActionActive(TwinEActionType::MoveBackward)) {
-					_engine->_renderer->projectPositionOnScreen(extra->x - _engine->_grid->camera.x, extra->y - _engine->_grid->camera.y, extra->z - _engine->_grid->camera.z);
+					_engine->_renderer->projectPositionOnScreen(extra->pos - _engine->_grid->camera);
 					const int16 fontColor = COLOR_158;
 					_engine->_redraw->addOverlay(OverlayType::koNumber, extra->info1, _engine->_renderer->projPosX, _engine->_renderer->projPosY, fontColor, OverlayPosType::koNormal, 2);
 				}
diff --git a/engines/twine/scene/extra.h b/engines/twine/scene/extra.h
index 26978dd74d..3ae2553cd8 100644
--- a/engines/twine/scene/extra.h
+++ b/engines/twine/scene/extra.h
@@ -51,19 +51,12 @@ enum ExtraType {
 
 struct ExtraListStruct {
 	int16 info0 = 0; /**< a value of -1 indicates that this instance is free to use */
-	int16 x = 0;
-	int16 y = 0;
-	int16 z = 0;
-
-	int16 lastX = 0; // field_8
-	int16 lastY = 0; // field_A
-	int16 lastZ = 0; // field_C
+	Vec3 pos;
+	Vec3 lastPos;
+	Vec3 destPos;
 
 	ActorMoveStruct trackActorMove;
 
-	int16 destX = 0; // field_E
-	int16 destY = 0; // field_10
-	int16 destZ = 0; // field_12
 	uint16 type = 0; /**< ExtraType bitmask */
 	int16 angle = 0; // field_16
 	int32 spawnTime = 0;
diff --git a/engines/twine/scene/movements.cpp b/engines/twine/scene/movements.cpp
index f173f85031..f0fca6f58d 100644
--- a/engines/twine/scene/movements.cpp
+++ b/engines/twine/scene/movements.cpp
@@ -274,7 +274,8 @@ bool Movements::processBehaviourExecution(int actorIdx) {
 
 bool Movements::processAttackExecution(int actorIdx) {
 	ActorStruct *actor = _engine->_scene->getActor(actorIdx);
-	if (!_engine->_gameState->usingSabre) { // Use Magic Ball
+	if (!_engine->_gameState->usingSabre) {
+		// Use Magic Ball
 		if (_engine->_gameState->hasItem(InventoryItems::kiMagicBall)) {
 			if (_engine->_gameState->magicBallIdx == -1) {
 				_engine->_animations->initAnim(AnimationTypes::kThrowBall, kAnimationType_1, AnimationTypes::kStanding, actorIdx);


Commit: 56b9d68bb021578a5153efd1c7ff6af00513650e
    https://github.com/scummvm/scummvm/commit/56b9d68bb021578a5153efd1c7ff6af00513650e
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2021-02-26T11:11:20+01:00

Commit Message:
TWINE: replaced magic number with constant

Changed paths:
    engines/twine/renderer/redraw.cpp
    engines/twine/scene/extra.cpp
    engines/twine/scene/extra.h


diff --git a/engines/twine/renderer/redraw.cpp b/engines/twine/renderer/redraw.cpp
index 8a720113ac..c1f58479d1 100644
--- a/engines/twine/renderer/redraw.cpp
+++ b/engines/twine/renderer/redraw.cpp
@@ -293,7 +293,7 @@ int32 Redraw::fillExtraDrawingList(int32 drawListPos) {
 				drawList[drawListPos].type = DrawListType::DrawExtras;
 				drawListPos++;
 
-				if (_engine->cfgfile.ShadowMode == 2 && !(extra->info0 & 0x8000)) {
+				if (_engine->cfgfile.ShadowMode == 2 && !(extra->info0 & EXTRA_SPECIAL_MASK)) {
 					_engine->_movements->getShadowPosition(extra->pos.x, extra->pos.y, extra->pos.z);
 
 					drawList[drawListPos].posValue = extra->pos.x - _engine->_grid->camera.x + extra->pos.z - _engine->_grid->camera.z - 1;
@@ -463,7 +463,7 @@ void Redraw::processDrawListExtras(const DrawListStruct &drawCmd) {
 
 	_engine->_renderer->projectPositionOnScreen(extra->pos - _engine->_grid->camera);
 
-	if (extra->info0 & 0x8000) {
+	if (extra->info0 & EXTRA_SPECIAL_MASK) {
 		_engine->_extra->drawExtraSpecial(actorIdx, _engine->_renderer->projPosX, _engine->_renderer->projPosY);
 	} else {
 		const SpriteData &spritePtr = _engine->_resources->spriteData[extra->info0];
diff --git a/engines/twine/scene/extra.cpp b/engines/twine/scene/extra.cpp
index 9251393909..edf6eb30f6 100644
--- a/engines/twine/scene/extra.cpp
+++ b/engines/twine/scene/extra.cpp
@@ -180,7 +180,7 @@ void Extra::throwExtra(ExtraListStruct *extra, int32 xAngle, int32 yAngle, int32
 }
 
 int32 Extra::addExtraSpecial(int32 x, int32 y, int32 z, ExtraSpecialType type) { // InitSpecial
-	const int16 flag = 0x8000 + (int16)type;
+	const int16 flag = EXTRA_SPECIAL_MASK + (int16)type;
 
 	for (int32 i = 0; i < EXTRA_MAX_ENTRIES; i++) {
 		ExtraListStruct *extra = &extraList[i];
diff --git a/engines/twine/scene/extra.h b/engines/twine/scene/extra.h
index 3ae2553cd8..a350e68f57 100644
--- a/engines/twine/scene/extra.h
+++ b/engines/twine/scene/extra.h
@@ -30,6 +30,8 @@ namespace TwinE {
 
 #define EXTRA_MAX_ENTRIES 50
 
+#define EXTRA_SPECIAL_MASK 0x8000
+
 enum ExtraType {
 	TIME_OUT = 1 << 0,     // 0x0001
 	FLY = 1 << 1,          // 0x0002


Commit: c702e0955ed5c1450188604a4750332d215e8dc3
    https://github.com/scummvm/scummvm/commit/c702e0955ed5c1450188604a4750332d215e8dc3
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2021-02-26T11:11:21+01:00

Commit Message:
TWINE: use Vec3 operators

Changed paths:
    engines/twine/renderer/redraw.cpp
    engines/twine/scene/actor.cpp
    engines/twine/scene/animations.cpp
    engines/twine/scene/collision.cpp
    engines/twine/scene/extra.cpp
    engines/twine/scene/movements.cpp
    engines/twine/scene/movements.h
    engines/twine/scene/scene.cpp
    engines/twine/script/script_life_v1.cpp
    engines/twine/script/script_move_v1.cpp
    engines/twine/twine.cpp


diff --git a/engines/twine/renderer/redraw.cpp b/engines/twine/renderer/redraw.cpp
index c1f58479d1..66f4b41d3d 100644
--- a/engines/twine/renderer/redraw.cpp
+++ b/engines/twine/renderer/redraw.cpp
@@ -285,7 +285,7 @@ int32 Redraw::fillExtraDrawingList(int32 drawListPos) {
 			continue;
 		}
 		if ((extra->type & ExtraType::TIME_OUT) || (extra->type & ExtraType::FLASH) || (extra->payload.lifeTime + extra->spawnTime - 150 < _engine->lbaTime) || (!((_engine->lbaTime + extra->spawnTime) & 8))) {
-			_engine->_renderer->projectPositionOnScreen(extra->pos.x - _engine->_grid->camera.x, extra->pos.y - _engine->_grid->camera.y, extra->pos.z - _engine->_grid->camera.z);
+			_engine->_renderer->projectPositionOnScreen(extra->pos - _engine->_grid->camera);
 
 			if (_engine->_renderer->projPosX > -50 && _engine->_renderer->projPosX < _engine->width() + 40 && _engine->_renderer->projPosY > -30 && _engine->_renderer->projPosY < _engine->height() + 100) {
 				drawList[drawListPos].posValue = extra->pos.x - _engine->_grid->camera.x + extra->pos.z - _engine->_grid->camera.z;
diff --git a/engines/twine/scene/actor.cpp b/engines/twine/scene/actor.cpp
index 29bbfc3391..c89542053b 100644
--- a/engines/twine/scene/actor.cpp
+++ b/engines/twine/scene/actor.cpp
@@ -467,7 +467,7 @@ void Actor::processActorExtraBonus(int32 actorIdx) { // GiveExtraBonus
 		_engine->_sound->playSample(Samples::ItemPopup, 1, actor->pos, actorIdx);
 	} else {
 		ActorStruct *sceneHero = _engine->_scene->sceneHero;
-		const int32 angle = _engine->_movements->getAngleAndSetTargetActorDistance(actor->pos.x, actor->pos.z, sceneHero->pos.x, sceneHero->pos.z);
+		const int32 angle = _engine->_movements->getAngleAndSetTargetActorDistance(actor->pos, sceneHero->pos);
 		_engine->_extra->addExtraBonus(actor->pos.x, actor->pos.y + actor->boudingBox.y.topRight, actor->pos.z, ANGLE_70, angle, bonusSprite, actor->bonusAmount);
 		_engine->_sound->playSample(Samples::ItemPopup, 1, actor->pos.x, actor->pos.y + actor->boudingBox.y.topRight, actor->pos.z, actorIdx);
 	}
diff --git a/engines/twine/scene/animations.cpp b/engines/twine/scene/animations.cpp
index bb060ffbc5..44af168178 100644
--- a/engines/twine/scene/animations.cpp
+++ b/engines/twine/scene/animations.cpp
@@ -397,7 +397,8 @@ void Animations::processAnimActions(int32 actorIdx) {
 			break;
 		case ActionType::ACTION_THROW_3D_ALPHA:
 			if (action.animFrame == actor->animPosition) {
-				const int32 newAngle = _engine->_movements->getAngleAndSetTargetActorDistance(actor->pos.y, 0, _engine->_scene->sceneHero->pos.y, _engine->_movements->getDistance2D(actor->pos.x, actor->pos.z, _engine->_scene->sceneHero->pos.x, _engine->_scene->sceneHero->pos.z));
+				const int32 distance = _engine->_movements->getDistance2D(actor->pos, _engine->_scene->sceneHero->pos);
+				const int32 newAngle = _engine->_movements->getAngleAndSetTargetActorDistance(actor->pos.y, 0, _engine->_scene->sceneHero->pos.y, distance);
 
 				_engine->_movements->rotateActor(action.distanceX, action.distanceZ, actor->angle);
 
diff --git a/engines/twine/scene/collision.cpp b/engines/twine/scene/collision.cpp
index edbe22eb90..e6e1594167 100644
--- a/engines/twine/scene/collision.cpp
+++ b/engines/twine/scene/collision.cpp
@@ -243,7 +243,7 @@ int32 Collision::checkCollisionWithActors(int32 actorIdx) {
 							_engine->_movements->processActor.y = yRightTest - actor->boudingBox.y.bottomLeft + 1;
 							actor->standOn = a;
 						} else {
-							int32 newAngle = _engine->_movements->getAngleAndSetTargetActorDistance(_engine->_movements->processActor.x, _engine->_movements->processActor.z, actorTest->pos.x, actorTest->pos.z);
+							int32 newAngle = _engine->_movements->getAngleAndSetTargetActorDistance(_engine->_movements->processActor, actorTest->pos);
 
 							if (actorTest->staticFlags.bCanBePushed && !actor->staticFlags.bCanBePushed) {
 								actorTest->lastPos.y = 0;
@@ -293,7 +293,7 @@ int32 Collision::checkCollisionWithActors(int32 actorIdx) {
 						_engine->_actor->hitActor(actorIdx, a, 1, -1);
 					}
 
-					int32 newAngle = _engine->_movements->getAngleAndSetTargetActorDistance(_engine->_movements->processActor.x, _engine->_movements->processActor.z, actorTest->pos.x, actorTest->pos.z);
+					int32 newAngle = _engine->_movements->getAngleAndSetTargetActorDistance(_engine->_movements->processActor, actorTest->pos);
 
 					if (actorTest->staticFlags.bCanBePushed && !actor->staticFlags.bCanBePushed) {
 						actorTest->lastPos.y = 0;
diff --git a/engines/twine/scene/extra.cpp b/engines/twine/scene/extra.cpp
index edf6eb30f6..b0902ab3b2 100644
--- a/engines/twine/scene/extra.cpp
+++ b/engines/twine/scene/extra.cpp
@@ -162,9 +162,7 @@ void Extra::resetExtras() {
 void Extra::throwExtra(ExtraListStruct *extra, int32 xAngle, int32 yAngle, int32 x, int32 extraAngle) { // InitFly
 	extra->type |= ExtraType::FLY;
 
-	extra->lastPos.x = extra->pos.x;
-	extra->lastPos.y = extra->pos.y;
-	extra->lastPos.z = extra->pos.z;
+	extra->lastPos = extra->pos;
 
 	_engine->_movements->rotateActor(x, 0, xAngle);
 
@@ -685,14 +683,14 @@ void Extra::processExtras() {
 			ExtraListStruct *extraKey = &extraList[extra->payload.extraIdx];
 			const int32 extraIdx = extra->payload.extraIdx;
 
-			const int32 tmpAngle = _engine->_movements->getAngleAndSetTargetActorDistance(extra->pos.x, extra->pos.z, extraKey->pos.x, extraKey->pos.z);
+			const int32 tmpAngle = _engine->_movements->getAngleAndSetTargetActorDistance(extra->pos, extraKey->pos);
 			const int32 angle = ClampAngle(tmpAngle - extra->angle);
 
 			if (angle > ANGLE_140 && angle < ANGLE_210) {
 				_engine->_sound->playSample(Samples::ItemFound, 1, _engine->_scene->sceneHero->pos, OWN_ACTOR_SCENE_INDEX);
 
 				if (extraKey->info1 > 1) {
-					_engine->_renderer->projectPositionOnScreen(extraKey->pos.x - _engine->_grid->camera.x, extraKey->pos.y - _engine->_grid->camera.y, extraKey->pos.z - _engine->_grid->camera.z);
+					_engine->_renderer->projectPositionOnScreen(extraKey->pos - _engine->_grid->camera);
 					_engine->_redraw->addOverlay(OverlayType::koNumber, extraKey->info1, _engine->_renderer->projPosX, _engine->_renderer->projPosY, COLOR_BLACK, OverlayPosType::koNormal, 2);
 				}
 
@@ -725,7 +723,7 @@ void Extra::processExtras() {
 				_engine->_sound->playSample(Samples::ItemFound, 1, _engine->_scene->sceneHero->pos, OWN_ACTOR_SCENE_INDEX);
 
 				if (extraKey->info1 > 1) {
-					_engine->_renderer->projectPositionOnScreen(extraKey->pos.x - _engine->_grid->camera.x, extraKey->pos.y - _engine->_grid->camera.y, extraKey->pos.z - _engine->_grid->camera.z);
+					_engine->_renderer->projectPositionOnScreen(extraKey->pos - _engine->_grid->camera);
 					_engine->_redraw->addOverlay(OverlayType::koNumber, extraKey->info1, _engine->_renderer->projPosX, _engine->_renderer->projPosY, COLOR_BLACK, OverlayPosType::koNormal, 2);
 				}
 
diff --git a/engines/twine/scene/movements.cpp b/engines/twine/scene/movements.cpp
index f0fca6f58d..f322e6ac6e 100644
--- a/engines/twine/scene/movements.cpp
+++ b/engines/twine/scene/movements.cpp
@@ -160,7 +160,7 @@ int32 Movements::getDistance3D(const Vec3 &v1, const Vec3 &v2) const {
 	return (int32)sqrt((float)((v2.x - v1.x) * (v2.x - v1.x) + (v2.y - v1.y) * (v2.y - v1.y) + (v2.z - v1.z) * (v2.z - v1.z)));
 }
 
-void Movements::moveActor(int32 angleFrom, int32 angleTo, int32 speed, ActorMoveStruct *movePtr) { // ManualRealAngle
+void Movements::moveActor(int32 angleFrom, int32 angleTo, int32 speed, ActorMoveStruct *movePtr) const { // ManualRealAngle
 	const int16 from = ClampAngle(angleFrom);
 	const int16 to = ClampAngle(angleTo);
 
@@ -392,7 +392,7 @@ void Movements::processManualAction(int actorIdx) {
 void Movements::processFollowAction(int actorIdx) {
 	ActorStruct *actor = _engine->_scene->getActor(actorIdx);
 	const ActorStruct *followedActor = _engine->_scene->getActor(actor->followedActor);
-	int32 newAngle = getAngleAndSetTargetActorDistance(actor->pos.x, actor->pos.z, followedActor->pos.x, followedActor->pos.z);
+	int32 newAngle = getAngleAndSetTargetActorDistance(actor->pos, followedActor->pos);
 	if (actor->staticFlags.bIsSpriteActor) {
 		actor->angle = newAngle;
 	} else {
diff --git a/engines/twine/scene/movements.h b/engines/twine/scene/movements.h
index bc97a39646..d710e46024 100644
--- a/engines/twine/scene/movements.h
+++ b/engines/twine/scene/movements.h
@@ -184,6 +184,10 @@ public:
 	 */
 	int32 getAngleAndSetTargetActorDistance(int32 x1, int32 z1, int32 x2, int32 z2);
 
+	inline int32 getAngleAndSetTargetActorDistance(const Vec3& v1, const Vec3 &v2) {
+		return getAngleAndSetTargetActorDistance(v1.x, v1.z, v2.x, v2.z);
+	}
+
 	/**
 	 * Rotate actor with a given angle
 	 * @param x Actor current X coordinate
@@ -221,7 +225,7 @@ public:
 	 * @param speed Rotate speed
 	 * @param movePtr Pointer to process movements
 	 */
-	void moveActor(int32 angleFrom, int32 angleTo, int32 speed, ActorMoveStruct *movePtr);
+	void moveActor(int32 angleFrom, int32 angleTo, int32 speed, ActorMoveStruct *movePtr) const;
 
 	void processActorMovements(int32 actorIdx);
 };
diff --git a/engines/twine/scene/scene.cpp b/engines/twine/scene/scene.cpp
index 158078d8df..bab00eb3de 100644
--- a/engines/twine/scene/scene.cpp
+++ b/engines/twine/scene/scene.cpp
@@ -198,11 +198,9 @@ bool Scene::loadSceneLBA2() {
 		act->anim = (AnimationTypes)stream.readByte();
 		act->sprite = stream.readUint16LE();
 		act->pos.x = stream.readUint16LE();
-		act->collisionPos.x = act->pos.x;
 		act->pos.y = stream.readUint16LE();
-		act->collisionPos.y = act->pos.y;
 		act->pos.z = stream.readUint16LE();
-		act->collisionPos.z = act->pos.z;
+		act->collisionPos = act->pos;
 		act->strengthOfHit = stream.readByte();
 		setBonusParameterFlags(act, stream.readUint16LE());
 		act->angle = stream.readUint16LE();
diff --git a/engines/twine/script/script_life_v1.cpp b/engines/twine/script/script_life_v1.cpp
index e5b7894c46..edec817116 100644
--- a/engines/twine/script/script_life_v1.cpp
+++ b/engines/twine/script/script_life_v1.cpp
@@ -161,7 +161,7 @@ static int32 processLifeConditions(TwinEEngine *engine, LifeScriptContext &ctx)
 				engine->_scene->currentScriptValue = MAX_TARGET_ACTOR_DISTANCE;
 			} else {
 				// Returns int32, so we check for integer overflow
-				int32 distance = engine->_movements->getDistance2D(ctx.actor->pos.x, ctx.actor->pos.z, otherActor->pos.x, otherActor->pos.z);
+				int32 distance = engine->_movements->getDistance2D(ctx.actor->pos, otherActor->pos);
 				if (ABS(distance) > MAX_TARGET_ACTOR_DISTANCE) {
 					engine->_scene->currentScriptValue = MAX_TARGET_ACTOR_DISTANCE;
 				} else {
@@ -219,7 +219,7 @@ static int32 processLifeConditions(TwinEEngine *engine, LifeScriptContext &ctx)
 
 		if (!targetActor->dynamicFlags.bIsDead) {
 			if (ABS(targetActor->pos.y - ctx.actor->pos.y) < 1500) {
-				newAngle = engine->_movements->getAngleAndSetTargetActorDistance(ctx.actor->pos.x, ctx.actor->pos.z, targetActor->pos.x, targetActor->pos.z);
+				newAngle = engine->_movements->getAngleAndSetTargetActorDistance(ctx.actor->pos, targetActor->pos);
 				if (ABS(engine->_movements->targetActorDistance) > MAX_TARGET_ACTOR_DISTANCE) {
 					engine->_movements->targetActorDistance = MAX_TARGET_ACTOR_DISTANCE;
 				}
diff --git a/engines/twine/script/script_move_v1.cpp b/engines/twine/script/script_move_v1.cpp
index b5e9de589f..39be09049b 100644
--- a/engines/twine/script/script_move_v1.cpp
+++ b/engines/twine/script/script_move_v1.cpp
@@ -621,7 +621,7 @@ static int32 mFACE_HERO(TwinEEngine *engine, MoveScriptContext &ctx) {
 	}
 	engine->_scene->currentScriptValue = angle;
 	if (engine->_scene->currentScriptValue == -1 && ctx.actor->move.numOfStep == 0) {
-		engine->_scene->currentScriptValue = engine->_movements->getAngleAndSetTargetActorDistance(ctx.actor->pos.x, ctx.actor->pos.z, engine->_scene->sceneHero->pos.x, engine->_scene->sceneHero->pos.z);
+		engine->_scene->currentScriptValue = engine->_movements->getAngleAndSetTargetActorDistance(ctx.actor->pos, engine->_scene->sceneHero->pos);
 		engine->_movements->moveActor(ctx.actor->angle, engine->_scene->currentScriptValue, ctx.actor->speed, &ctx.actor->move);
 		ctx.stream.rewind(2);
 		ctx.stream.writeSint16LE(engine->_scene->currentScriptValue);
diff --git a/engines/twine/twine.cpp b/engines/twine/twine.cpp
index 1dde5bcbdf..3c2d83db5f 100644
--- a/engines/twine/twine.cpp
+++ b/engines/twine/twine.cpp
@@ -930,9 +930,7 @@ int32 TwinEEngine::runGameEngine() { // mainLoopInteration
 			if (IS_HERO(a)) {
 				if (actor->dynamicFlags.bAnimEnded) {
 					if (_gameState->inventoryNumLeafs > 0) { // use clover leaf automaticaly
-						_scene->sceneHero->pos.x = _scene->newHeroPos.x;
-						_scene->sceneHero->pos.y = _scene->newHeroPos.y;
-						_scene->sceneHero->pos.z = _scene->newHeroPos.z;
+						_scene->sceneHero->pos = _scene->newHeroPos;
 
 						_scene->needChangeScene = _scene->currentSceneIdx;
 						_gameState->inventoryMagicPoints = _gameState->magicLevelIdx * 20;


Commit: d1b67f614e32a9c729c07db1abd2d9793e08534a
    https://github.com/scummvm/scummvm/commit/d1b67f614e32a9c729c07db1abd2d9793e08534a
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2021-02-26T11:11:21+01:00

Commit Message:
TWINE: converted projPosScreen to Vec3

Changed paths:
    engines/twine/renderer/redraw.cpp
    engines/twine/renderer/renderer.h
    engines/twine/scene/grid.cpp


diff --git a/engines/twine/renderer/redraw.cpp b/engines/twine/renderer/redraw.cpp
index 66f4b41d3d..936925fbac 100644
--- a/engines/twine/renderer/redraw.cpp
+++ b/engines/twine/renderer/redraw.cpp
@@ -419,7 +419,7 @@ void Redraw::processDrawListActorSprites(const DrawListStruct &drawCmd, bool bgR
 	renderRect.bottom = renderRect.top + spriteHeight;
 
 	if (actor->staticFlags.bUsesClipping) {
-		const Common::Rect rect(_engine->_renderer->projPosXScreen + actor->cropLeft, _engine->_renderer->projPosYScreen + actor->cropTop, _engine->_renderer->projPosXScreen + actor->cropRight, _engine->_renderer->projPosYScreen + actor->cropBottom);
+		const Common::Rect rect(_engine->_renderer->projPosScreen.x + actor->cropLeft, _engine->_renderer->projPosScreen.y + actor->cropTop, _engine->_renderer->projPosScreen.x + actor->cropRight, _engine->_renderer->projPosScreen.y + actor->cropBottom);
 		_engine->_interface->setClip(rect);
 	} else {
 		_engine->_interface->setClip(renderRect);
@@ -675,8 +675,8 @@ void Redraw::renderOverlays() {
 }
 
 void Redraw::redrawEngineActions(bool bgRedraw) {
-	int16 tmp_projPosX = _engine->_renderer->projPosXScreen;
-	int16 tmp_projPosY = _engine->_renderer->projPosYScreen;
+	int16 tmp_projPosX = _engine->_renderer->projPosScreen.x;
+	int16 tmp_projPosY = _engine->_renderer->projPosScreen.y;
 
 	_engine->_interface->resetClip();
 
@@ -687,7 +687,7 @@ void Redraw::redrawEngineActions(bool bgRedraw) {
 		}
 		_engine->_screens->clearScreen();
 		_engine->_grid->redrawGrid();
-		updateOverlayTypePosition(tmp_projPosX, tmp_projPosY, _engine->_renderer->projPosXScreen, _engine->_renderer->projPosYScreen);
+		updateOverlayTypePosition(tmp_projPosX, tmp_projPosY, _engine->_renderer->projPosScreen.x, _engine->_renderer->projPosScreen.y);
 		_engine->_screens->copyScreen(_engine->frontVideoBuffer, _engine->workVideoBuffer);
 
 		if (_engine->_scene->needChangeScene != -1 && _engine->_scene->needChangeScene != -2) {
diff --git a/engines/twine/renderer/renderer.h b/engines/twine/renderer/renderer.h
index 82764df6bb..7bfb505ecc 100644
--- a/engines/twine/renderer/renderer.h
+++ b/engines/twine/renderer/renderer.h
@@ -394,9 +394,7 @@ public:
 
 	void init(int32 w, int32 h);
 
-	int16 projPosXScreen = 0; // fullRedrawVar1
-	int16 projPosYScreen = 0; // fullRedrawVar2
-	int16 projPosZScreen = 0; // fullRedrawVar3
+	Vec3 projPosScreen;
 	int16 projPosX = 0;
 	int16 projPosY = 0;
 	int16 projPosZ = 0;
diff --git a/engines/twine/scene/grid.cpp b/engines/twine/scene/grid.cpp
index ed47d14cc8..ba0dca90f5 100644
--- a/engines/twine/scene/grid.cpp
+++ b/engines/twine/scene/grid.cpp
@@ -683,8 +683,8 @@ void Grid::redrawGrid() {
 
 	_engine->_renderer->projectPositionOnScreen(-camera.x, -camera.y, -camera.z);
 
-	_engine->_renderer->projPosXScreen = _engine->_renderer->projPosX;
-	_engine->_renderer->projPosYScreen = _engine->_renderer->projPosY;
+	_engine->_renderer->projPosScreen.x = _engine->_renderer->projPosX;
+	_engine->_renderer->projPosScreen.y = _engine->_renderer->projPosY;
 
 	memset(brickInfoBuffer, 0, _brickInfoBufferSize);
 


Commit: a7aaa2c7dbe695abecc13c1163f71958218b09d1
    https://github.com/scummvm/scummvm/commit/a7aaa2c7dbe695abecc13c1163f71958218b09d1
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2021-02-26T11:11:21+01:00

Commit Message:
TWINE: converted baseRotPos to Vec3

Changed paths:
    engines/twine/holomap.cpp
    engines/twine/renderer/renderer.cpp
    engines/twine/renderer/renderer.h


diff --git a/engines/twine/holomap.cpp b/engines/twine/holomap.cpp
index 10a5af68c7..735a59fd08 100644
--- a/engines/twine/holomap.cpp
+++ b/engines/twine/holomap.cpp
@@ -473,9 +473,9 @@ void Holomap::renderLocations(int xRot, int yRot, int zRot, bool lower) {
 			int32 zpos2 = _engine->_renderer->destZ;
 			_engine->_renderer->setBaseRotation(xRot, yRot, zRot, true);
 			int32 zpos1_copy = zpos1;
-			_engine->_renderer->baseRotPosX = 0;
-			_engine->_renderer->baseRotPosY = 0;
-			_engine->_renderer->baseRotPosZ = 9500;
+			_engine->_renderer->baseRotPos.x = 0;
+			_engine->_renderer->baseRotPos.y = 0;
+			_engine->_renderer->baseRotPos.z = 9500;
 			_engine->_renderer->getBaseRotationPosition(xpos1, ypos1, zpos1);
 			int32 zpos1_copy2 = _engine->_renderer->destZ;
 			_engine->_renderer->getBaseRotationPosition(xpos2, ypos2, zpos2);
@@ -631,9 +631,9 @@ void Holomap::processHolomap() {
 			_engine->_renderer->setLightVector(xRot, yRot, 0);
 			renderLocations(xRot, yRot, 0, false);
 			_engine->_renderer->setBaseRotation(xRot, yRot, 0, true);
-			_engine->_renderer->baseRotPosX = 0;
-			_engine->_renderer->baseRotPosY = 0;
-			_engine->_renderer->baseRotPosZ = 9500;
+			_engine->_renderer->baseRotPos.x = 0;
+			_engine->_renderer->baseRotPos.y = 0;
+			_engine->_renderer->baseRotPos.z = 9500;
 			renderHolomapSurfacePolygons();
 			renderLocations(xRot, yRot, 0, true);
 			if (rotate) {
diff --git a/engines/twine/renderer/renderer.cpp b/engines/twine/renderer/renderer.cpp
index 4df791c7e8..452e426a2f 100644
--- a/engines/twine/renderer/renderer.cpp
+++ b/engines/twine/renderer/renderer.cpp
@@ -64,9 +64,9 @@ int32 Renderer::projectPositionOnScreen(int32 cX, int32 cY, int32 cZ) {
 		return 1;
 	}
 
-	cX -= baseRotPosX;
-	cY -= baseRotPosY;
-	cZ -= baseRotPosZ;
+	cX -= baseRotPos.x;
+	cY -= baseRotPos.y;
+	cZ -= baseRotPos.z;
 
 	if (cZ < 0) {
 		projPosX = 0;
@@ -152,9 +152,9 @@ void Renderer::setBaseRotation(int32 x, int32 y, int32 z, bool transpose) {
 	}
 	getBaseRotationPosition(baseTransPosX, baseTransPosY, baseTransPosZ);
 
-	baseRotPosX = destX;
-	baseRotPosY = destY;
-	baseRotPosZ = destZ;
+	baseRotPos.x = destX;
+	baseRotPos.y = destY;
+	baseRotPos.z = destZ;
 }
 
 void Renderer::getBaseRotationPosition(int32 x, int32 y, int32 z) {
@@ -182,9 +182,9 @@ void Renderer::setCameraAngle(int32 transPosX, int32 transPosY, int32 transPosZ,
 
 	setBaseRotation(rotPosX, rotPosY, rotPosZ);
 
-	baseRotPosZ += param6;
+	baseRotPos.z += param6;
 
-	getCameraAnglePositions(baseRotPosX, baseRotPosY, baseRotPosZ);
+	getCameraAnglePositions(baseRotPos.x, baseRotPos.y, baseRotPos.z);
 
 	baseTransPosX = destX;
 	baseTransPosY = destY;
@@ -1477,9 +1477,9 @@ bool Renderer::renderIsoModel(int32 x, int32 y, int32 z, int32 angleX, int32 ang
 	} else {
 		getBaseRotationPosition(x, y, z);
 
-		renderX = destX - baseRotPosX;
-		renderY = destY - baseRotPosY; // RECHECK
-		renderZ = destZ - baseRotPosZ;
+		renderX = destX - baseRotPos.x;
+		renderY = destY - baseRotPos.y; // RECHECK
+		renderZ = destZ - baseRotPos.z;
 	}
 
 	if (!Model::isAnimated(bodyPtr)) {
diff --git a/engines/twine/renderer/renderer.h b/engines/twine/renderer/renderer.h
index 7bfb505ecc..16fbed90d0 100644
--- a/engines/twine/renderer/renderer.h
+++ b/engines/twine/renderer/renderer.h
@@ -399,9 +399,7 @@ public:
 	int16 projPosY = 0;
 	int16 projPosZ = 0;
 
-	int32 baseRotPosX = 0; // setSomething3Var12
-	int32 baseRotPosY = 0; // setSomething3Var14
-	int32 baseRotPosZ = 0; // setSomething3Var16
+	Vec3 baseRotPos;
 
 	int32 orthoProjX = 0; // setSomethingVar1
 	int32 orthoProjY = 0; // setSomethingVar2


Commit: 517f51ae059821acf93232e93da77058445d6ac5
    https://github.com/scummvm/scummvm/commit/517f51ae059821acf93232e93da77058445d6ac5
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2021-02-26T11:11:21+01:00

Commit Message:
TWINE: converted orthoProjPos to Vec3

Changed paths:
    engines/twine/renderer/renderer.cpp
    engines/twine/renderer/renderer.h


diff --git a/engines/twine/renderer/renderer.cpp b/engines/twine/renderer/renderer.cpp
index 452e426a2f..81b5f6b9a1 100644
--- a/engines/twine/renderer/renderer.cpp
+++ b/engines/twine/renderer/renderer.cpp
@@ -58,8 +58,8 @@ void Renderer::init(int32 w, int32 h) {
 
 int32 Renderer::projectPositionOnScreen(int32 cX, int32 cY, int32 cZ) {
 	if (isUsingOrthoProjection) {
-		projPosX = ((cX - cZ) * 24) / BRICK_SIZE + orthoProjX;
-		projPosY = (((cX + cZ) * 12) - cY * 30) / BRICK_SIZE + orthoProjY;
+		projPosX = ((cX - cZ) * 24) / BRICK_SIZE + orthoProjPos.x;
+		projPosY = (((cX + cZ) * 12) - cY * 30) / BRICK_SIZE + orthoProjPos.y;
 		projPosZ = cZ - cY - cX;
 		return 1;
 	}
@@ -80,15 +80,15 @@ int32 Renderer::projectPositionOnScreen(int32 cX, int32 cY, int32 cZ) {
 		posZ = 0x7FFF;
 	}
 
-	projPosX = (cX * cameraScaleY) / posZ + orthoProjX;
-	projPosY = (-cY * cameraScaleZ) / posZ + orthoProjY;
+	projPosX = (cX * cameraScaleY) / posZ + orthoProjPos.x;
+	projPosY = (-cY * cameraScaleZ) / posZ + orthoProjPos.y;
 	projPosZ = posZ;
 	return -1;
 }
 
 void Renderer::setCameraPosition(int32 x, int32 y, int32 depthOffset, int32 scaleY, int32 scaleZ) {
-	orthoProjX = x;
-	orthoProjY = y;
+	orthoProjPos.x = x;
+	orthoProjPos.y = y;
 
 	cameraDepthOffset = depthOffset;
 	cameraScaleY = scaleY;
@@ -104,9 +104,9 @@ void Renderer::setBaseTranslation(int32 x, int32 y, int32 z) {
 }
 
 void Renderer::setOrthoProjection(int32 x, int32 y, int32 z) {
-	orthoProjX = x;
-	orthoProjY = y;
-	orthoProjZ = z;
+	orthoProjPos.x = x;
+	orthoProjPos.y = y;
+	orthoProjPos.z = z;
 
 	isUsingOrthoProjection = true;
 }
@@ -1296,8 +1296,8 @@ bool Renderer::renderAnimatedModel(ModelData *modelData, const uint8 *bodyPtr, R
 			const int32 coY = pointPtr->y + renderY;
 			const int32 coZ = -(pointPtr->z + renderZ);
 
-			pointPtrDest->x = (coX + coZ) * 24 / BRICK_SIZE + orthoProjX;
-			pointPtrDest->y = (((coX - coZ) * 12) - coY * 30) / BRICK_SIZE + orthoProjY;
+			pointPtrDest->x = (coX + coZ) * 24 / BRICK_SIZE + orthoProjPos.x;
+			pointPtrDest->y = (((coX - coZ) * 12) - coY * 30) / BRICK_SIZE + orthoProjPos.y;
 			pointPtrDest->z = coZ - coX - coY;
 
 			if (pointPtrDest->x < _engine->_redraw->renderRect.left) {
@@ -1331,7 +1331,7 @@ bool Renderer::renderAnimatedModel(ModelData *modelData, const uint8 *bodyPtr, R
 
 			// X projection
 			{
-				coX = orthoProjX + ((coX * cameraScaleY) / coZ);
+				coX = orthoProjPos.x + ((coX * cameraScaleY) / coZ);
 
 				if (coX > 0xFFFF) {
 					coX = 0x7FFF;
@@ -1350,7 +1350,7 @@ bool Renderer::renderAnimatedModel(ModelData *modelData, const uint8 *bodyPtr, R
 
 			// Y projection
 			{
-				coY = orthoProjY + ((-coY * cameraScaleZ) / coZ);
+				coY = orthoProjPos.y + ((-coY * cameraScaleZ) / coZ);
 
 				if (coY > 0xFFFF) {
 					coY = 0x7FFF;
diff --git a/engines/twine/renderer/renderer.h b/engines/twine/renderer/renderer.h
index 16fbed90d0..b64f827173 100644
--- a/engines/twine/renderer/renderer.h
+++ b/engines/twine/renderer/renderer.h
@@ -400,10 +400,7 @@ public:
 	int16 projPosZ = 0;
 
 	Vec3 baseRotPos;
-
-	int32 orthoProjX = 0; // setSomethingVar1
-	int32 orthoProjY = 0; // setSomethingVar2
-	int32 orthoProjZ = 0; // setSomethingVar2
+	Vec3 orthoProjPos;
 
 	int32 destX = 0;
 	int32 destY = 0;


Commit: 89921cac570565a1bc51903a898e74ad830b052e
    https://github.com/scummvm/scummvm/commit/89921cac570565a1bc51903a898e74ad830b052e
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2021-02-26T11:11:21+01:00

Commit Message:
TWINE: converted projPosScreen to Vec3

Changed paths:
    engines/twine/debugger/debug_scene.cpp
    engines/twine/holomap.cpp
    engines/twine/renderer/redraw.cpp
    engines/twine/renderer/renderer.cpp
    engines/twine/renderer/renderer.h
    engines/twine/scene/extra.cpp
    engines/twine/scene/gamestate.cpp
    engines/twine/scene/grid.cpp
    engines/twine/twine.cpp


diff --git a/engines/twine/debugger/debug_scene.cpp b/engines/twine/debugger/debug_scene.cpp
index aee4924d04..7dfadbdd6a 100644
--- a/engines/twine/debugger/debug_scene.cpp
+++ b/engines/twine/debugger/debug_scene.cpp
@@ -43,24 +43,24 @@ void DebugScene::drawClip(const Common::Rect& rect) {
 void DebugScene::drawBoundingBoxProjectPoints(ScenePoint *pPoint3d, ScenePoint *pPoint3dProjected) {
 	_engine->_renderer->projectPositionOnScreen(pPoint3d->x, pPoint3d->y, pPoint3d->z);
 
-	pPoint3dProjected->x = _engine->_renderer->projPosX;
-	pPoint3dProjected->y = _engine->_renderer->projPosY;
-	pPoint3dProjected->z = _engine->_renderer->projPosZ;
+	pPoint3dProjected->x = _engine->_renderer->projPos.x;
+	pPoint3dProjected->y = _engine->_renderer->projPos.y;
+	pPoint3dProjected->z = _engine->_renderer->projPos.z;
 
-	if (_engine->_redraw->renderRect.left > _engine->_renderer->projPosX) {
-		_engine->_redraw->renderRect.left = _engine->_renderer->projPosX;
+	if (_engine->_redraw->renderRect.left > _engine->_renderer->projPos.x) {
+		_engine->_redraw->renderRect.left = _engine->_renderer->projPos.x;
 	}
 
-	if (_engine->_redraw->renderRect.right < _engine->_renderer->projPosX) {
-		_engine->_redraw->renderRect.right = _engine->_renderer->projPosX;
+	if (_engine->_redraw->renderRect.right < _engine->_renderer->projPos.x) {
+		_engine->_redraw->renderRect.right = _engine->_renderer->projPos.x;
 	}
 
-	if (_engine->_redraw->renderRect.top > _engine->_renderer->projPosY) {
-		_engine->_redraw->renderRect.top = _engine->_renderer->projPosY;
+	if (_engine->_redraw->renderRect.top > _engine->_renderer->projPos.y) {
+		_engine->_redraw->renderRect.top = _engine->_renderer->projPos.y;
 	}
 
-	if (_engine->_redraw->renderRect.bottom < _engine->_renderer->projPosY) {
-		_engine->_redraw->renderRect.bottom = _engine->_renderer->projPosY;
+	if (_engine->_redraw->renderRect.bottom < _engine->_renderer->projPos.y) {
+		_engine->_redraw->renderRect.bottom = _engine->_renderer->projPos.y;
 	}
 }
 
diff --git a/engines/twine/holomap.cpp b/engines/twine/holomap.cpp
index 735a59fd08..8472b09712 100644
--- a/engines/twine/holomap.cpp
+++ b/engines/twine/holomap.cpp
@@ -182,16 +182,16 @@ void Holomap::prepareHolomapPolygons() {
 				++holomapSortArrayIdx;
 			}
 			_engine->_renderer->projectPositionOnScreen(_engine->_renderer->destX, _engine->_renderer->destY, _engine->_renderer->destZ);
-			_projectedSurfacePositions[_projectedSurfaceIndex].x = _engine->_renderer->projPosX;
-			_projectedSurfacePositions[_projectedSurfaceIndex].y = _engine->_renderer->projPosY;
+			_projectedSurfacePositions[_projectedSurfaceIndex].x = _engine->_renderer->projPos.x;
+			_projectedSurfacePositions[_projectedSurfaceIndex].y = _engine->_renderer->projPos.y;
 			rotation += ANGLE_11_25;
 			++_projectedSurfaceIndex;
 		}
 		HolomapSurface* vec = &_holomapSurface[holomapSurfaceArrayIdx++];
 		_engine->_renderer->getBaseRotationPosition(vec->x, vec->y, vec->z);
 		_engine->_renderer->projectPositionOnScreen(_engine->_renderer->destX, _engine->_renderer->destY, _engine->_renderer->destZ);
-		_projectedSurfacePositions[_projectedSurfaceIndex].x = _engine->_renderer->projPosX;
-		_projectedSurfacePositions[_projectedSurfaceIndex].y = _engine->_renderer->projPosY;
+		_projectedSurfacePositions[_projectedSurfaceIndex].x = _engine->_renderer->projPos.x;
+		_projectedSurfacePositions[_projectedSurfaceIndex].y = _engine->_renderer->projPos.y;
 		rotation += ANGLE_11_25;
 		++_projectedSurfaceIndex;
 	}
diff --git a/engines/twine/renderer/redraw.cpp b/engines/twine/renderer/redraw.cpp
index 936925fbac..54b1f3e2bd 100644
--- a/engines/twine/renderer/redraw.cpp
+++ b/engines/twine/renderer/redraw.cpp
@@ -203,7 +203,7 @@ int32 Redraw::fillActorDrawingList(bool bgRedraw) {
 			_engine->_renderer->projectPositionOnScreen(actor->pos - _engine->_grid->camera);
 
 			// check if actor is visible on screen, otherwise don't display it
-			if (_engine->_renderer->projPosX > -50 && _engine->_renderer->projPosX < _engine->width() + 40 && _engine->_renderer->projPosY > -30 && _engine->_renderer->projPosY < _engine->height() + 100) {
+			if (_engine->_renderer->projPos.x > -50 && _engine->_renderer->projPos.x < _engine->width() + 40 && _engine->_renderer->projPos.y > -30 && _engine->_renderer->projPos.y < _engine->height() + 100) {
 				actor->dynamicFlags.bIsVisible = 1;
 			}
 			continue;
@@ -215,8 +215,8 @@ int32 Redraw::fillActorDrawingList(bool bgRedraw) {
 		// get actor position on screen
 		_engine->_renderer->projectPositionOnScreen(actor->pos - _engine->_grid->camera);
 
-		if ((actor->staticFlags.bUsesClipping && _engine->_renderer->projPosX > -112 && _engine->_renderer->projPosX < _engine->width() + 112 && _engine->_renderer->projPosY > -50 && _engine->_renderer->projPosY < _engine->height() + 171) ||
-		    ((!actor->staticFlags.bUsesClipping) && _engine->_renderer->projPosX > -50 && _engine->_renderer->projPosX < _engine->width() + 40 && _engine->_renderer->projPosY > -30 && _engine->_renderer->projPosY < _engine->height() + 100)) {
+		if ((actor->staticFlags.bUsesClipping && _engine->_renderer->projPos.x > -112 && _engine->_renderer->projPos.x < _engine->width() + 112 && _engine->_renderer->projPos.y > -50 && _engine->_renderer->projPos.y < _engine->height() + 171) ||
+		    ((!actor->staticFlags.bUsesClipping) && _engine->_renderer->projPos.x > -50 && _engine->_renderer->projPos.x < _engine->width() + 40 && _engine->_renderer->projPos.y > -30 && _engine->_renderer->projPos.y < _engine->height() + 100)) {
 
 			int32 tmpVal = actor->pos.z + actor->pos.x - _engine->_grid->camera.x - _engine->_grid->camera.z;
 
@@ -262,8 +262,8 @@ int32 Redraw::fillActorDrawingList(bool bgRedraw) {
 				drawListPos++;
 			}
 			if (inSceneryView && modelActorPos == _engine->_scene->currentlyFollowedActor) {
-				_sceneryViewX = _engine->_renderer->projPosX;
-				_sceneryViewY = _engine->_renderer->projPosY;
+				_sceneryViewX = _engine->_renderer->projPos.x;
+				_sceneryViewY = _engine->_renderer->projPos.y;
 			}
 		}
 	}
@@ -287,7 +287,7 @@ int32 Redraw::fillExtraDrawingList(int32 drawListPos) {
 		if ((extra->type & ExtraType::TIME_OUT) || (extra->type & ExtraType::FLASH) || (extra->payload.lifeTime + extra->spawnTime - 150 < _engine->lbaTime) || (!((_engine->lbaTime + extra->spawnTime) & 8))) {
 			_engine->_renderer->projectPositionOnScreen(extra->pos - _engine->_grid->camera);
 
-			if (_engine->_renderer->projPosX > -50 && _engine->_renderer->projPosX < _engine->width() + 40 && _engine->_renderer->projPosY > -30 && _engine->_renderer->projPosY < _engine->height() + 100) {
+			if (_engine->_renderer->projPos.x > -50 && _engine->_renderer->projPos.x < _engine->width() + 40 && _engine->_renderer->projPos.y > -30 && _engine->_renderer->projPos.y < _engine->height() + 100) {
 				drawList[drawListPos].posValue = extra->pos.x - _engine->_grid->camera.x + extra->pos.z - _engine->_grid->camera.z;
 				drawList[drawListPos].actorIdx = i;
 				drawList[drawListPos].type = DrawListType::DrawExtras;
@@ -319,10 +319,10 @@ void Redraw::processDrawListShadows(const DrawListStruct &drawCmd) {
 	_engine->_grid->getSpriteSize(drawCmd.offset, &spriteWidth, &spriteHeight, _engine->_resources->spriteShadowPtr);
 
 	// calculate sprite size and position on screen
-	renderRect.left = _engine->_renderer->projPosX - (spriteWidth / 2);
-	renderRect.top = _engine->_renderer->projPosY - (spriteHeight / 2);
-	renderRect.right = _engine->_renderer->projPosX + (spriteWidth / 2);
-	renderRect.bottom = _engine->_renderer->projPosY + (spriteHeight / 2);
+	renderRect.left = _engine->_renderer->projPos.x - (spriteWidth / 2);
+	renderRect.top = _engine->_renderer->projPos.y - (spriteHeight / 2);
+	renderRect.right = _engine->_renderer->projPos.x + (spriteWidth / 2);
+	renderRect.bottom = _engine->_renderer->projPos.y + (spriteHeight / 2);
 
 	_engine->_interface->setClip(renderRect);
 
@@ -413,8 +413,8 @@ void Redraw::processDrawListActorSprites(const DrawListStruct &drawCmd, bool bgR
 
 	// calculate sprite position on screen
 	const SpriteDim *dim = _engine->_resources->spriteBoundingBox.dim(actor->entity);
-	renderRect.left = _engine->_renderer->projPosX + dim->x;
-	renderRect.top = _engine->_renderer->projPosY + dim->y;
+	renderRect.left = _engine->_renderer->projPos.x + dim->x;
+	renderRect.top = _engine->_renderer->projPos.y + dim->y;
 	renderRect.right = renderRect.left + spriteWidth;
 	renderRect.bottom = renderRect.top + spriteHeight;
 
@@ -464,7 +464,7 @@ void Redraw::processDrawListExtras(const DrawListStruct &drawCmd) {
 	_engine->_renderer->projectPositionOnScreen(extra->pos - _engine->_grid->camera);
 
 	if (extra->info0 & EXTRA_SPECIAL_MASK) {
-		_engine->_extra->drawExtraSpecial(actorIdx, _engine->_renderer->projPosX, _engine->_renderer->projPosY);
+		_engine->_extra->drawExtraSpecial(actorIdx, _engine->_renderer->projPos.x, _engine->_renderer->projPos.y);
 	} else {
 		const SpriteData &spritePtr = _engine->_resources->spriteData[extra->info0];
 		const int32 spriteWidth = spritePtr.surface().w;
@@ -472,8 +472,8 @@ void Redraw::processDrawListExtras(const DrawListStruct &drawCmd) {
 
 		// calculate sprite position on screen
 		const SpriteDim *dim = _engine->_resources->spriteBoundingBox.dim(extra->info0);
-		renderRect.left = _engine->_renderer->projPosX + dim->x;
-		renderRect.top = _engine->_renderer->projPosY + dim->y;
+		renderRect.left = _engine->_renderer->projPos.x + dim->x;
+		renderRect.top = _engine->_renderer->projPos.y + dim->y;
 		renderRect.right = renderRect.left + spriteWidth;
 		renderRect.bottom = renderRect.top + spriteHeight;
 
@@ -544,8 +544,8 @@ void Redraw::renderOverlays() {
 
 				_engine->_renderer->projectPositionOnScreen(actor2->pos.x - _engine->_grid->camera.x, actor2->pos.y + actor2->boudingBox.y.topRight - _engine->_grid->camera.y, actor2->pos.z - _engine->_grid->camera.z);
 
-				overlay->x = _engine->_renderer->projPosX;
-				overlay->y = _engine->_renderer->projPosY;
+				overlay->x = _engine->_renderer->projPos.x;
+				overlay->y = _engine->_renderer->projPos.y;
 
 				if (_engine->lbaTime >= overlay->lifeTime) {
 					overlay->info0 = -1;
@@ -675,8 +675,8 @@ void Redraw::renderOverlays() {
 }
 
 void Redraw::redrawEngineActions(bool bgRedraw) {
-	int16 tmp_projPosX = _engine->_renderer->projPosScreen.x;
-	int16 tmp_projPosY = _engine->_renderer->projPosScreen.y;
+	int16 tmp_projPos.x = _engine->_renderer->projPosScreen.x;
+	int16 tmp_projPos.y = _engine->_renderer->projPosScreen.y;
 
 	_engine->_interface->resetClip();
 
@@ -687,7 +687,7 @@ void Redraw::redrawEngineActions(bool bgRedraw) {
 		}
 		_engine->_screens->clearScreen();
 		_engine->_grid->redrawGrid();
-		updateOverlayTypePosition(tmp_projPosX, tmp_projPosY, _engine->_renderer->projPosScreen.x, _engine->_renderer->projPosScreen.y);
+		updateOverlayTypePosition(tmp_projPos.x, tmp_projPos.y, _engine->_renderer->projPosScreen.x, _engine->_renderer->projPosScreen.y);
 		_engine->_screens->copyScreen(_engine->frontVideoBuffer, _engine->workVideoBuffer);
 
 		if (_engine->_scene->needChangeScene != -1 && _engine->_scene->needChangeScene != -2) {
@@ -759,11 +759,11 @@ void Redraw::drawBubble(int32 actorIdx) {
 
 	// calculate sprite position on screen
 	if (bubbleSpriteIndex == SPRITEHQR_DIAG_BUBBLE_RIGHT) {
-		renderRect.left = _engine->_renderer->projPosX + 10;
+		renderRect.left = _engine->_renderer->projPos.x + 10;
 	} else {
-		renderRect.left = _engine->_renderer->projPosX - 10 - spriteWidth;
+		renderRect.left = _engine->_renderer->projPos.x - 10 - spriteWidth;
 	}
-	renderRect.top = _engine->_renderer->projPosY - 20;
+	renderRect.top = _engine->_renderer->projPos.y - 20;
 	renderRect.right = spriteWidth + renderRect.left - 1;
 	renderRect.bottom = spriteHeight + renderRect.top - 1;
 
diff --git a/engines/twine/renderer/renderer.cpp b/engines/twine/renderer/renderer.cpp
index 81b5f6b9a1..0c6ffc9e74 100644
--- a/engines/twine/renderer/renderer.cpp
+++ b/engines/twine/renderer/renderer.cpp
@@ -58,9 +58,9 @@ void Renderer::init(int32 w, int32 h) {
 
 int32 Renderer::projectPositionOnScreen(int32 cX, int32 cY, int32 cZ) {
 	if (isUsingOrthoProjection) {
-		projPosX = ((cX - cZ) * 24) / BRICK_SIZE + orthoProjPos.x;
-		projPosY = (((cX + cZ) * 12) - cY * 30) / BRICK_SIZE + orthoProjPos.y;
-		projPosZ = cZ - cY - cX;
+		projPos.x = ((cX - cZ) * 24) / BRICK_SIZE + orthoProjPos.x;
+		projPos.y = (((cX + cZ) * 12) - cY * 30) / BRICK_SIZE + orthoProjPos.y;
+		projPos.z = cZ - cY - cX;
 		return 1;
 	}
 
@@ -69,9 +69,9 @@ int32 Renderer::projectPositionOnScreen(int32 cX, int32 cY, int32 cZ) {
 	cZ -= baseRotPos.z;
 
 	if (cZ < 0) {
-		projPosX = 0;
-		projPosY = 0;
-		projPosZ = 0;
+		projPos.x = 0;
+		projPos.y = 0;
+		projPos.z = 0;
 		return 0;
 	}
 
@@ -80,9 +80,9 @@ int32 Renderer::projectPositionOnScreen(int32 cX, int32 cY, int32 cZ) {
 		posZ = 0x7FFF;
 	}
 
-	projPosX = (cX * cameraScaleY) / posZ + orthoProjPos.x;
-	projPosY = (-cY * cameraScaleZ) / posZ + orthoProjPos.y;
-	projPosZ = posZ;
+	projPos.x = (cX * cameraScaleY) / posZ + orthoProjPos.x;
+	projPos.y = (-cY * cameraScaleZ) / posZ + orthoProjPos.y;
+	projPos.z = posZ;
 	return -1;
 }
 
diff --git a/engines/twine/renderer/renderer.h b/engines/twine/renderer/renderer.h
index b64f827173..21917ef6b0 100644
--- a/engines/twine/renderer/renderer.h
+++ b/engines/twine/renderer/renderer.h
@@ -395,10 +395,7 @@ public:
 	void init(int32 w, int32 h);
 
 	Vec3 projPosScreen;
-	int16 projPosX = 0;
-	int16 projPosY = 0;
-	int16 projPosZ = 0;
-
+	Vec3 projPos;
 	Vec3 baseRotPos;
 	Vec3 orthoProjPos;
 
diff --git a/engines/twine/scene/extra.cpp b/engines/twine/scene/extra.cpp
index b0902ab3b2..b547b67941 100644
--- a/engines/twine/scene/extra.cpp
+++ b/engines/twine/scene/extra.cpp
@@ -472,8 +472,8 @@ void Extra::drawSpecialShape(const int16 *shapeTable, int32 x, int32 y, int32 co
 		const int32 oldComputedX = currentX;
 		const int32 oldComputedY = currentY;
 
-		_engine->_renderer->projPosX = currentX;
-		_engine->_renderer->projPosY = currentY;
+		_engine->_renderer->projPos.x = currentX;
+		_engine->_renderer->projPos.y = currentY;
 
 		_engine->_movements->rotateActor(var_x, var_z, angle);
 
@@ -496,17 +496,17 @@ void Extra::drawSpecialShape(const int16 *shapeTable, int32 x, int32 y, int32 co
 			_engine->_redraw->renderRect.bottom = currentY;
 		}
 
-		_engine->_renderer->projPosX = currentX;
-		_engine->_renderer->projPosY = currentY;
+		_engine->_renderer->projPos.x = currentX;
+		_engine->_renderer->projPos.y = currentY;
 
 		_engine->_interface->drawLine(oldComputedX, oldComputedY, currentX, currentY, color);
 
-		currentX = _engine->_renderer->projPosX;
-		currentY = _engine->_renderer->projPosY;
+		currentX = _engine->_renderer->projPos.x;
+		currentY = _engine->_renderer->projPos.y;
 	}
 
-	_engine->_renderer->projPosX = currentX;
-	_engine->_renderer->projPosY = currentY;
+	_engine->_renderer->projPos.x = currentX;
+	_engine->_renderer->projPos.y = currentY;
 	_engine->_interface->drawLine(currentX, currentY, computedX, computedY, color);
 }
 
@@ -691,7 +691,7 @@ void Extra::processExtras() {
 
 				if (extraKey->info1 > 1) {
 					_engine->_renderer->projectPositionOnScreen(extraKey->pos - _engine->_grid->camera);
-					_engine->_redraw->addOverlay(OverlayType::koNumber, extraKey->info1, _engine->_renderer->projPosX, _engine->_renderer->projPosY, COLOR_BLACK, OverlayPosType::koNormal, 2);
+					_engine->_redraw->addOverlay(OverlayType::koNumber, extraKey->info1, _engine->_renderer->projPos.x, _engine->_renderer->projPos.y, COLOR_BLACK, OverlayPosType::koNormal, 2);
 				}
 
 				_engine->_redraw->addOverlay(OverlayType::koSprite, SPRITEHQR_KEY, 10, 30, 0, OverlayPosType::koNormal, 2);
@@ -724,7 +724,7 @@ void Extra::processExtras() {
 
 				if (extraKey->info1 > 1) {
 					_engine->_renderer->projectPositionOnScreen(extraKey->pos - _engine->_grid->camera);
-					_engine->_redraw->addOverlay(OverlayType::koNumber, extraKey->info1, _engine->_renderer->projPosX, _engine->_renderer->projPosY, COLOR_BLACK, OverlayPosType::koNormal, 2);
+					_engine->_redraw->addOverlay(OverlayType::koNumber, extraKey->info1, _engine->_renderer->projPos.x, _engine->_renderer->projPos.y, COLOR_BLACK, OverlayPosType::koNormal, 2);
 				}
 
 				_engine->_redraw->addOverlay(OverlayType::koSprite, SPRITEHQR_KEY, 10, 30, 0, OverlayPosType::koNormal, 2);
@@ -871,7 +871,7 @@ void Extra::processExtras() {
 				if (extra->info1 > 1 && !_engine->_input->isActionActive(TwinEActionType::MoveBackward)) {
 					_engine->_renderer->projectPositionOnScreen(extra->pos - _engine->_grid->camera);
 					const int16 fontColor = COLOR_158;
-					_engine->_redraw->addOverlay(OverlayType::koNumber, extra->info1, _engine->_renderer->projPosX, _engine->_renderer->projPosY, fontColor, OverlayPosType::koNormal, 2);
+					_engine->_redraw->addOverlay(OverlayType::koNumber, extra->info1, _engine->_renderer->projPos.x, _engine->_renderer->projPos.y, fontColor, OverlayPosType::koNormal, 2);
 				}
 
 				_engine->_redraw->addOverlay(OverlayType::koSprite, extra->info0, 10, 30, 0, OverlayPosType::koNormal, 2);
diff --git a/engines/twine/scene/gamestate.cpp b/engines/twine/scene/gamestate.cpp
index e41a6d436a..1e8a4e5b1b 100644
--- a/engines/twine/scene/gamestate.cpp
+++ b/engines/twine/scene/gamestate.cpp
@@ -339,12 +339,12 @@ void GameState::processFoundItem(int32 item) {
 	_engine->flip();
 
 	_engine->_renderer->projectPositionOnScreen(bodyX, bodyY, bodyZ);
-	_engine->_renderer->projPosY -= 150;
+	_engine->_renderer->projPos.y -= 150;
 
-	const int32 boxTopLeftX = _engine->_renderer->projPosX - 65;
-	const int32 boxTopLeftY = _engine->_renderer->projPosY - 65;
-	const int32 boxBottomRightX = _engine->_renderer->projPosX + 65;
-	const int32 boxBottomRightY = _engine->_renderer->projPosY + 65;
+	const int32 boxTopLeftX = _engine->_renderer->projPos.x - 65;
+	const int32 boxTopLeftY = _engine->_renderer->projPos.y - 65;
+	const int32 boxBottomRightX = _engine->_renderer->projPos.x + 65;
+	const int32 boxBottomRightY = _engine->_renderer->projPos.y + 65;
 	const Common::Rect boxRect(boxTopLeftX, boxTopLeftY, boxBottomRightX, boxBottomRightY);
 	_engine->_sound->playSample(Samples::BigItemFound);
 
@@ -385,7 +385,7 @@ void GameState::processFoundItem(int32 item) {
 
 		_engine->_menu->itemAngle[item] += ANGLE_2;
 
-		_engine->_renderer->renderInventoryItem(_engine->_renderer->projPosX, _engine->_renderer->projPosY, _engine->_resources->inventoryTable[item], _engine->_menu->itemAngle[item], 10000);
+		_engine->_renderer->renderInventoryItem(_engine->_renderer->projPos.x, _engine->_renderer->projPos.y, _engine->_resources->inventoryTable[item], _engine->_menu->itemAngle[item], 10000);
 
 		_engine->_menu->drawBox(boxRect);
 		_engine->_redraw->addRedrawArea(boxRect);
diff --git a/engines/twine/scene/grid.cpp b/engines/twine/scene/grid.cpp
index ba0dca90f5..ecdd5d1f2a 100644
--- a/engines/twine/scene/grid.cpp
+++ b/engines/twine/scene/grid.cpp
@@ -683,8 +683,8 @@ void Grid::redrawGrid() {
 
 	_engine->_renderer->projectPositionOnScreen(-camera.x, -camera.y, -camera.z);
 
-	_engine->_renderer->projPosScreen.x = _engine->_renderer->projPosX;
-	_engine->_renderer->projPosScreen.y = _engine->_renderer->projPosY;
+	_engine->_renderer->projPosScreen.x = _engine->_renderer->projPos.x;
+	_engine->_renderer->projPosScreen.y = _engine->_renderer->projPos.y;
 
 	memset(brickInfoBuffer, 0, _brickInfoBufferSize);
 
@@ -875,7 +875,7 @@ void Grid::centerScreenOnActor() {
 	_engine->_renderer->projectPositionOnScreen(actor->pos.x - (newCamera.x * BRICK_SIZE),
 	                                   actor->pos.y - (newCamera.y * BRICK_HEIGHT),
 	                                   actor->pos.z - (newCamera.z * BRICK_SIZE));
-	if (_engine->_renderer->projPosX < 80 || _engine->_renderer->projPosX >= _engine->width() - 60 || _engine->_renderer->projPosY < 80 || _engine->_renderer->projPosY >= _engine->height() - 50) {
+	if (_engine->_renderer->projPos.x < 80 || _engine->_renderer->projPos.x >= _engine->width() - 60 || _engine->_renderer->projPos.y < 80 || _engine->_renderer->projPos.y >= _engine->height() - 50) {
 		newCamera.x = ((actor->pos.x + BRICK_HEIGHT) / BRICK_SIZE) + (((actor->pos.x + BRICK_HEIGHT) / BRICK_SIZE) - newCamera.x) / 2;
 		newCamera.y = actor->pos.y / BRICK_HEIGHT;
 		newCamera.z = ((actor->pos.z + BRICK_HEIGHT) / BRICK_SIZE) + (((actor->pos.z + BRICK_HEIGHT) / BRICK_SIZE) - newCamera.z) / 2;
diff --git a/engines/twine/twine.cpp b/engines/twine/twine.cpp
index 3c2d83db5f..aaf9c99083 100644
--- a/engines/twine/twine.cpp
+++ b/engines/twine/twine.cpp
@@ -905,12 +905,12 @@ int32 TwinEEngine::runGameEngine() { // mainLoopInteration
 							if (!_actor->cropBottomScreen) {
 								_animations->initAnim(AnimationTypes::kDrawn, kAnimationType_4, AnimationTypes::kStanding, 0);
 								_renderer->projectPositionOnScreen(actor->pos - _grid->camera);
-								_actor->cropBottomScreen = _renderer->projPosY;
+								_actor->cropBottomScreen = _renderer->projPos.y;
 							}
 							_renderer->projectPositionOnScreen(actor->pos - _grid->camera);
 							actor->controlMode = ControlMode::kNoMove;
 							actor->life = -1;
-							_actor->cropBottomScreen = _renderer->projPosY;
+							_actor->cropBottomScreen = _renderer->projPos.y;
 							actor->staticFlags.bCanDrown |= 0x10; // TODO: doesn't make sense
 						}
 					} else {


Commit: 718ef4a58f1646f7b30250ec8ae55de141dc5632
    https://github.com/scummvm/scummvm/commit/718ef4a58f1646f7b30250ec8ae55de141dc5632
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2021-02-26T11:11:21+01:00

Commit Message:
TWINE: converted destXYZ to Vec3

Changed paths:
    engines/twine/holomap.cpp
    engines/twine/renderer/redraw.cpp
    engines/twine/renderer/renderer.cpp
    engines/twine/renderer/renderer.h
    engines/twine/scene/animations.cpp
    engines/twine/scene/collision.cpp
    engines/twine/scene/extra.cpp
    engines/twine/scene/movements.cpp
    engines/twine/scene/scene.cpp
    engines/twine/script/script_life_v1.cpp
    engines/twine/script/script_move_v1.cpp
    engines/twine/twine.cpp


diff --git a/engines/twine/holomap.cpp b/engines/twine/holomap.cpp
index 8472b09712..dd18a21392 100644
--- a/engines/twine/holomap.cpp
+++ b/engines/twine/holomap.cpp
@@ -119,23 +119,23 @@ void Holomap::prepareHolomapSurface() {
 		for (int32 stepWidth = ANGLE_11_25; stepWidth != 0; --stepWidth) {
 			const int32 rotX = stream.readByte();
 			_engine->_movements->rotateActor(rotX * 2 + 1000, 0, angle);
-			const int32 tmpDestY = _engine->_renderer->destZ;
-			_engine->_movements->rotateActor(_engine->_renderer->destX, 0, rotation);
-			_engine->_renderer->getBaseRotationPosition(_engine->_renderer->destX, tmpDestY, _engine->_renderer->destZ);
-			_holomapSurface[holomapSurfaceArrayIdx].x = _engine->_renderer->destX;
-			_holomapSurface[holomapSurfaceArrayIdx].y = _engine->_renderer->destY;
-			_holomapSurface[holomapSurfaceArrayIdx].z = _engine->_renderer->destZ;
+			const int32 tmpDestY = _engine->_renderer->destPos.z;
+			_engine->_movements->rotateActor(_engine->_renderer->destPos.x, 0, rotation);
+			_engine->_renderer->getBaseRotationPosition(_engine->_renderer->destPos.x, tmpDestY, _engine->_renderer->destPos.z);
+			_holomapSurface[holomapSurfaceArrayIdx].x = _engine->_renderer->destPos.x;
+			_holomapSurface[holomapSurfaceArrayIdx].y = _engine->_renderer->destPos.y;
+			_holomapSurface[holomapSurfaceArrayIdx].z = _engine->_renderer->destPos.z;
 			++holomapSurfaceArrayIdx;
 			rotation += ANGLE_11_25;
 		}
 		const int32 rotX = stream.readByte();
 		_engine->_movements->rotateActor(rotX * 2 + 1000, 0, angle);
-		const int32 tmpDestY = _engine->_renderer->destZ;
-		_engine->_movements->rotateActor(_engine->_renderer->destX, 0, ANGLE_0);
-		_engine->_renderer->getBaseRotationPosition(_engine->_renderer->destX, tmpDestY, _engine->_renderer->destZ);
-		_holomapSurface[holomapSurfaceArrayIdx].x = _engine->_renderer->destX;
-		_holomapSurface[holomapSurfaceArrayIdx].y = _engine->_renderer->destY;
-		_holomapSurface[holomapSurfaceArrayIdx].z = _engine->_renderer->destZ;
+		const int32 tmpDestY = _engine->_renderer->destPos.z;
+		_engine->_movements->rotateActor(_engine->_renderer->destPos.x, 0, ANGLE_0);
+		_engine->_renderer->getBaseRotationPosition(_engine->_renderer->destPos.x, tmpDestY, _engine->_renderer->destPos.z);
+		_holomapSurface[holomapSurfaceArrayIdx].x = _engine->_renderer->destPos.x;
+		_holomapSurface[holomapSurfaceArrayIdx].y = _engine->_renderer->destPos.y;
+		_holomapSurface[holomapSurfaceArrayIdx].z = _engine->_renderer->destPos.z;
 		++holomapSurfaceArrayIdx;
 	}
 }
@@ -177,11 +177,11 @@ void Holomap::prepareHolomapPolygons() {
 			HolomapSurface* vec = &_holomapSurface[holomapSurfaceArrayIdx++];
 			_engine->_renderer->getBaseRotationPosition(vec->x, vec->y, vec->z);
 			if (angle != ANGLE_90) {
-				_holomapSort[holomapSortArrayIdx].z = _engine->_renderer->destZ;
+				_holomapSort[holomapSortArrayIdx].z = _engine->_renderer->destPos.z;
 				_holomapSort[holomapSortArrayIdx].projectedPosIdx = _projectedSurfaceIndex;
 				++holomapSortArrayIdx;
 			}
-			_engine->_renderer->projectPositionOnScreen(_engine->_renderer->destX, _engine->_renderer->destY, _engine->_renderer->destZ);
+			_engine->_renderer->projectPositionOnScreen(_engine->_renderer->destPos.x, _engine->_renderer->destPos.y, _engine->_renderer->destPos.z);
 			_projectedSurfacePositions[_projectedSurfaceIndex].x = _engine->_renderer->projPos.x;
 			_projectedSurfacePositions[_projectedSurfaceIndex].y = _engine->_renderer->projPos.y;
 			rotation += ANGLE_11_25;
@@ -189,7 +189,7 @@ void Holomap::prepareHolomapPolygons() {
 		}
 		HolomapSurface* vec = &_holomapSurface[holomapSurfaceArrayIdx++];
 		_engine->_renderer->getBaseRotationPosition(vec->x, vec->y, vec->z);
-		_engine->_renderer->projectPositionOnScreen(_engine->_renderer->destX, _engine->_renderer->destY, _engine->_renderer->destZ);
+		_engine->_renderer->projectPositionOnScreen(_engine->_renderer->destPos.x, _engine->_renderer->destPos.y, _engine->_renderer->destPos.z);
 		_projectedSurfacePositions[_projectedSurfaceIndex].x = _engine->_renderer->projPos.x;
 		_projectedSurfacePositions[_projectedSurfaceIndex].y = _engine->_renderer->projPos.y;
 		rotation += ANGLE_11_25;
@@ -287,9 +287,9 @@ void Holomap::drawHolomapText(int32 centerx, int32 top, const char *title) {
 void Holomap::renderHolomapModel(const uint8 *bodyPtr, int32 x, int32 y, int32 zPos) {
 	_engine->_renderer->setBaseRotation(x, y, 0);
 	_engine->_renderer->getBaseRotationPosition(0, 0, zPos + 1000);
-	_engine->_renderer->getBaseRotationPosition(_engine->_renderer->destX, _engine->_renderer->destY, _engine->_renderer->destZ);
+	_engine->_renderer->getBaseRotationPosition(_engine->_renderer->destPos.x, _engine->_renderer->destPos.y, _engine->_renderer->destPos.z);
 	_engine->_interface->resetClip();
-	_engine->_renderer->renderIsoModel(_engine->_renderer->destX, _engine->_renderer->destY, _engine->_renderer->destZ, x, y, 0, bodyPtr);
+	_engine->_renderer->renderIsoModel(_engine->_renderer->destPos.x, _engine->_renderer->destPos.y, _engine->_renderer->destPos.z, x, y, 0, bodyPtr);
 }
 
 Holomap::TrajectoryData Holomap::loadTrajectoryData(int32 trajectoryIdx) {
@@ -464,27 +464,27 @@ void Holomap::renderLocations(int xRot, int yRot, int zRot, bool lower) {
 			const Location &loc = _locations[locationIdx];
 			_engine->_renderer->setBaseRotation(loc.x, loc.y, 0);
 			_engine->_renderer->getBaseRotationPosition(0, 0, loc.z + 1000);
-			int32 xpos1 = _engine->_renderer->destX;
-			int32 ypos1 = _engine->_renderer->destY;
-			int32 zpos1 = _engine->_renderer->destZ;
+			int32 xpos1 = _engine->_renderer->destPos.x;
+			int32 ypos1 = _engine->_renderer->destPos.y;
+			int32 zpos1 = _engine->_renderer->destPos.z;
 			_engine->_renderer->getBaseRotationPosition(0, 0, 1500);
-			int32 xpos2 = _engine->_renderer->destX;
-			int32 ypos2 = _engine->_renderer->destY;
-			int32 zpos2 = _engine->_renderer->destZ;
+			int32 xpos2 = _engine->_renderer->destPos.x;
+			int32 ypos2 = _engine->_renderer->destPos.y;
+			int32 zpos2 = _engine->_renderer->destPos.z;
 			_engine->_renderer->setBaseRotation(xRot, yRot, zRot, true);
 			int32 zpos1_copy = zpos1;
 			_engine->_renderer->baseRotPos.x = 0;
 			_engine->_renderer->baseRotPos.y = 0;
 			_engine->_renderer->baseRotPos.z = 9500;
 			_engine->_renderer->getBaseRotationPosition(xpos1, ypos1, zpos1);
-			int32 zpos1_copy2 = _engine->_renderer->destZ;
+			int32 zpos1_copy2 = _engine->_renderer->destPos.z;
 			_engine->_renderer->getBaseRotationPosition(xpos2, ypos2, zpos2);
 			if (lower) {
-				if (zpos1_copy2 <= _engine->_renderer->destZ) {
+				if (zpos1_copy2 <= _engine->_renderer->destPos.z) {
 					continue;
 				}
 			} else {
-				if (_engine->_renderer->destZ <= zpos1_copy2) {
+				if (_engine->_renderer->destPos.z <= zpos1_copy2) {
 					continue;
 				}
 			}
diff --git a/engines/twine/renderer/redraw.cpp b/engines/twine/renderer/redraw.cpp
index 54b1f3e2bd..af711df875 100644
--- a/engines/twine/renderer/redraw.cpp
+++ b/engines/twine/renderer/redraw.cpp
@@ -675,8 +675,8 @@ void Redraw::renderOverlays() {
 }
 
 void Redraw::redrawEngineActions(bool bgRedraw) {
-	int16 tmp_projPos.x = _engine->_renderer->projPosScreen.x;
-	int16 tmp_projPos.y = _engine->_renderer->projPosScreen.y;
+	int32 tmp_projPosX = _engine->_renderer->projPosScreen.x;
+	int32 tmp_projPosY = _engine->_renderer->projPosScreen.y;
 
 	_engine->_interface->resetClip();
 
@@ -687,7 +687,7 @@ void Redraw::redrawEngineActions(bool bgRedraw) {
 		}
 		_engine->_screens->clearScreen();
 		_engine->_grid->redrawGrid();
-		updateOverlayTypePosition(tmp_projPos.x, tmp_projPos.y, _engine->_renderer->projPosScreen.x, _engine->_renderer->projPosScreen.y);
+		updateOverlayTypePosition(tmp_projPosX, tmp_projPosY, _engine->_renderer->projPosScreen.x, _engine->_renderer->projPosScreen.y);
 		_engine->_screens->copyScreen(_engine->frontVideoBuffer, _engine->workVideoBuffer);
 
 		if (_engine->_scene->needChangeScene != -1 && _engine->_scene->needChangeScene != -2) {
diff --git a/engines/twine/renderer/renderer.cpp b/engines/twine/renderer/renderer.cpp
index 0c6ffc9e74..0b17d86de3 100644
--- a/engines/twine/renderer/renderer.cpp
+++ b/engines/twine/renderer/renderer.cpp
@@ -152,27 +152,27 @@ void Renderer::setBaseRotation(int32 x, int32 y, int32 z, bool transpose) {
 	}
 	getBaseRotationPosition(baseTransPosX, baseTransPosY, baseTransPosZ);
 
-	baseRotPos.x = destX;
-	baseRotPos.y = destY;
-	baseRotPos.z = destZ;
+	baseRotPos.x = destPos.x;
+	baseRotPos.y = destPos.y;
+	baseRotPos.z = destPos.z;
 }
 
 void Renderer::getBaseRotationPosition(int32 x, int32 y, int32 z) {
-	destX = (baseMatrix.row1[0] * x + baseMatrix.row1[1] * y + baseMatrix.row1[2] * z) / SCENE_SIZE_HALF;
-	destY = (baseMatrix.row2[0] * x + baseMatrix.row2[1] * y + baseMatrix.row2[2] * z) / SCENE_SIZE_HALF;
-	destZ = (baseMatrix.row3[0] * x + baseMatrix.row3[1] * y + baseMatrix.row3[2] * z) / SCENE_SIZE_HALF;
+	destPos.x = (baseMatrix.row1[0] * x + baseMatrix.row1[1] * y + baseMatrix.row1[2] * z) / SCENE_SIZE_HALF;
+	destPos.y = (baseMatrix.row2[0] * x + baseMatrix.row2[1] * y + baseMatrix.row2[2] * z) / SCENE_SIZE_HALF;
+	destPos.z = (baseMatrix.row3[0] * x + baseMatrix.row3[1] * y + baseMatrix.row3[2] * z) / SCENE_SIZE_HALF;
 }
 
 void Renderer::getCameraAnglePositions(int32 x, int32 y, int32 z) {
-	destX = (baseMatrix.row1[0] * x + baseMatrix.row2[0] * y + baseMatrix.row3[0] * z) / SCENE_SIZE_HALF;
-	destY = (baseMatrix.row1[1] * x + baseMatrix.row2[1] * y + baseMatrix.row3[1] * z) / SCENE_SIZE_HALF;
-	destZ = (baseMatrix.row1[2] * x + baseMatrix.row2[2] * y + baseMatrix.row3[2] * z) / SCENE_SIZE_HALF;
+	destPos.x = (baseMatrix.row1[0] * x + baseMatrix.row2[0] * y + baseMatrix.row3[0] * z) / SCENE_SIZE_HALF;
+	destPos.y = (baseMatrix.row1[1] * x + baseMatrix.row2[1] * y + baseMatrix.row3[1] * z) / SCENE_SIZE_HALF;
+	destPos.z = (baseMatrix.row1[2] * x + baseMatrix.row2[2] * y + baseMatrix.row3[2] * z) / SCENE_SIZE_HALF;
 }
 
 void Renderer::translateGroup(int32 x, int32 y, int32 z) {
-	destX = (shadeMatrix.row1[0] * x + shadeMatrix.row1[1] * y + shadeMatrix.row1[2] * z) / SCENE_SIZE_HALF;
-	destY = (shadeMatrix.row2[0] * x + shadeMatrix.row2[1] * y + shadeMatrix.row2[2] * z) / SCENE_SIZE_HALF;
-	destZ = destY;
+	destPos.x = (shadeMatrix.row1[0] * x + shadeMatrix.row1[1] * y + shadeMatrix.row1[2] * z) / SCENE_SIZE_HALF;
+	destPos.y = (shadeMatrix.row2[0] * x + shadeMatrix.row2[1] * y + shadeMatrix.row2[2] * z) / SCENE_SIZE_HALF;
+	destPos.z = destPos.y;
 }
 
 void Renderer::setCameraAngle(int32 transPosX, int32 transPosY, int32 transPosZ, int32 rotPosX, int32 rotPosY, int32 rotPosZ, int32 param6) {
@@ -186,9 +186,9 @@ void Renderer::setCameraAngle(int32 transPosX, int32 transPosY, int32 transPosZ,
 
 	getCameraAnglePositions(baseRotPos.x, baseRotPos.y, baseRotPos.z);
 
-	baseTransPosX = destX;
-	baseTransPosY = destY;
-	baseTransPosZ = destZ;
+	baseTransPosX = destPos.x;
+	baseTransPosY = destPos.y;
+	baseTransPosZ = destPos.z;
 }
 
 void Renderer::applyRotation(Matrix *targetMatrix, const Matrix *currentMatrix) {
@@ -265,9 +265,9 @@ void Renderer::applyPointsRotation(const pointTab *pointsPtr, int32 numPoints, p
 		const int32 tmpY = pointsPtr->y;
 		const int32 tmpZ = pointsPtr->z;
 
-		destPoints->x = ((rotationMatrix->row1[0] * tmpX + rotationMatrix->row1[1] * tmpY + rotationMatrix->row1[2] * tmpZ) / SCENE_SIZE_HALF) + destX;
-		destPoints->y = ((rotationMatrix->row2[0] * tmpX + rotationMatrix->row2[1] * tmpY + rotationMatrix->row2[2] * tmpZ) / SCENE_SIZE_HALF) + destY;
-		destPoints->z = ((rotationMatrix->row3[0] * tmpX + rotationMatrix->row3[1] * tmpY + rotationMatrix->row3[2] * tmpZ) / SCENE_SIZE_HALF) + destZ;
+		destPoints->x = ((rotationMatrix->row1[0] * tmpX + rotationMatrix->row1[1] * tmpY + rotationMatrix->row1[2] * tmpZ) / SCENE_SIZE_HALF) + destPos.x;
+		destPoints->y = ((rotationMatrix->row2[0] * tmpX + rotationMatrix->row2[1] * tmpY + rotationMatrix->row2[2] * tmpZ) / SCENE_SIZE_HALF) + destPos.y;
+		destPoints->z = ((rotationMatrix->row3[0] * tmpX + rotationMatrix->row3[1] * tmpY + rotationMatrix->row3[2] * tmpZ) / SCENE_SIZE_HALF) + destPos.z;
 
 		destPoints++;
 		pointsPtr++;
@@ -287,18 +287,18 @@ void Renderer::processRotatedElement(Matrix *targetMatrix, const pointTab *point
 	if (elemPtr->baseElement == -1) {
 		currentMatrix = &baseMatrix;
 
-		destX = 0;
-		destY = 0;
-		destZ = 0;
+		destPos.x = 0;
+		destPos.y = 0;
+		destPos.z = 0;
 	} else {
 		const int32 pointIdx = elemPtr->basePoint / sizeof(pointTab);
 		const int32 matrixIndex = elemPtr->baseElement;
 		assert(matrixIndex >= 0 && matrixIndex < ARRAYSIZE(matricesTable));
 		currentMatrix = &matricesTable[matrixIndex];
 
-		destX = modelData->computedPoints[pointIdx].x;
-		destY = modelData->computedPoints[pointIdx].y;
-		destZ = modelData->computedPoints[pointIdx].z;
+		destPos.x = modelData->computedPoints[pointIdx].x;
+		destPos.y = modelData->computedPoints[pointIdx].y;
+		destPos.z = modelData->computedPoints[pointIdx].z;
 	}
 
 	applyRotation(targetMatrix, currentMatrix);
@@ -318,9 +318,9 @@ void Renderer::applyPointsTranslation(const pointTab *pointsPtr, int32 numPoints
 		const int32 tmpY = pointsPtr->y + renderAngleY;
 		const int32 tmpZ = pointsPtr->z + renderAngleX;
 
-		destPoints->x = ((translationMatrix->row1[0] * tmpX + translationMatrix->row1[1] * tmpY + translationMatrix->row1[2] * tmpZ) / SCENE_SIZE_HALF) + destX;
-		destPoints->y = ((translationMatrix->row2[0] * tmpX + translationMatrix->row2[1] * tmpY + translationMatrix->row2[2] * tmpZ) / SCENE_SIZE_HALF) + destY;
-		destPoints->z = ((translationMatrix->row3[0] * tmpX + translationMatrix->row3[1] * tmpY + translationMatrix->row3[2] * tmpZ) / SCENE_SIZE_HALF) + destZ;
+		destPoints->x = ((translationMatrix->row1[0] * tmpX + translationMatrix->row1[1] * tmpY + translationMatrix->row1[2] * tmpZ) / SCENE_SIZE_HALF) + destPos.x;
+		destPoints->y = ((translationMatrix->row2[0] * tmpX + translationMatrix->row2[1] * tmpY + translationMatrix->row2[2] * tmpZ) / SCENE_SIZE_HALF) + destPos.y;
+		destPoints->z = ((translationMatrix->row3[0] * tmpX + translationMatrix->row3[1] * tmpY + translationMatrix->row3[2] * tmpZ) / SCENE_SIZE_HALF) + destPos.z;
 
 		destPoints++;
 		pointsPtr++;
@@ -333,16 +333,16 @@ void Renderer::processTranslatedElement(Matrix *targetMatrix, const pointTab *po
 	renderAngleZ = rotZ;
 
 	if (elemPtr->baseElement == -1) { // base point
-		destX = 0;
-		destY = 0;
-		destZ = 0;
+		destPos.x = 0;
+		destPos.y = 0;
+		destPos.z = 0;
 
 		*targetMatrix = baseMatrix;
 	} else { // dependent
 		const int pointsIdx = elemPtr->basePoint / 6;
-		destX = modelData->computedPoints[pointsIdx].x;
-		destY = modelData->computedPoints[pointsIdx].y;
-		destZ = modelData->computedPoints[pointsIdx].z;
+		destPos.x = modelData->computedPoints[pointsIdx].x;
+		destPos.y = modelData->computedPoints[pointsIdx].y;
+		destPos.z = modelData->computedPoints[pointsIdx].z;
 
 		const int32 matrixIndex = elemPtr->baseElement;
 		assert(matrixIndex >= 0 && matrixIndex < ARRAYSIZE(matricesTable));
@@ -365,9 +365,9 @@ void Renderer::setLightVector(int32 angleX, int32 angleY, int32 angleZ) {
 	applyRotation(&shadeMatrix, &baseMatrix);
 	translateGroup(0, 0, 59);
 
-	lightPos.x = destX;
-	lightPos.y = destY;
-	lightPos.z = destZ;
+	lightPos.x = destPos.x;
+	lightPos.y = destPos.y;
+	lightPos.z = destPos.z;
 }
 
 FORCEINLINE int16 clamp(int16 x, int16 a, int16 b) {
@@ -1477,9 +1477,9 @@ bool Renderer::renderIsoModel(int32 x, int32 y, int32 z, int32 angleX, int32 ang
 	} else {
 		getBaseRotationPosition(x, y, z);
 
-		renderX = destX - baseRotPos.x;
-		renderY = destY - baseRotPos.y; // RECHECK
-		renderZ = destZ - baseRotPos.z;
+		renderX = destPos.x - baseRotPos.x;
+		renderY = destPos.y - baseRotPos.y; // RECHECK
+		renderZ = destPos.z - baseRotPos.z;
 	}
 
 	if (!Model::isAnimated(bodyPtr)) {
diff --git a/engines/twine/renderer/renderer.h b/engines/twine/renderer/renderer.h
index 21917ef6b0..a2db934d13 100644
--- a/engines/twine/renderer/renderer.h
+++ b/engines/twine/renderer/renderer.h
@@ -398,10 +398,7 @@ public:
 	Vec3 projPos;
 	Vec3 baseRotPos;
 	Vec3 orthoProjPos;
-
-	int32 destX = 0;
-	int32 destY = 0;
-	int32 destZ = 0;
+	Vec3 destPos;
 
 	const int16 *const shadeAngleTab3;
 
diff --git a/engines/twine/scene/animations.cpp b/engines/twine/scene/animations.cpp
index 44af168178..34939b63d8 100644
--- a/engines/twine/scene/animations.cpp
+++ b/engines/twine/scene/animations.cpp
@@ -387,9 +387,9 @@ void Animations::processAnimActions(int32 actorIdx) {
 			if (action.animFrame == actor->animPosition) {
 				_engine->_movements->rotateActor(action.distanceX, action.distanceZ, actor->angle);
 
-				const int32 throwX = _engine->_renderer->destX + actor->pos.x;
+				const int32 throwX = _engine->_renderer->destPos.x + actor->pos.x;
 				const int32 throwY = action.distanceY + actor->pos.y;
-				const int32 throwZ = _engine->_renderer->destZ + actor->pos.z;
+				const int32 throwZ = _engine->_renderer->destPos.z + actor->pos.z;
 
 				_engine->_extra->addExtraThrow(actorIdx, throwX, throwY, throwZ, action.spriteIndex,
 				                               action.xAngle, action.yAngle + actor->angle, action.xRotPoint, action.extraAngle, action.strength);
@@ -402,9 +402,9 @@ void Animations::processAnimActions(int32 actorIdx) {
 
 				_engine->_movements->rotateActor(action.distanceX, action.distanceZ, actor->angle);
 
-				const int32 throwX = _engine->_renderer->destX + actor->pos.x;
+				const int32 throwX = _engine->_renderer->destPos.x + actor->pos.x;
 				const int32 throwY = action.distanceY + actor->pos.y;
-				const int32 throwZ = _engine->_renderer->destZ + actor->pos.z;
+				const int32 throwZ = _engine->_renderer->destPos.z + actor->pos.z;
 
 				_engine->_extra->addExtraThrow(actorIdx, throwX, throwY, throwZ, action.spriteIndex,
 				                               action.xAngle + newAngle, action.yAngle + actor->angle, action.xRotPoint, action.extraAngle, action.strength);
@@ -413,9 +413,9 @@ void Animations::processAnimActions(int32 actorIdx) {
 		case ActionType::ACTION_THROW_3D_SEARCH:
 			if (action.animFrame == actor->animPosition) {
 				_engine->_movements->rotateActor(action.distanceX, action.distanceZ, actor->angle);
-				const int32 x = actor->pos.x + _engine->_renderer->destX;
+				const int32 x = actor->pos.x + _engine->_renderer->destPos.x;
 				const int32 y = actor->pos.y + action.distanceY;
-				const int32 z = actor->pos.z + _engine->_renderer->destZ;
+				const int32 z = actor->pos.z + _engine->_renderer->destPos.z;
 				_engine->_extra->addExtraAiming(actorIdx, x, y, z, action.spriteIndex,
 				                                action.targetActor, action.finalAngle, action.strength);
 			}
@@ -423,9 +423,9 @@ void Animations::processAnimActions(int32 actorIdx) {
 		case ActionType::ACTION_UNKNOWN_21:
 			if (_engine->_gameState->magicBallIdx == -1 && action.animFrame == actor->animPosition) {
 				_engine->_movements->rotateActor(action.distanceX, action.distanceZ, actor->angle);
-				const int32 x = actor->pos.x + _engine->_renderer->destX;
+				const int32 x = actor->pos.x + _engine->_renderer->destPos.x;
 				const int32 y = actor->pos.y + action.distanceY;
-				const int32 z = actor->pos.z + _engine->_renderer->destZ;
+				const int32 z = actor->pos.z + _engine->_renderer->destPos.z;
 				_engine->_extra->addExtraThrowMagicball(x, y, z, action.xAngle, actor->angle, action.yAngle, action.finalAngle);
 			}
 			break;
@@ -539,12 +539,12 @@ void Animations::processActorAnimations(int32 actorIdx) { // DoAnim
 
 				_engine->_movements->rotateActor(xAxisRotation, 0, actor->animType);
 
-				_engine->_movements->processActor.y = actor->pos.y - _engine->_renderer->destZ;
+				_engine->_movements->processActor.y = actor->pos.y - _engine->_renderer->destPos.z;
 
-				_engine->_movements->rotateActor(0, _engine->_renderer->destX, actor->angle);
+				_engine->_movements->rotateActor(0, _engine->_renderer->destPos.x, actor->angle);
 
-				_engine->_movements->processActor.x = actor->pos.x + _engine->_renderer->destX;
-				_engine->_movements->processActor.z = actor->pos.z + _engine->_renderer->destZ;
+				_engine->_movements->processActor.x = actor->pos.x + _engine->_renderer->destPos.x;
+				_engine->_movements->processActor.z = actor->pos.z + _engine->_renderer->destPos.z;
 
 				_engine->_movements->setActorAngle(ANGLE_0, actor->speed, ANGLE_17, &actor->move);
 
@@ -629,8 +629,8 @@ void Animations::processActorAnimations(int32 actorIdx) { // DoAnim
 
 			_engine->_movements->rotateActor(currentStepX, currentStepZ, actor->angle);
 
-			currentStepX = _engine->_renderer->destX;
-			currentStepZ = _engine->_renderer->destZ;
+			currentStepX = _engine->_renderer->destPos.x;
+			currentStepZ = _engine->_renderer->destPos.z;
 
 			_engine->_movements->processActor.x = actor->pos.x + currentStepX - actor->lastPos.x;
 			_engine->_movements->processActor.y = actor->pos.y + currentStepY - actor->lastPos.y;
@@ -747,11 +747,11 @@ void Animations::processActorAnimations(int32 actorIdx) { // DoAnim
 		if (_engine->_collision->causeActorDamage && !actor->dynamicFlags.bIsFalling && !currentlyProcessedActorIdx && _engine->_actor->heroBehaviour == HeroBehaviourType::kAthletic && actor->anim == AnimationTypes::kForward) {
 			_engine->_movements->rotateActor(actor->boudingBox.x.bottomLeft, actor->boudingBox.z.bottomLeft, actor->angle + ANGLE_360 + ANGLE_135);
 
-			_engine->_renderer->destX += _engine->_movements->processActor.x;
-			_engine->_renderer->destZ += _engine->_movements->processActor.z;
+			_engine->_renderer->destPos.x += _engine->_movements->processActor.x;
+			_engine->_renderer->destPos.z += _engine->_movements->processActor.z;
 
-			if (_engine->_renderer->destX >= 0 && _engine->_renderer->destZ >= 0 && _engine->_renderer->destX <= 0x7E00 && _engine->_renderer->destZ <= 0x7E00) {
-				if (_engine->_grid->getBrickShape(_engine->_renderer->destX, _engine->_movements->processActor.y + BRICK_HEIGHT, _engine->_renderer->destZ) != ShapeType::kNone && _engine->cfgfile.WallCollision) { // avoid wall hit damage
+			if (_engine->_renderer->destPos.x >= 0 && _engine->_renderer->destPos.z >= 0 && _engine->_renderer->destPos.x <= 0x7E00 && _engine->_renderer->destPos.z <= 0x7E00) {
+				if (_engine->_grid->getBrickShape(_engine->_renderer->destPos.x, _engine->_movements->processActor.y + BRICK_HEIGHT, _engine->_renderer->destPos.z) != ShapeType::kNone && _engine->cfgfile.WallCollision) { // avoid wall hit damage
 					_engine->_extra->addExtraSpecial(actor->pos.x, actor->pos.y + 1000, actor->pos.z, ExtraSpecialType::kHitStars);
 					initAnim(AnimationTypes::kBigHit, kAnimationType_2, AnimationTypes::kStanding, currentlyProcessedActorIdx);
 
diff --git a/engines/twine/scene/collision.cpp b/engines/twine/scene/collision.cpp
index e6e1594167..d4faf47bb1 100644
--- a/engines/twine/scene/collision.cpp
+++ b/engines/twine/scene/collision.cpp
@@ -346,14 +346,14 @@ int32 Collision::checkCollisionWithActors(int32 actorIdx) {
 	if (actor->dynamicFlags.bIsHitting) {
 		_engine->_movements->rotateActor(0, 200, actor->angle);
 
-		xLeft = _engine->_renderer->destX + _engine->_movements->processActor.x + actor->boudingBox.x.bottomLeft;
-		xRight = _engine->_renderer->destX + _engine->_movements->processActor.x + actor->boudingBox.x.topRight;
+		xLeft = _engine->_renderer->destPos.x + _engine->_movements->processActor.x + actor->boudingBox.x.bottomLeft;
+		xRight = _engine->_renderer->destPos.x + _engine->_movements->processActor.x + actor->boudingBox.x.topRight;
 
 		yLeft = _engine->_movements->processActor.y + actor->boudingBox.y.bottomLeft;
 		yRight = _engine->_movements->processActor.y + actor->boudingBox.y.topRight;
 
-		zLeft = _engine->_renderer->destZ + _engine->_movements->processActor.z + actor->boudingBox.z.bottomLeft;
-		zRight = _engine->_renderer->destZ + _engine->_movements->processActor.z + actor->boudingBox.z.topRight;
+		zLeft = _engine->_renderer->destPos.z + _engine->_movements->processActor.z + actor->boudingBox.z.bottomLeft;
+		zRight = _engine->_renderer->destPos.z + _engine->_movements->processActor.z + actor->boudingBox.z.topRight;
 
 		for (int32 a = 0; a < _engine->_scene->sceneNumActors; a++) {
 			const ActorStruct *actorTest = _engine->_scene->getActor(a);
diff --git a/engines/twine/scene/extra.cpp b/engines/twine/scene/extra.cpp
index b547b67941..38105b9b49 100644
--- a/engines/twine/scene/extra.cpp
+++ b/engines/twine/scene/extra.cpp
@@ -166,12 +166,12 @@ void Extra::throwExtra(ExtraListStruct *extra, int32 xAngle, int32 yAngle, int32
 
 	_engine->_movements->rotateActor(x, 0, xAngle);
 
-	extra->destPos.y = -_engine->_renderer->destZ;
+	extra->destPos.y = -_engine->_renderer->destPos.z;
 
-	_engine->_movements->rotateActor(0, _engine->_renderer->destX, yAngle);
+	_engine->_movements->rotateActor(0, _engine->_renderer->destPos.x, yAngle);
 
-	extra->destPos.x = _engine->_renderer->destX;
-	extra->destPos.z = _engine->_renderer->destZ;
+	extra->destPos.x = _engine->_renderer->destPos.x;
+	extra->destPos.z = _engine->_renderer->destPos.z;
 
 	extra->angle = extraAngle;
 	extra->spawnTime = _engine->lbaTime;
@@ -443,8 +443,8 @@ void Extra::drawSpecialShape(const int16 *shapeTable, int32 x, int32 y, int32 co
 
 	_engine->_movements->rotateActor(var_x, var_z, angle);
 
-	const int32 computedX = _engine->_renderer->destX + x;
-	const int32 computedY = _engine->_renderer->destZ + y;
+	const int32 computedX = _engine->_renderer->destPos.x + x;
+	const int32 computedY = _engine->_renderer->destPos.z + y;
 
 	if (computedX < _engine->_redraw->renderRect.left) {
 		_engine->_redraw->renderRect.left = computedX;
@@ -477,8 +477,8 @@ void Extra::drawSpecialShape(const int16 *shapeTable, int32 x, int32 y, int32 co
 
 		_engine->_movements->rotateActor(var_x, var_z, angle);
 
-		currentX = _engine->_renderer->destX + x;
-		currentY = _engine->_renderer->destZ + y;
+		currentX = _engine->_renderer->destPos.x + x;
+		currentY = _engine->_renderer->destPos.z + y;
 
 		if (currentX < _engine->_redraw->renderRect.left) {
 			_engine->_redraw->renderRect.left = currentX;
@@ -660,11 +660,11 @@ void Extra::processExtras() {
 			}
 
 			_engine->_movements->rotateActor(pos, 0, angle2);
-			extra->pos.y -= _engine->_renderer->destZ;
+			extra->pos.y -= _engine->_renderer->destPos.z;
 
-			_engine->_movements->rotateActor(0, _engine->_renderer->destX, tmpAngle);
-			extra->pos.x += _engine->_renderer->destX;
-			extra->pos.z += _engine->_renderer->destZ;
+			_engine->_movements->rotateActor(0, _engine->_renderer->destPos.x, tmpAngle);
+			extra->pos.x += _engine->_renderer->destPos.x;
+			extra->pos.z += _engine->_renderer->destPos.z;
 
 			_engine->_movements->setActorAngle(ANGLE_0, extra->destPos.z, ANGLE_17, &extra->trackActorMove);
 
@@ -711,11 +711,11 @@ void Extra::processExtras() {
 			}
 
 			_engine->_movements->rotateActor(pos, 0, angle2);
-			extra->pos.y -= _engine->_renderer->destZ;
+			extra->pos.y -= _engine->_renderer->destPos.z;
 
-			_engine->_movements->rotateActor(0, _engine->_renderer->destX, tmpAngle);
-			extra->pos.x += _engine->_renderer->destX;
-			extra->pos.z += _engine->_renderer->destZ;
+			_engine->_movements->rotateActor(0, _engine->_renderer->destPos.x, tmpAngle);
+			extra->pos.x += _engine->_renderer->destPos.x;
+			extra->pos.z += _engine->_renderer->destPos.z;
 
 			_engine->_movements->setActorAngle(ANGLE_0, extra->destPos.z, ANGLE_17, &extra->trackActorMove);
 
diff --git a/engines/twine/scene/movements.cpp b/engines/twine/scene/movements.cpp
index f322e6ac6e..095dca22b1 100644
--- a/engines/twine/scene/movements.cpp
+++ b/engines/twine/scene/movements.cpp
@@ -140,8 +140,8 @@ int32 Movements::getAngleAndSetTargetActorDistance(int32 x1, int32 z1, int32 x2,
 
 void Movements::rotateActor(int32 x, int32 z, int32 angle) {
 	const double radians = AngleToRadians(angle);
-	_engine->_renderer->destX = (int32)(x * cos(radians) + z * sin(radians));
-	_engine->_renderer->destZ = (int32)(-x * sin(radians) + z * cos(radians));
+	_engine->_renderer->destPos.x = (int32)(x * cos(radians) + z * sin(radians));
+	_engine->_renderer->destPos.z = (int32)(-x * sin(radians) + z * cos(radians));
 }
 
 int32 Movements::getDistance2D(int32 x1, int32 z1, int32 x2, int32 z2) const {
diff --git a/engines/twine/scene/scene.cpp b/engines/twine/scene/scene.cpp
index bab00eb3de..9e1e637fdd 100644
--- a/engines/twine/scene/scene.cpp
+++ b/engines/twine/scene/scene.cpp
@@ -713,11 +713,11 @@ void Scene::processActorZones(int32 actorIdx) {
 			case ZoneType::kLadder:
 				if (IS_HERO(actorIdx) && _engine->_actor->heroBehaviour != HeroBehaviourType::kProtoPack && (actor->anim == AnimationTypes::kForward || actor->anim == AnimationTypes::kTopLadder || actor->anim == AnimationTypes::kClimbLadder)) {
 					_engine->_movements->rotateActor(actor->boudingBox.x.bottomLeft, actor->boudingBox.z.bottomLeft, actor->angle + ANGLE_360 + ANGLE_135);
-					_engine->_renderer->destX += _engine->_movements->processActor.x;
-					_engine->_renderer->destZ += _engine->_movements->processActor.z;
+					_engine->_renderer->destPos.x += _engine->_movements->processActor.x;
+					_engine->_renderer->destPos.z += _engine->_movements->processActor.z;
 
-					if (_engine->_renderer->destX >= 0 && _engine->_renderer->destZ >= 0 && _engine->_renderer->destX <= 0x7E00 && _engine->_renderer->destZ <= 0x7E00) {
-						if (_engine->_grid->getBrickShape(_engine->_renderer->destX, actor->pos.y + ANGLE_90, _engine->_renderer->destZ) != ShapeType::kNone) {
+					if (_engine->_renderer->destPos.x >= 0 && _engine->_renderer->destPos.z >= 0 && _engine->_renderer->destPos.x <= 0x7E00 && _engine->_renderer->destPos.z <= 0x7E00) {
+						if (_engine->_grid->getBrickShape(_engine->_renderer->destPos.x, actor->pos.y + ANGLE_90, _engine->_renderer->destPos.z) != ShapeType::kNone) {
 							currentActorInZone = true;
 							if (actor->pos.y >= ABS(zone->bottomLeft.y + zone->topRight.y) / 2) {
 								_engine->_animations->initAnim(AnimationTypes::kTopLadder, kAnimationType_2, AnimationTypes::kStanding, actorIdx); // reached end of ladder
diff --git a/engines/twine/script/script_life_v1.cpp b/engines/twine/script/script_life_v1.cpp
index edec817116..ff02d9321c 100644
--- a/engines/twine/script/script_life_v1.cpp
+++ b/engines/twine/script/script_life_v1.cpp
@@ -1121,9 +1121,9 @@ static int32 lPOS_POINT(TwinEEngine *engine, LifeScriptContext &ctx) {
 	int32 trackIdx = ctx.stream.readByte();
 
 	const ScenePoint &sp = engine->_scene->sceneTracks[trackIdx];
-	engine->_renderer->destX = sp.x;
-	engine->_renderer->destY = sp.y;
-	engine->_renderer->destZ = sp.z;
+	engine->_renderer->destPos.x = sp.x;
+	engine->_renderer->destPos.y = sp.y;
+	engine->_renderer->destPos.z = sp.z;
 
 	ctx.actor->pos.x = sp.x;
 	ctx.actor->pos.y = sp.y;
diff --git a/engines/twine/script/script_move_v1.cpp b/engines/twine/script/script_move_v1.cpp
index 39be09049b..977149b8d6 100644
--- a/engines/twine/script/script_move_v1.cpp
+++ b/engines/twine/script/script_move_v1.cpp
@@ -117,9 +117,9 @@ static int32 mGOTO_POINT(TwinEEngine *engine, MoveScriptContext &ctx) {
 	engine->_scene->currentScriptValue = ctx.stream.readByte();
 
 	const ScenePoint &sp = engine->_scene->sceneTracks[engine->_scene->currentScriptValue];
-	engine->_renderer->destX = sp.x;
-	engine->_renderer->destY = sp.y;
-	engine->_renderer->destZ = sp.z;
+	engine->_renderer->destPos.x = sp.x;
+	engine->_renderer->destPos.y = sp.y;
+	engine->_renderer->destPos.z = sp.z;
 
 	const int32 newAngle = engine->_movements->getAngleAndSetTargetActorDistance(ctx.actor->pos.x, ctx.actor->pos.z, sp.x, sp.z);
 
@@ -189,9 +189,9 @@ static int32 mPOS_POINT(TwinEEngine *engine, MoveScriptContext &ctx) {
 	engine->_scene->currentScriptValue = ctx.stream.readByte();
 
 	const ScenePoint &sp = engine->_scene->sceneTracks[engine->_scene->currentScriptValue];
-	engine->_renderer->destX = sp.x;
-	engine->_renderer->destY = sp.y;
-	engine->_renderer->destZ = sp.z;
+	engine->_renderer->destPos.x = sp.x;
+	engine->_renderer->destPos.y = sp.y;
+	engine->_renderer->destPos.z = sp.z;
 
 	if (ctx.actor->staticFlags.bIsSpriteActor) {
 		ctx.actor->speed = 0;
@@ -249,9 +249,9 @@ static int32 mGOTO_SYM_POINT(TwinEEngine *engine, MoveScriptContext &ctx) {
 	engine->_scene->currentScriptValue = ctx.stream.readByte();
 
 	const ScenePoint &sp = engine->_scene->sceneTracks[engine->_scene->currentScriptValue];
-	engine->_renderer->destX = sp.x;
-	engine->_renderer->destY = sp.y;
-	engine->_renderer->destZ = sp.z;
+	engine->_renderer->destPos.x = sp.x;
+	engine->_renderer->destPos.y = sp.y;
+	engine->_renderer->destPos.z = sp.z;
 
 	const int32 newAngle = ANGLE_180 + engine->_movements->getAngleAndSetTargetActorDistance(ctx.actor->pos.x, ctx.actor->pos.z, sp.x, sp.z);
 
@@ -322,9 +322,9 @@ static int32 mGOTO_POINT_3D(TwinEEngine *engine, MoveScriptContext &ctx) {
 	engine->_scene->currentScriptValue = trackId;
 
 	const ScenePoint &sp = engine->_scene->sceneTracks[engine->_scene->currentScriptValue];
-	engine->_renderer->destX = sp.x;
-	engine->_renderer->destY = sp.y;
-	engine->_renderer->destZ = sp.z;
+	engine->_renderer->destPos.x = sp.x;
+	engine->_renderer->destPos.y = sp.y;
+	engine->_renderer->destPos.z = sp.z;
 
 	ctx.actor->angle = engine->_movements->getAngleAndSetTargetActorDistance(ctx.actor->pos.x, ctx.actor->pos.z, sp.x, sp.z);
 	// TODO: this adds an angle to the animType value
diff --git a/engines/twine/twine.cpp b/engines/twine/twine.cpp
index aaf9c99083..9bd006bcb7 100644
--- a/engines/twine/twine.cpp
+++ b/engines/twine/twine.cpp
@@ -636,9 +636,9 @@ void TwinEEngine::processInventoryAction() {
 	case kiPinguin: {
 		ActorStruct *pinguin = _scene->getActor(_scene->mecaPinguinIdx);
 
-		pinguin->pos.x = _renderer->destX + _scene->sceneHero->pos.x;
+		pinguin->pos.x = _renderer->destPos.x + _scene->sceneHero->pos.x;
 		pinguin->pos.y = _scene->sceneHero->pos.y;
-		pinguin->pos.z = _renderer->destZ + _scene->sceneHero->pos.z;
+		pinguin->pos.z = _renderer->destPos.z + _scene->sceneHero->pos.z;
 		pinguin->angle = _scene->sceneHero->angle;
 
 		_movements->rotateActor(0, 800, pinguin->angle);


Commit: 9743f36d95fc0e7034d583257877cbcba71420d5
    https://github.com/scummvm/scummvm/commit/9743f36d95fc0e7034d583257877cbcba71420d5
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2021-02-26T11:11:21+01:00

Commit Message:
TWINE: converted Renderer class members to Vec3

Changed paths:
    engines/twine/renderer/renderer.cpp
    engines/twine/renderer/renderer.h


diff --git a/engines/twine/renderer/renderer.cpp b/engines/twine/renderer/renderer.cpp
index 0b17d86de3..d3e12c0647 100644
--- a/engines/twine/renderer/renderer.cpp
+++ b/engines/twine/renderer/renderer.cpp
@@ -98,9 +98,9 @@ void Renderer::setCameraPosition(int32 x, int32 y, int32 depthOffset, int32 scal
 }
 
 void Renderer::setBaseTranslation(int32 x, int32 y, int32 z) {
-	baseTransPosX = x;
-	baseTransPosY = y;
-	baseTransPosZ = z;
+	baseTransPos.x = x;
+	baseTransPos.y = y;
+	baseTransPos.z = z;
 }
 
 void Renderer::setOrthoProjection(int32 x, int32 y, int32 z) {
@@ -150,7 +150,7 @@ void Renderer::setBaseRotation(int32 x, int32 y, int32 z, bool transpose) {
 	if (transpose) {
 		baseMatrixTranspose();
 	}
-	getBaseRotationPosition(baseTransPosX, baseTransPosY, baseTransPosZ);
+	getBaseRotationPosition(baseTransPos.x, baseTransPos.y, baseTransPos.z);
 
 	baseRotPos.x = destPos.x;
 	baseRotPos.y = destPos.y;
@@ -176,9 +176,9 @@ void Renderer::translateGroup(int32 x, int32 y, int32 z) {
 }
 
 void Renderer::setCameraAngle(int32 transPosX, int32 transPosY, int32 transPosZ, int32 rotPosX, int32 rotPosY, int32 rotPosZ, int32 param6) {
-	baseTransPosX = transPosX;
-	baseTransPosY = transPosY;
-	baseTransPosZ = transPosZ;
+	baseTransPos.x = transPosX;
+	baseTransPos.y = transPosY;
+	baseTransPos.z = transPosZ;
 
 	setBaseRotation(rotPosX, rotPosY, rotPosZ);
 
@@ -186,9 +186,7 @@ void Renderer::setCameraAngle(int32 transPosX, int32 transPosY, int32 transPosZ,
 
 	getCameraAnglePositions(baseRotPos.x, baseRotPos.y, baseRotPos.z);
 
-	baseTransPosX = destPos.x;
-	baseTransPosY = destPos.y;
-	baseTransPosZ = destPos.z;
+	baseTransPos = destPos;
 }
 
 void Renderer::applyRotation(Matrix *targetMatrix, const Matrix *currentMatrix) {
@@ -1292,9 +1290,9 @@ bool Renderer::renderAnimatedModel(ModelData *modelData, const uint8 *bodyPtr, R
 
 	if (isUsingOrthoProjection) { // use standard projection
 		do {
-			const int32 coX = pointPtr->x + renderX;
-			const int32 coY = pointPtr->y + renderY;
-			const int32 coZ = -(pointPtr->z + renderZ);
+			const int32 coX = pointPtr->x + renderPos.x;
+			const int32 coY = pointPtr->y + renderPos.y;
+			const int32 coZ = -(pointPtr->z + renderPos.z);
 
 			pointPtrDest->x = (coX + coZ) * 24 / BRICK_SIZE + orthoProjPos.x;
 			pointPtrDest->y = (((coX - coZ) * 12) - coY * 30) / BRICK_SIZE + orthoProjPos.y;
@@ -1319,9 +1317,9 @@ bool Renderer::renderAnimatedModel(ModelData *modelData, const uint8 *bodyPtr, R
 		} while (--numOfPrimitives);
 	} else {
 		do {
-			int32 coX = pointPtr->x + renderX;
-			int32 coY = pointPtr->y + renderY;
-			int32 coZ = -(pointPtr->z + renderZ);
+			int32 coX = pointPtr->x + renderPos.x;
+			int32 coY = pointPtr->y + renderPos.y;
+			int32 coZ = -(pointPtr->z + renderPos.z);
 
 			coZ += cameraDepthOffset;
 
@@ -1471,15 +1469,15 @@ bool Renderer::renderIsoModel(int32 x, int32 y, int32 z, int32 angleX, int32 ang
 	_engine->_redraw->renderRect.bottom = SCENE_SIZE_MIN;
 
 	if (isUsingOrthoProjection) {
-		renderX = x;
-		renderY = y;
-		renderZ = z;
+		renderPos.x = x;
+		renderPos.y = y;
+		renderPos.z = z;
 	} else {
 		getBaseRotationPosition(x, y, z);
 
-		renderX = destPos.x - baseRotPos.x;
-		renderY = destPos.y - baseRotPos.y; // RECHECK
-		renderZ = destPos.z - baseRotPos.z;
+		renderPos.x = destPos.x - baseRotPos.x;
+		renderPos.y = destPos.y - baseRotPos.y; // RECHECK
+		renderPos.z = destPos.z - baseRotPos.z;
 	}
 
 	if (!Model::isAnimated(bodyPtr)) {
diff --git a/engines/twine/renderer/renderer.h b/engines/twine/renderer/renderer.h
index a2db934d13..7689f3070e 100644
--- a/engines/twine/renderer/renderer.h
+++ b/engines/twine/renderer/renderer.h
@@ -330,9 +330,7 @@ private:
 
 	// ---- variables ----
 
-	int32 baseTransPosX = 0; // setSomething2Var1
-	int32 baseTransPosY = 0; // setSomething2Var2
-	int32 baseTransPosZ = 0; // setSomething2Var3
+	Vec3 baseTransPos;
 
 	int32 cameraDepthOffset = 0; // cameraVar1
 	int32 cameraScaleY = 0; // cameraVar2
@@ -344,9 +342,7 @@ private:
 	int32 renderAngleY = 0; // _angleY
 	int32 renderAngleZ = 0; // _angleZ
 
-	int32 renderX = 0; // _X
-	int32 renderY = 0; // _Y
-	int32 renderZ = 0; // _Z
+	Vec3 renderPos;
 
 	// ---
 


Commit: 9275999d9b379a1d5239e366c11af975e4d88e5c
    https://github.com/scummvm/scummvm/commit/9275999d9b379a1d5239e366c11af975e4d88e5c
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2021-02-26T11:11:21+01:00

Commit Message:
TWINE: hide min/max values of inventory items

also extract the max life points of an actor into a constant

Changed paths:
    engines/twine/debugger/console.cpp
    engines/twine/menu/menu.cpp
    engines/twine/renderer/renderer.cpp
    engines/twine/scene/actor.cpp
    engines/twine/scene/actor.h
    engines/twine/scene/extra.cpp
    engines/twine/scene/gamestate.cpp
    engines/twine/scene/gamestate.h
    engines/twine/script/script_life_v1.cpp
    engines/twine/twine.cpp


diff --git a/engines/twine/debugger/console.cpp b/engines/twine/debugger/console.cpp
index 177a3cd441..f2d3ca2c72 100644
--- a/engines/twine/debugger/console.cpp
+++ b/engines/twine/debugger/console.cpp
@@ -243,7 +243,7 @@ bool TwinEConsole::doGiveKey(int argc, const char **argv) {
 	if (argc >= 2) {
 		amount = atoi(argv[1]);
 	}
-	_engine->_gameState->setKeys(_engine->_gameState->inventoryNumKeys + amount);
+	_engine->_gameState->addKeys(amount);
 	return true;
 }
 
@@ -252,7 +252,7 @@ bool TwinEConsole::doGiveGas(int argc, const char **argv) {
 	if (argc >= 2) {
 		amount = atoi(argv[1]);
 	}
-	_engine->_gameState->setGas(_engine->_gameState->inventoryNumGas + amount);
+	_engine->_gameState->addGas(amount);
 	return true;
 }
 
@@ -261,7 +261,7 @@ bool TwinEConsole::doGiveKashes(int argc, const char **argv) {
 	if (argc >= 2) {
 		amount = atoi(argv[1]);
 	}
-	_engine->_gameState->setKashes(_engine->_gameState->inventoryNumKashes + amount);
+	_engine->_gameState->addKashes(amount);
 	return true;
 }
 
@@ -401,25 +401,12 @@ bool TwinEConsole::doGiveAllItems(int argc, const char **argv) {
 	if (argc >= 2) {
 		amount = atoi(argv[1]);
 	}
-	state->inventoryNumKeys += amount;
-	state->inventoryNumKashes += amount;
-	state->inventoryNumLeafsBox += amount;
-	state->inventoryNumLeafs += amount;
-	state->inventoryMagicPoints += amount;
-	state->setGas(state->inventoryNumGas + amount);
-	state->setKashes(state->inventoryNumKashes + amount);
-
-	if (state->inventoryNumLeafsBox > 10) {
-		state->inventoryNumLeafsBox = 10;
-	}
-
-	if (state->inventoryNumLeafs > state->inventoryNumLeafsBox) {
-		state->inventoryNumLeafs = state->inventoryNumLeafsBox;
-	}
-
-	if (state->inventoryMagicPoints > state->magicLevelIdx * 20) {
-		state->inventoryMagicPoints = state->magicLevelIdx * 20;
-	}
+	state->addKeys(amount);
+	state->addLeafBoxes(amount);
+	state->addKashes(amount);
+	state->addLeafs(amount);
+	state->addMagicPoints(amount);
+	state->addGas(amount);
 
 	return true;
 }
@@ -429,10 +416,7 @@ bool TwinEConsole::doSetLife(int argc, const char **argv) {
 		debugPrintf("Expected to get the life points as parameter\n");
 		return true;
 	}
-	_engine->_scene->sceneHero->life = atoi(argv[1]);
-	if (_engine->_scene->sceneHero->life > 50) {
-		_engine->_scene->sceneHero->life = 50;
-	}
+	_engine->_scene->sceneHero->setLife(atoi(argv[1]));
 	return true;
 }
 
diff --git a/engines/twine/menu/menu.cpp b/engines/twine/menu/menu.cpp
index b0f1172d2c..8c45f90b6f 100644
--- a/engines/twine/menu/menu.cpp
+++ b/engines/twine/menu/menu.cpp
@@ -819,11 +819,6 @@ void Menu::drawHealthBar(int32 left, int32 right, int32 top, int32 barLeftPaddin
 }
 
 void Menu::drawCloverLeafs(int32 newBoxLeft, int32 boxRight, int32 top) {
-	// prevent
-	if (_engine->_gameState->inventoryNumLeafs > _engine->_gameState->inventoryNumLeafsBox) {
-		_engine->_gameState->inventoryNumLeafs = _engine->_gameState->inventoryNumLeafsBox;
-	}
-
 	// Clover leaf boxes
 	for (int32 i = 0; i < _engine->_gameState->inventoryNumLeafsBox; i++) {
 		const int32 leftSpritePos = _engine->_screens->crossDot(newBoxLeft, boxRight, 10, i);
diff --git a/engines/twine/renderer/renderer.cpp b/engines/twine/renderer/renderer.cpp
index d3e12c0647..240c5aa488 100644
--- a/engines/twine/renderer/renderer.cpp
+++ b/engines/twine/renderer/renderer.cpp
@@ -363,9 +363,7 @@ void Renderer::setLightVector(int32 angleX, int32 angleY, int32 angleZ) {
 	applyRotation(&shadeMatrix, &baseMatrix);
 	translateGroup(0, 0, 59);
 
-	lightPos.x = destPos.x;
-	lightPos.y = destPos.y;
-	lightPos.z = destPos.z;
+	lightPos = destPos;
 }
 
 FORCEINLINE int16 clamp(int16 x, int16 a, int16 b) {
diff --git a/engines/twine/scene/actor.cpp b/engines/twine/scene/actor.cpp
index c89542053b..a2c542dca6 100644
--- a/engines/twine/scene/actor.cpp
+++ b/engines/twine/scene/actor.cpp
@@ -381,7 +381,7 @@ void Actor::resetActor(int16 actorIdx) {
 	memset(&actor->dynamicFlags, 0, sizeof(DynamicFlagsStruct));
 	memset(&actor->bonusParameter, 0, sizeof(BonusParameter));
 
-	actor->life = 50;
+	actor->life = kActorMaxLife;
 	actor->armor = 1;
 	actor->hitBy = -1;
 	actor->lastRotationAngle = ANGLE_0;
diff --git a/engines/twine/scene/actor.h b/engines/twine/scene/actor.h
index 7c3a6c37f2..c9775833d5 100644
--- a/engines/twine/scene/actor.h
+++ b/engines/twine/scene/actor.h
@@ -157,6 +157,8 @@ struct BonusParameter {
 // but don't take the current state in account
 #define kAnimationType_4 4
 
+#define kActorMaxLife 50
+
 /**
  * Actors structure
  *
@@ -214,6 +216,10 @@ public:
 	int32 armor = 0; // field_14
 	int32 life = 0;
 
+	void addLife(int32 val);
+
+	void setLife(int32 val);
+
 	Vec3 collisionPos;
 
 	int32 positionInMoveScript = 0;
@@ -246,6 +252,17 @@ public:
 	AnimTimerDataStruct animTimerData;
 };
 
+inline void ActorStruct::addLife(int32 val) {
+	setLife(life + val);
+}
+
+inline void ActorStruct::setLife(int32 val) {
+	life = val;
+	if (life > kActorMaxLife) {
+		life = kActorMaxLife;
+	}
+}
+
 class TwinEEngine;
 
 class Actor {
diff --git a/engines/twine/scene/extra.cpp b/engines/twine/scene/extra.cpp
index 38105b9b49..fdfbbc93cd 100644
--- a/engines/twine/scene/extra.cpp
+++ b/engines/twine/scene/extra.cpp
@@ -696,7 +696,7 @@ void Extra::processExtras() {
 
 				_engine->_redraw->addOverlay(OverlayType::koSprite, SPRITEHQR_KEY, 10, 30, 0, OverlayPosType::koNormal, 2);
 
-				_engine->_gameState->inventoryNumKeys += extraKey->info1;
+				_engine->_gameState->addKeys(extraKey->info1);
 				extraKey->info0 = -1;
 
 				extra->info0 = -1;
@@ -729,7 +729,7 @@ void Extra::processExtras() {
 
 				_engine->_redraw->addOverlay(OverlayType::koSprite, SPRITEHQR_KEY, 10, 30, 0, OverlayPosType::koNormal, 2);
 
-				_engine->_gameState->inventoryNumKeys += extraKey->info1;
+				_engine->_gameState->addKeys(extraKey->info1);
 				extraKey->info0 = -1;
 
 				extra->info0 = -1;
@@ -774,12 +774,12 @@ void Extra::processExtras() {
 		}
 		// process extra collision with scene ground
 		if (extra->type & ExtraType::UNK3) {
-			int32 process = 0;
+			bool process = false;
 
 			if (_engine->_collision->checkExtraCollisionWithBricks(currentExtraX, currentExtraY, currentExtraZ, extra->pos.x, extra->pos.y, extra->pos.z)) {
 				// if not touch the ground
 				if (!(extra->type & ExtraType::WAIT_NO_COL)) {
-					process = 1;
+					process = true;
 				}
 			} else {
 				// if touch the ground
@@ -841,12 +841,12 @@ void Extra::processExtras() {
 		}
 		// extra stop moving while collision with bricks
 		if (extra->type & ExtraType::STOP_COL) {
-			int32 process = 0;
+			bool process = false;
 
 			if (_engine->_collision->checkExtraCollisionWithBricks(currentExtraX, currentExtraY, currentExtraZ, extra->pos.x, extra->pos.y, extra->pos.z)) {
 				// if not touch the ground
 				if (!(extra->type & ExtraType::WAIT_NO_COL)) {
-					process = 1;
+					process = true;
 				}
 			} else {
 				// if touch the ground
@@ -877,30 +877,15 @@ void Extra::processExtras() {
 				_engine->_redraw->addOverlay(OverlayType::koSprite, extra->info0, 10, 30, 0, OverlayPosType::koNormal, 2);
 
 				if (extra->info0 == SPRITEHQR_KASHES) {
-					_engine->_gameState->inventoryNumKashes += extra->info1;
-					if (_engine->_gameState->inventoryNumKashes > 999) {
-						_engine->_gameState->inventoryNumKashes = 999;
-					}
-					if (_engine->_gameState->inventoryNumKashes >= 500) {
-						_engine->unlockAchievement("LBA_ACH_011");
-					}
+					_engine->_gameState->addKashes(extra->info1);
 				} else if (extra->info0 == SPRITEHQR_LIFEPOINTS) {
-					_engine->_scene->sceneHero->life += extra->info1;
-					if (_engine->_scene->sceneHero->life > 50) {
-						_engine->_scene->sceneHero->life = 50;
-					}
+					_engine->_scene->sceneHero->addLife(extra->info1);
 				} else if (extra->info0 == SPRITEHQR_MAGICPOINTS && _engine->_gameState->magicLevelIdx) {
-					_engine->_gameState->inventoryMagicPoints += extra->info1 * 2;
-					if (_engine->_gameState->inventoryMagicPoints > _engine->_gameState->magicLevelIdx * 20) {
-						_engine->_gameState->inventoryMagicPoints = _engine->_gameState->magicLevelIdx * 20;
-					}
+					_engine->_gameState->addMagicPoints(extra->info1 * 2);
 				} else if (extra->info0 == SPRITEHQR_KEY) {
-					_engine->_gameState->inventoryNumKeys += extra->info1;
+					_engine->_gameState->addKeys(extra->info1);
 				} else if (extra->info0 == SPRITEHQR_CLOVERLEAF) {
-					_engine->_gameState->inventoryNumLeafs += extra->info1;
-					if (_engine->_gameState->inventoryNumLeafs > _engine->_gameState->inventoryNumLeafsBox) {
-						_engine->_gameState->inventoryNumLeafs = _engine->_gameState->inventoryNumLeafsBox;
-					}
+					_engine->_gameState->addLeafs(extra->info1);
 				}
 
 				extra->info0 = -1;
diff --git a/engines/twine/scene/gamestate.cpp b/engines/twine/scene/gamestate.cpp
index 1e8a4e5b1b..21e6ec947a 100644
--- a/engines/twine/scene/gamestate.cpp
+++ b/engines/twine/scene/gamestate.cpp
@@ -100,7 +100,7 @@ void GameState::initHeroVars() {
 	usingSabre = false;
 
 	_engine->_scene->sceneHero->body = BodyType::btNormal;
-	_engine->_scene->sceneHero->life = 50;
+	_engine->_scene->sceneHero->life = kActorMaxLife;
 	_engine->_scene->sceneHero->talkColor = COLOR_BRIGHT_BLUE;
 }
 
@@ -187,11 +187,11 @@ bool GameState::loadGame(Common::SeekableReadStream *file) {
 
 	_engine->_actor->heroBehaviour = (HeroBehaviourType)file->readByte();
 	_engine->_actor->previousHeroBehaviour = _engine->_actor->heroBehaviour;
-	_engine->_scene->sceneHero->life = file->readByte();
-	inventoryNumKashes = file->readSint16LE();
+	_engine->_scene->sceneHero->setLife(file->readByte());
+	setKashes(file->readSint16LE());
 	magicLevelIdx = file->readByte();
-	inventoryMagicPoints = file->readByte();
-	inventoryNumLeafsBox = file->readByte();
+	setMagicPoints(file->readByte());
+	setLeafBoxes(file->readByte());
 	_engine->_scene->newHeroPos.x = file->readSint16LE();
 	_engine->_scene->newHeroPos.y = file->readSint16LE();
 	_engine->_scene->newHeroPos.z = file->readSint16LE();
@@ -206,7 +206,7 @@ bool GameState::loadGame(Common::SeekableReadStream *file) {
 	}
 	file->read(holomapFlags, NUM_LOCATIONS);
 
-	inventoryNumGas = file->readByte();
+	setGas(file->readByte());
 
 	const byte numInventoryFlags = file->readByte(); // number of used inventory items, always 28
 	if (numInventoryFlags != NUM_INVENTORY_ITEMS) {
@@ -215,7 +215,7 @@ bool GameState::loadGame(Common::SeekableReadStream *file) {
 	}
 	file->read(inventoryFlags, NUM_INVENTORY_ITEMS);
 
-	inventoryNumLeafs = file->readByte();
+	setLeafs(file->readByte());
 	usingSabre = file->readByte();
 
 	if (saveFileVersion == 4) {
@@ -554,18 +554,72 @@ void GameState::giveUp() {
 }
 
 int16 GameState::setGas(int16 value) {
-	inventoryNumGas = MIN<int16>(100, value);
+	inventoryNumGas = CLIP<int16>(value, 0, 100);
 	return inventoryNumGas;
 }
 
+void GameState::addGas(int16 value) {
+	setGas(inventoryNumGas + value);
+}
+
 int16 GameState::setKashes(int16 value) {
-	inventoryNumKashes = MIN<int16>(999, value);
+	inventoryNumKashes = CLIP<int16>(value, 0, 999);
+	if (_engine->_gameState->inventoryNumKashes >= 500) {
+		_engine->unlockAchievement("LBA_ACH_011");
+	}
 	return inventoryNumKashes;
 }
 
 int16 GameState::setKeys(int16 value) {
-	inventoryNumKeys = value;
+	inventoryNumKeys = MAX<int16>(0, value);
 	return inventoryNumKeys;
 }
 
+void GameState::addKeys(int16 val) {
+	setKeys(inventoryNumKeys + val);
+}
+
+void GameState::addKashes(int16 val) {
+	setKashes(inventoryNumKashes + val);
+}
+
+int16 GameState::setMagicPoints(int16 val) {
+	inventoryMagicPoints = val;
+	if (inventoryMagicPoints > magicLevelIdx * 20) {
+		inventoryMagicPoints = magicLevelIdx * 20;
+	}
+	return inventoryMagicPoints;
+}
+
+void GameState::addMagicPoints(int16 val) {
+	setMagicPoints(inventoryMagicPoints + val);
+}
+
+int16 GameState::setLeafs(int16 val) {
+	inventoryNumLeafs = val;
+	if (inventoryNumLeafs > inventoryNumLeafsBox) {
+		inventoryNumLeafs = inventoryNumLeafsBox;
+	}
+	return inventoryNumLeafs;
+}
+
+void GameState::addLeafs(int16 val) {
+	setLeafs(inventoryNumLeafs + val);
+}
+
+int16 GameState::setLeafBoxes(int16 val) {
+	inventoryNumLeafsBox = val;
+	if (inventoryNumLeafsBox > 10) {
+		inventoryNumLeafsBox = 10;
+	}
+	if (inventoryNumLeafsBox == 5) {
+		_engine->unlockAchievement("LBA_ACH_003");
+	}
+	return inventoryNumLeafsBox;
+}
+
+void GameState::addLeafBoxes(int16 val) {
+	setLeafBoxes(inventoryNumLeafsBox + val);
+}
+
 } // namespace TwinE
diff --git a/engines/twine/scene/gamestate.h b/engines/twine/scene/gamestate.h
index ae5e6b48cb..b80fa91888 100644
--- a/engines/twine/scene/gamestate.h
+++ b/engines/twine/scene/gamestate.h
@@ -190,7 +190,17 @@ public:
 
 	int16 setKeys(int16 value);
 	int16 setGas(int16 value);
+	int16 setLeafs(int16 value);
 	int16 setKashes(int16 value);
+	int16 setMagicPoints(int16 val);
+	int16 setLeafBoxes(int16 val);
+
+	void addGas(int16 value);
+	void addKeys(int16 val);
+	void addKashes(int16 val);
+	void addMagicPoints(int16 val);
+	void addLeafs(int16 val);
+	void addLeafBoxes(int16 val);
 
 	/** Its using FunFrock Sabre */
 	bool usingSabre = false;
diff --git a/engines/twine/script/script_life_v1.cpp b/engines/twine/script/script_life_v1.cpp
index ff02d9321c..44d49ab3bc 100644
--- a/engines/twine/script/script_life_v1.cpp
+++ b/engines/twine/script/script_life_v1.cpp
@@ -828,12 +828,7 @@ static int32 lSUICIDE(TwinEEngine *engine, LifeScriptContext &ctx) {
  * @note Opcode @c 0x27
  */
 static int32 lUSE_ONE_LITTLE_KEY(TwinEEngine *engine, LifeScriptContext &ctx) {
-	engine->_gameState->inventoryNumKeys--;
-
-	if (engine->_gameState->inventoryNumKeys < 0) {
-		engine->_gameState->inventoryNumKeys = 0;
-	}
-
+	engine->_gameState->addKeys(-1);
 	engine->_redraw->addOverlay(OverlayType::koSprite, SPRITEHQR_KEY, 0, 0, 0, OverlayPosType::koFollowActor, 1);
 
 	return 0;
@@ -848,10 +843,7 @@ static int32 lGIVE_GOLD_PIECES(TwinEEngine *engine, LifeScriptContext &ctx) {
 	bool hideRange = false;
 	int16 kashes = ctx.stream.readSint16LE();
 
-	engine->_gameState->inventoryNumKashes -= kashes;
-	if (engine->_gameState->inventoryNumKashes < 0) {
-		engine->_gameState->inventoryNumKashes = 0;
-	}
+	engine->_gameState->addKashes(-kashes);
 
 	engine->_redraw->addOverlay(OverlayType::koSprite, SPRITEHQR_KASHES, 10, 15, 0, OverlayPosType::koNormal, 3);
 
@@ -1237,12 +1229,7 @@ static int32 lPLAY_MIDI(TwinEEngine *engine, LifeScriptContext &ctx) {
  * @note Opcode @c 0x42
  */
 static int32 lINC_CLOVER_BOX(TwinEEngine *engine, LifeScriptContext &ctx) {
-	if (engine->_gameState->inventoryNumLeafsBox < 10) {
-		engine->_gameState->inventoryNumLeafsBox++;
-		if (engine->_gameState->inventoryNumLeafsBox == 5) {
-			engine->unlockAchievement("LBA_ACH_003");
-		}
-	}
+	engine->_gameState->addLeafBoxes(1);
 	return 0;
 }
 
@@ -1349,10 +1336,7 @@ static int32 lCLR_HOLO_POS(TwinEEngine *engine, LifeScriptContext &ctx) {
  * @note Opcode @c 0x4A
  */
 static int32 lADD_FUEL(TwinEEngine *engine, LifeScriptContext &ctx) {
-	engine->_gameState->inventoryNumGas += ctx.stream.readByte();
-	if (engine->_gameState->inventoryNumGas > 100) {
-		engine->_gameState->inventoryNumGas = 100;
-	}
+	engine->_gameState->addGas(ctx.stream.readByte());
 	return 0;
 }
 
@@ -1361,10 +1345,7 @@ static int32 lADD_FUEL(TwinEEngine *engine, LifeScriptContext &ctx) {
  * @note Opcode @c 0x4B
  */
 static int32 lSUB_FUEL(TwinEEngine *engine, LifeScriptContext &ctx) {
-	engine->_gameState->inventoryNumGas -= ctx.stream.readByte();
-	if (engine->_gameState->inventoryNumGas < 0) {
-		engine->_gameState->inventoryNumGas = 0;
-	}
+	engine->_gameState->addGas(-(int16)ctx.stream.readByte());
 	return 0;
 }
 
@@ -1414,7 +1395,7 @@ static int32 lSAY_MESSAGE_OBJ(TwinEEngine *engine, LifeScriptContext &ctx) {
  * @note Opcode @c 0x4F
  */
 static int32 lFULL_POINT(TwinEEngine *engine, LifeScriptContext &ctx) {
-	engine->_scene->sceneHero->life = 50;
+	engine->_scene->sceneHero->life = kActorMaxLife;
 	engine->_gameState->inventoryMagicPoints = engine->_gameState->magicLevelIdx * 20;
 	return 0;
 }
@@ -1662,7 +1643,7 @@ static int32 lGAME_OVER(TwinEEngine *engine, LifeScriptContext &ctx) {
 static int32 lTHE_END(TwinEEngine *engine, LifeScriptContext &ctx) {
 	engine->quitGame = 1;
 	engine->_gameState->inventoryNumLeafs = 0;
-	engine->_scene->sceneHero->life = 50;
+	engine->_scene->sceneHero->life = kActorMaxLife;
 	engine->_gameState->inventoryMagicPoints = 80;
 	engine->_scene->currentSceneIdx = LBA1SceneId::Polar_Island_Final_Battle;
 	engine->_actor->heroBehaviour = engine->_actor->previousHeroBehaviour;
diff --git a/engines/twine/twine.cpp b/engines/twine/twine.cpp
index 9bd006bcb7..d079151fa1 100644
--- a/engines/twine/twine.cpp
+++ b/engines/twine/twine.cpp
@@ -644,7 +644,7 @@ void TwinEEngine::processInventoryAction() {
 		_movements->rotateActor(0, 800, pinguin->angle);
 
 		if (!_collision->checkCollisionWithActors(_scene->mecaPinguinIdx)) {
-			pinguin->life = 50;
+			pinguin->life = kActorMaxLife;
 			pinguin->body = BodyType::btNone;
 			_actor->initModelActor(BodyType::btNormal, _scene->mecaPinguinIdx);
 			pinguin->dynamicFlags.bIsDead = 0; // &= 0xDF
@@ -663,9 +663,9 @@ void TwinEEngine::processInventoryAction() {
 		break;
 	}
 	case kiCloverLeaf:
-		if (_scene->sceneHero->life < 50) {
+		if (_scene->sceneHero->life < kActorMaxLife) {
 			if (_gameState->inventoryNumLeafs > 0) {
-				_scene->sceneHero->life = 50;
+				_scene->sceneHero->life = kActorMaxLife;
 				_gameState->inventoryMagicPoints = _gameState->magicLevelIdx * 20;
 				_gameState->inventoryNumLeafs--;
 				_redraw->addOverlay(OverlayType::koInventoryItem, InventoryItems::kiCloverLeaf, 0, 0, 0, OverlayPosType::koNormal, 3);
@@ -939,7 +939,7 @@ int32 TwinEEngine::runGameEngine() { // mainLoopInteration
 
 						_scene->heroPositionType = ScenePositionType::kReborn;
 
-						_scene->sceneHero->life = 50;
+						_scene->sceneHero->life = kActorMaxLife;
 						_redraw->reqBgRedraw = true;
 						_screens->lockPalette = true;
 						_gameState->inventoryNumLeafs--;
@@ -950,7 +950,7 @@ int32 TwinEEngine::runGameEngine() { // mainLoopInteration
 						_gameState->inventoryMagicPoints = _gameState->magicLevelIdx * 20;
 						_actor->heroBehaviour = _actor->previousHeroBehaviour;
 						actor->angle = _actor->previousHeroAngle;
-						actor->life = 50;
+						actor->life = kActorMaxLife;
 
 						if (_scene->previousSceneIdx != _scene->currentSceneIdx) {
 							_scene->newHeroPos.x = -1;


Commit: bbe4083ab0c6ecb96c908dd8f7f5904f2c7c5b3e
    https://github.com/scummvm/scummvm/commit/bbe4083ab0c6ecb96c908dd8f7f5904f2c7c5b3e
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2021-02-26T11:11:21+01:00

Commit Message:
TWINE: use a few of the inventory setters to ensure the item amount boundaries

Changed paths:
    engines/twine/scene/actor.cpp
    engines/twine/scene/animations.cpp
    engines/twine/scene/collision.cpp
    engines/twine/scene/gamestate.cpp
    engines/twine/scene/scene.cpp
    engines/twine/script/script_life_v1.cpp
    engines/twine/twine.cpp


diff --git a/engines/twine/scene/actor.cpp b/engines/twine/scene/actor.cpp
index a2c542dca6..b03d47f2f1 100644
--- a/engines/twine/scene/actor.cpp
+++ b/engines/twine/scene/actor.cpp
@@ -381,7 +381,7 @@ void Actor::resetActor(int16 actorIdx) {
 	memset(&actor->dynamicFlags, 0, sizeof(DynamicFlagsStruct));
 	memset(&actor->bonusParameter, 0, sizeof(BonusParameter));
 
-	actor->life = kActorMaxLife;
+	actor->setLife(kActorMaxLife);
 	actor->armor = 1;
 	actor->hitBy = -1;
 	actor->lastRotationAngle = ANGLE_0;
@@ -434,7 +434,6 @@ void Actor::hitActor(int32 actorIdx, int32 actorIdxAttacked, int32 strengthOfHit
 		}
 
 		actor->life -= strengthOfHit;
-
 		if (actor->life < 0) {
 			actor->life = 0;
 		}
diff --git a/engines/twine/scene/animations.cpp b/engines/twine/scene/animations.cpp
index 34939b63d8..641dbc99df 100644
--- a/engines/twine/scene/animations.cpp
+++ b/engines/twine/scene/animations.cpp
@@ -831,7 +831,7 @@ void Animations::processActorAnimations(int32 actorIdx) { // DoAnim
 
 		// if under the map, than die
 		if (_engine->_collision->collision.y == -1) {
-			actor->life = 0;
+			actor->setLife(0);
 		}
 	} else {
 		if (actor->staticFlags.bComputeCollisionWithObj) {
diff --git a/engines/twine/scene/collision.cpp b/engines/twine/scene/collision.cpp
index d4faf47bb1..b69165f8e7 100644
--- a/engines/twine/scene/collision.cpp
+++ b/engines/twine/scene/collision.cpp
@@ -446,7 +446,7 @@ void Collision::stopFalling() { // ReceptionObj()
 
 		if (fall >= BRICK_HEIGHT * 8) {
 			_engine->_extra->addExtraSpecial(_engine->_actor->processActorPtr->pos.x, _engine->_actor->processActorPtr->pos.y + 1000, _engine->_actor->processActorPtr->pos.z, ExtraSpecialType::kHitStars);
-			_engine->_actor->processActorPtr->life--;
+			_engine->_actor->processActorPtr->addLife(-1);
 			_engine->_animations->initAnim(AnimationTypes::kLandingHit, kAnimationType_2, AnimationTypes::kStanding, _engine->_animations->currentlyProcessedActorIdx);
 		} else if (fall > 10) {
 			_engine->_animations->initAnim(AnimationTypes::kLanding, kAnimationType_2, AnimationTypes::kStanding, _engine->_animations->currentlyProcessedActorIdx);
diff --git a/engines/twine/scene/gamestate.cpp b/engines/twine/scene/gamestate.cpp
index 21e6ec947a..e79b52032e 100644
--- a/engines/twine/scene/gamestate.cpp
+++ b/engines/twine/scene/gamestate.cpp
@@ -100,7 +100,7 @@ void GameState::initHeroVars() {
 	usingSabre = false;
 
 	_engine->_scene->sceneHero->body = BodyType::btNormal;
-	_engine->_scene->sceneHero->life = kActorMaxLife;
+	_engine->_scene->sceneHero->setLife(kActorMaxLife);
 	_engine->_scene->sceneHero->talkColor = COLOR_BRIGHT_BLUE;
 }
 
diff --git a/engines/twine/scene/scene.cpp b/engines/twine/scene/scene.cpp
index 9e1e637fdd..5465d3d989 100644
--- a/engines/twine/scene/scene.cpp
+++ b/engines/twine/scene/scene.cpp
@@ -220,7 +220,7 @@ bool Scene::loadSceneLBA2() {
 			/*act->cropBottom = act->spriteSizeHit;*/
 		}
 		act->armor = stream.readByte();
-		act->life = stream.readByte();
+		act->setLife(stream.readByte());
 
 		act->moveScriptSize = stream.readUint16LE();
 		act->moveScript = currentScene + stream.pos();
@@ -348,7 +348,7 @@ bool Scene::loadSceneLBA1() {
 		act->bonusAmount = stream.readByte();
 		act->talkColor = stream.readByte();
 		act->armor = stream.readByte();
-		act->life = stream.readByte();
+		act->setLife(stream.readByte());
 
 		act->moveScriptSize = stream.readUint16LE();
 		act->moveScript = currentScene + stream.pos();
diff --git a/engines/twine/script/script_life_v1.cpp b/engines/twine/script/script_life_v1.cpp
index 44d49ab3bc..f1d3464f86 100644
--- a/engines/twine/script/script_life_v1.cpp
+++ b/engines/twine/script/script_life_v1.cpp
@@ -804,7 +804,7 @@ static int32 lKILL_OBJ(TwinEEngine *engine, LifeScriptContext &ctx) {
 	otherActor->dynamicFlags.bIsDead = 1;
 	otherActor->entity = -1;
 	otherActor->zone = -1;
-	otherActor->life = 0;
+	otherActor->setLife(0);
 
 	return 0;
 }
@@ -818,7 +818,7 @@ static int32 lSUICIDE(TwinEEngine *engine, LifeScriptContext &ctx) {
 	ctx.actor->dynamicFlags.bIsDead = 1;
 	ctx.actor->entity = -1;
 	ctx.actor->zone = -1;
-	ctx.actor->life = 0;
+	ctx.actor->setLife(0);
 
 	return 0;
 }
@@ -1154,7 +1154,7 @@ static int32 lSET_LIFE_POINT_OBJ(TwinEEngine *engine, LifeScriptContext &ctx) {
 	int32 otherActorIdx = ctx.stream.readByte();
 	static int32 lifeValue = ctx.stream.readByte();
 
-	engine->_scene->getActor(otherActorIdx)->life = lifeValue;
+	engine->_scene->getActor(otherActorIdx)->setLife(lifeValue);
 
 	return 0;
 }
@@ -1168,10 +1168,9 @@ static int32 lSUB_LIFE_POINT_OBJ(TwinEEngine *engine, LifeScriptContext &ctx) {
 	static int32 lifeValue = ctx.stream.readByte();
 
 	ActorStruct *otherActor = engine->_scene->getActor(otherActorIdx);
-	otherActor->life -= lifeValue;
-
+	otherActor->addLife(-lifeValue);
 	if (otherActor->life < 0) {
-		otherActor->life = 0;
+		otherActor->setLife(0);
 	}
 
 	return 0;
@@ -1395,7 +1394,7 @@ static int32 lSAY_MESSAGE_OBJ(TwinEEngine *engine, LifeScriptContext &ctx) {
  * @note Opcode @c 0x4F
  */
 static int32 lFULL_POINT(TwinEEngine *engine, LifeScriptContext &ctx) {
-	engine->_scene->sceneHero->life = kActorMaxLife;
+	engine->_scene->sceneHero->setLife(kActorMaxLife);
 	engine->_gameState->inventoryMagicPoints = engine->_gameState->magicLevelIdx * 20;
 	return 0;
 }
@@ -1631,8 +1630,8 @@ static int32 lHOLOMAP_TRAJ(TwinEEngine *engine, LifeScriptContext &ctx) {
  */
 static int32 lGAME_OVER(TwinEEngine *engine, LifeScriptContext &ctx) {
 	engine->_scene->sceneHero->dynamicFlags.bAnimEnded = 1;
-	engine->_scene->sceneHero->life = 0;
-	engine->_gameState->inventoryNumLeafs = 0;
+	engine->_scene->sceneHero->setLife(0);
+	engine->_gameState->setLeafs(0);
 	return 1; // break
 }
 
@@ -1642,9 +1641,9 @@ static int32 lGAME_OVER(TwinEEngine *engine, LifeScriptContext &ctx) {
  */
 static int32 lTHE_END(TwinEEngine *engine, LifeScriptContext &ctx) {
 	engine->quitGame = 1;
-	engine->_gameState->inventoryNumLeafs = 0;
-	engine->_scene->sceneHero->life = kActorMaxLife;
-	engine->_gameState->inventoryMagicPoints = 80;
+	engine->_gameState->setLeafs(0);
+	engine->_scene->sceneHero->setLife(kActorMaxLife);
+	engine->_gameState->setMagicPoints(80);
 	engine->_scene->currentSceneIdx = LBA1SceneId::Polar_Island_Final_Battle;
 	engine->_actor->heroBehaviour = engine->_actor->previousHeroBehaviour;
 	engine->_scene->newHeroPos.x = -1;
diff --git a/engines/twine/twine.cpp b/engines/twine/twine.cpp
index d079151fa1..761a90d432 100644
--- a/engines/twine/twine.cpp
+++ b/engines/twine/twine.cpp
@@ -644,7 +644,7 @@ void TwinEEngine::processInventoryAction() {
 		_movements->rotateActor(0, 800, pinguin->angle);
 
 		if (!_collision->checkCollisionWithActors(_scene->mecaPinguinIdx)) {
-			pinguin->life = kActorMaxLife;
+			pinguin->setLife(kActorMaxLife);
 			pinguin->body = BodyType::btNone;
 			_actor->initModelActor(BodyType::btNormal, _scene->mecaPinguinIdx);
 			pinguin->dynamicFlags.bIsDead = 0; // &= 0xDF
@@ -665,9 +665,9 @@ void TwinEEngine::processInventoryAction() {
 	case kiCloverLeaf:
 		if (_scene->sceneHero->life < kActorMaxLife) {
 			if (_gameState->inventoryNumLeafs > 0) {
-				_scene->sceneHero->life = kActorMaxLife;
-				_gameState->inventoryMagicPoints = _gameState->magicLevelIdx * 20;
-				_gameState->inventoryNumLeafs--;
+				_scene->sceneHero->setLife(kActorMaxLife);
+				_gameState->setMagicPoints(_gameState->magicLevelIdx * 20);
+				_gameState->addLeafs(-1);
 				_redraw->addOverlay(OverlayType::koInventoryItem, InventoryItems::kiCloverLeaf, 0, 0, 0, OverlayPosType::koNormal, 3);
 			}
 		}
@@ -909,7 +909,7 @@ int32 TwinEEngine::runGameEngine() { // mainLoopInteration
 							}
 							_renderer->projectPositionOnScreen(actor->pos - _grid->camera);
 							actor->controlMode = ControlMode::kNoMove;
-							actor->life = -1;
+							actor->setLife(-1);
 							_actor->cropBottomScreen = _renderer->projPos.y;
 							actor->staticFlags.bCanDrown |= 0x10; // TODO: doesn't make sense
 						}
@@ -919,7 +919,7 @@ int32 TwinEEngine::runGameEngine() { // mainLoopInteration
 							if (!actor->bonusParameter.unk1) {
 								_actor->processActorExtraBonus(a);
 							}
-							actor->life = 0;
+							actor->setLife(0);
 						}
 					}
 				}
@@ -939,18 +939,18 @@ int32 TwinEEngine::runGameEngine() { // mainLoopInteration
 
 						_scene->heroPositionType = ScenePositionType::kReborn;
 
-						_scene->sceneHero->life = kActorMaxLife;
+						_scene->sceneHero->setLife(kActorMaxLife);
 						_redraw->reqBgRedraw = true;
 						_screens->lockPalette = true;
-						_gameState->inventoryNumLeafs--;
+						_gameState->addLeafs(-1);
 						_actor->cropBottomScreen = 0;
 					} else { // game over
-						_gameState->inventoryNumLeafsBox = 2;
-						_gameState->inventoryNumLeafs = 1;
-						_gameState->inventoryMagicPoints = _gameState->magicLevelIdx * 20;
+						_gameState->setLeafBoxes(2);
+						_gameState->setLeafs(1);
+						_gameState->setMagicPoints(_gameState->magicLevelIdx * 20);
 						_actor->heroBehaviour = _actor->previousHeroBehaviour;
 						actor->angle = _actor->previousHeroAngle;
-						actor->life = kActorMaxLife;
+						actor->setLife(kActorMaxLife);
 
 						if (_scene->previousSceneIdx != _scene->currentSceneIdx) {
 							_scene->newHeroPos.x = -1;


Commit: b45b3bb6c08286e25a7ee1b59bd49ac6fceaa720
    https://github.com/scummvm/scummvm/commit/b45b3bb6c08286e25a7ee1b59bd49ac6fceaa720
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2021-02-26T11:13:49+01:00

Commit Message:
TWINE: don't clamp the given values to short

lba2 is using bigger maps

Changed paths:
    engines/twine/debugger/console.cpp


diff --git a/engines/twine/debugger/console.cpp b/engines/twine/debugger/console.cpp
index f2d3ca2c72..b14eefd386 100644
--- a/engines/twine/debugger/console.cpp
+++ b/engines/twine/debugger/console.cpp
@@ -288,16 +288,14 @@ bool TwinEConsole::doListMenuText(int argc, const char **argv) {
 }
 
 bool TwinEConsole::doSetHeroPosition(int argc, const char **argv) {
+	Vec3 &pos = _engine->_scene->sceneHero->pos;
 	if (argc < 4) {
-		debugPrintf("Current hero position: %i:%i:%i\n", _engine->_scene->sceneHero->pos.x, _engine->_scene->sceneHero->pos.y, _engine->_scene->sceneHero->pos.z);
+		debugPrintf("Current hero position: %i:%i:%i\n", pos.x, pos.y, pos.z);
 		return true;
 	}
-	const int16 x = atoi(argv[1]);
-	const int16 y = atoi(argv[2]);
-	const int16 z = atoi(argv[3]);
-	_engine->_scene->sceneHero->pos.x = x;
-	_engine->_scene->sceneHero->pos.y = y;
-	_engine->_scene->sceneHero->pos.z = z;
+	pos.x = atoi(argv[1]);
+	pos.y = atoi(argv[2]);
+	pos.z = atoi(argv[3]);
 	return true;
 }
 


Commit: 485a229007159c2069c8a340036fc10769151e2e
    https://github.com/scummvm/scummvm/commit/485a229007159c2069c8a340036fc10769151e2e
Author: Martin Gerhardy (martin.gerhardy at gmail.com)
Date: 2021-02-26T11:19:11+01:00

Commit Message:
AGS: fixed potential buffer overflows due to missing null byte

Changed paths:
    engines/ags/ags.cpp
    engines/ags/engine/main/quit.cpp


diff --git a/engines/ags/ags.cpp b/engines/ags/ags.cpp
index fd33148f19..f5405041ab 100644
--- a/engines/ags/ags.cpp
+++ b/engines/ags/ags.cpp
@@ -264,7 +264,8 @@ const char *set_allegro_error(const char *format, ...) {
 	va_list argptr;
 	va_start(argptr, format);
 	Common::String msg = Common::String::format(format, argptr);
-	strncpy(allegro_error, msg.c_str(), ALLEGRO_ERROR_SIZE);
+	strncpy(allegro_error, msg.c_str(), ALLEGRO_ERROR_SIZE - 1);
+	allegro_error[ALLEGRO_ERROR_SIZE - 1] = '\0';
 
 	va_end(argptr);
 	return allegro_error;
diff --git a/engines/ags/engine/main/quit.cpp b/engines/ags/engine/main/quit.cpp
index eb09c135d4..c262b7fecf 100644
--- a/engines/ags/engine/main/quit.cpp
+++ b/engines/ags/engine/main/quit.cpp
@@ -217,7 +217,8 @@ void allegro_bitmap_test_release() {
 // "!|" is a special code used to mean that the player has aborted (Alt+X)
 void quit(const char *quitmsg) {
 	if (!_G(abort_engine)) {
-		strncpy(_G(quit_message), quitmsg, 256);
+		strncpy(_G(quit_message), quitmsg, sizeof(_G(quit_message)) - 1);
+		_G(quit_message)[sizeof(_G(quit_message)) - 1] = '\0';
 		_G(abort_engine) = true;
 	}
 }




More information about the Scummvm-git-logs mailing list