thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'tony' into tony

Browse source
This commit is contained in:
Paul Gilbert 2012-06-07 20:52:57 +10:00
commit 8f93c7be16
21 changed files with 1682 additions and 1693 deletions
Download patch file Download diff file Expand all files Collapse all files

263
engines/tony/custom.cpp
View file

@ -109,7 +109,7 @@ const char *staccFileNames[] = {
void ReapplyChangedHotspot(void) {
int i;
for (i = 0; i < GLOBALS.curChangedHotspot; i++)
GLOBALS.Loc->GetItemFromCode(GLOBALS.ChangedHotspot[i].dwCode)->ChangeHotspot(RMPoint(GLOBALS.ChangedHotspot[i].nX, GLOBALS.ChangedHotspot[i].nY));
GLOBALS.Loc->getItemFromCode(GLOBALS.ChangedHotspot[i].dwCode)->changeHotspot(RMPoint(GLOBALS.ChangedHotspot[i].nX, GLOBALS.ChangedHotspot[i].nY));
}
void SaveChangedHotspot(Common::OutSaveFile *f) {
@ -141,9 +141,9 @@ void LoadChangedHotspot(Common::InSaveFile *f) {
*/
void MCharResetCodes(void) {
for (int i = 0; i < 10; i++)
GLOBALS.MCharacter[i].item = GLOBALS.Loc->GetItemFromCode(GLOBALS.MCharacter[i].code);
GLOBALS.MCharacter[i].item = GLOBALS.Loc->getItemFromCode(GLOBALS.MCharacter[i].code);
for (int i = 0; i < 10; i++)
GLOBALS.Character[i].item = GLOBALS.Loc->GetItemFromCode(GLOBALS.Character[i].code);
GLOBALS.Character[i].item = GLOBALS.Loc->getItemFromCode(GLOBALS.Character[i].code);
}
void CharsSaveAll(Common::OutSaveFile *f) {
@ -168,19 +168,19 @@ void CharsLoadAll(Common::InSaveFile *f) {
}
DECLARE_CUSTOM_FUNCTION(FaceToMe)(CORO_PARAM, uint32, uint32, uint32, uint32) {
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_STANDDOWN);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_STANDDOWN);
}
DECLARE_CUSTOM_FUNCTION(BackToMe)(CORO_PARAM, uint32, uint32, uint32, uint32) {
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_STANDUP);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_STANDUP);
}
DECLARE_CUSTOM_FUNCTION(LeftToMe)(CORO_PARAM, uint32, uint32, uint32, uint32) {
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_STANDLEFT);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_STANDLEFT);
}
DECLARE_CUSTOM_FUNCTION(RightToMe)(CORO_PARAM, uint32, uint32, uint32, uint32) {
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_STANDRIGHT);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_STANDRIGHT);
}
@ -263,8 +263,8 @@ DECLARE_CUSTOM_FUNCTION(SendTonyMessage)(CORO_PARAM, uint32 dwMessage, uint32 nX
if (GLOBALS.bSkipIdle) return;
_ctx->msg.Load(dwMessage);
if (!_ctx->msg.IsValid()) {
_ctx->msg.load(dwMessage);
if (!_ctx->msg.isValid()) {
return;
}
@ -285,15 +285,15 @@ DECLARE_CUSTOM_FUNCTION(SendTonyMessage)(CORO_PARAM, uint32 dwMessage, uint32 nX
}
if (GLOBALS.nTonyNextTalkType != GLOBALS.Tony->TALK_NORMAL) {
CORO_INVOKE_1(GLOBALS.Tony->StartTalk, GLOBALS.nTonyNextTalkType);
CORO_INVOKE_1(GLOBALS.Tony->startTalk, GLOBALS.nTonyNextTalkType);
if (!GLOBALS.bStaticTalk)
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_NORMAL;
} else {
if (_ctx->msg.NumPeriods() > 1)
CORO_INVOKE_1(GLOBALS.Tony->StartTalk, GLOBALS.Tony->TALK_FIANCHI);
if (_ctx->msg.numPeriods() > 1)
CORO_INVOKE_1(GLOBALS.Tony->startTalk, GLOBALS.Tony->TALK_FIANCHI);
else
CORO_INVOKE_1(GLOBALS.Tony->StartTalk, GLOBALS.Tony->TALK_NORMAL);
CORO_INVOKE_1(GLOBALS.Tony->startTalk, GLOBALS.Tony->TALK_NORMAL);
}
if (GLOBALS.curBackText)
@ -301,7 +301,7 @@ DECLARE_CUSTOM_FUNCTION(SendTonyMessage)(CORO_PARAM, uint32 dwMessage, uint32 nX
GLOBALS.bTonyIsSpeaking = true;
for (_ctx->i = 0; _ctx->i < _ctx->msg.NumPeriods() && !GLOBALS.bSkipIdle; _ctx->i++) {
for (_ctx->i = 0; _ctx->i < _ctx->msg.numPeriods() && !GLOBALS.bSkipIdle; _ctx->i++) {
_ctx->text.setInput(GLOBALS.Input);
// Alignment
@ -315,9 +315,9 @@ DECLARE_CUSTOM_FUNCTION(SendTonyMessage)(CORO_PARAM, uint32 dwMessage, uint32 nX
// Set the position
if (nX == 0 && nY == 0)
_ctx->text.setPosition(GLOBALS.Tony->Position() - RMPoint(0, 130) - GLOBALS.Loc->ScrollPosition());
_ctx->text.setPosition(GLOBALS.Tony->position() - RMPoint(0, 130) - GLOBALS.Loc->scrollPosition());
else
_ctx->text.setPosition(RMPoint(nX, nY) - GLOBALS.Loc->ScrollPosition());
_ctx->text.setPosition(RMPoint(nX, nY) - GLOBALS.Loc->scrollPosition());
// Handling for always display
if (GLOBALS.bAlwaysDisplay) {
@ -359,13 +359,13 @@ DECLARE_CUSTOM_FUNCTION(SendTonyMessage)(CORO_PARAM, uint32 dwMessage, uint32 nX
if (GLOBALS.curBackText)
GLOBALS.curBackText->show();
CORO_INVOKE_0(GLOBALS.Tony->EndTalk);
CORO_INVOKE_0(GLOBALS.Tony->endTalk);
CORO_END_CODE;
}
DECLARE_CUSTOM_FUNCTION(ChangeBoxStatus)(CORO_PARAM, uint32 nLoc, uint32 nBox, uint32 nStatus, uint32) {
GLOBALS.Boxes->ChangeBoxStatus(nLoc, nBox, nStatus);
GLOBALS.Boxes->changeBoxStatus(nLoc, nBox, nStatus);
}
@ -408,16 +408,16 @@ DECLARE_CUSTOM_FUNCTION(SendFullscreenMsgStart)(CORO_PARAM, uint32 nMsg, uint32
_ctx->msg = new RMMessage(nMsg);
GLOBALS.SFM_nLoc = GLOBALS.Loc->TEMPGetNumLoc();
GLOBALS.SFM_pt = GLOBALS.Tony->Position();
GLOBALS.SFM_pt = GLOBALS.Tony->position();
if (GLOBALS.bSkipIdle)
return;
CORO_INVOKE_2(GLOBALS.UnloadLocation, false, NULL);
GLOBALS.Tony->Hide();
GLOBALS.Tony->hide();
GLOBALS.Unfreeze();
for (_ctx->i = 0; _ctx->i < _ctx->msg->NumPeriods() && !GLOBALS.bSkipIdle; _ctx->i++) {
for (_ctx->i = 0; _ctx->i < _ctx->msg->numPeriods() && !GLOBALS.bSkipIdle; _ctx->i++) {
_ctx->text.setInput(GLOBALS.Input);
// Alignment
@ -474,7 +474,7 @@ DECLARE_CUSTOM_FUNCTION(SendFullscreenMsgEnd)(CORO_PARAM, uint32 bNotEnableTony,
GLOBALS.Freeze();
GLOBALS.LoadLocation(GLOBALS.SFM_nLoc, RMPoint(GLOBALS.SFM_pt.x, GLOBALS.SFM_pt.y), RMPoint(-1, -1));
if (!bNotEnableTony)
GLOBALS.Tony->Show();
GLOBALS.Tony->show();
GLOBALS.Unfreeze();
MCharResetCodes();
@ -574,11 +574,11 @@ DECLARE_CUSTOM_FUNCTION(ChangeLocation)(CORO_PARAM, uint32 nLoc, uint32 tX, uint
}
DECLARE_CUSTOM_FUNCTION(SetLocStartPosition)(CORO_PARAM, uint32 nLoc, uint32 lX, uint32 lY, uint32) {
GLOBALS.StartLocPos[nLoc].Set(lX, lY);
GLOBALS.StartLocPos[nLoc].set(lX, lY);
}
DECLARE_CUSTOM_FUNCTION(SaveTonyPosition)(CORO_PARAM, uint32, uint32, uint32, uint32) {
GLOBALS.saveTonyPos = GLOBALS.Tony->Position();
GLOBALS.saveTonyPos = GLOBALS.Tony->position();
GLOBALS.saveTonyLoc = GLOBALS.Loc->TEMPGetNumLoc();
}
@ -604,7 +604,7 @@ DECLARE_CUSTOM_FUNCTION(EnableInput)(CORO_PARAM, uint32, uint32, uint32, uint32)
}
DECLARE_CUSTOM_FUNCTION(StopTony)(CORO_PARAM, uint32, uint32, uint32, uint32) {
GLOBALS.Tony->StopNoAction(coroParam);
GLOBALS.Tony->stopNoAction(coroParam);
}
DECLARE_CUSTOM_FUNCTION(CustEnableGUI)(CORO_PARAM, uint32, uint32, uint32, uint32) {
@ -624,11 +624,11 @@ void TonyGenericTake1(CORO_PARAM, uint32 nDirection) {
CORO_BEGIN_CODE(_ctx);
GLOBALS.Freeze();
GLOBALS.Tony->Take(nDirection, 0);
GLOBALS.Tony->take(nDirection, 0);
GLOBALS.Unfreeze();
if (!GLOBALS.bSkipIdle)
CORO_INVOKE_0(GLOBALS.Tony->WaitForEndPattern);
CORO_INVOKE_0(GLOBALS.Tony->waitForEndPattern);
CORO_END_CODE;
}
@ -640,14 +640,14 @@ void TonyGenericTake2(CORO_PARAM, uint32 nDirection) {
CORO_BEGIN_CODE(_ctx);
GLOBALS.Freeze();
GLOBALS.Tony->Take(nDirection, 1);
GLOBALS.Tony->take(nDirection, 1);
GLOBALS.Unfreeze();
if (!GLOBALS.bSkipIdle)
CORO_INVOKE_0(GLOBALS.Tony->WaitForEndPattern);
CORO_INVOKE_0(GLOBALS.Tony->waitForEndPattern);
GLOBALS.Freeze();
GLOBALS.Tony->Take(nDirection, 2);
GLOBALS.Tony->take(nDirection, 2);
GLOBALS.Unfreeze();
CORO_END_CODE;
@ -660,11 +660,11 @@ void TonyGenericPut1(CORO_PARAM, uint32 nDirection) {
CORO_BEGIN_CODE(_ctx);
GLOBALS.Freeze();
GLOBALS.Tony->Put(nDirection, 0);
GLOBALS.Tony->put(nDirection, 0);
GLOBALS.Unfreeze();
if (!GLOBALS.bSkipIdle)
CORO_INVOKE_0(GLOBALS.Tony->WaitForEndPattern);
CORO_INVOKE_0(GLOBALS.Tony->waitForEndPattern);
CORO_END_CODE;
}
@ -676,14 +676,14 @@ void TonyGenericPut2(CORO_PARAM, uint32 nDirection) {
CORO_BEGIN_CODE(_ctx);
GLOBALS.Freeze();
GLOBALS.Tony->Put(nDirection, 1);
GLOBALS.Tony->put(nDirection, 1);
GLOBALS.Unfreeze();
if (!GLOBALS.bSkipIdle)
CORO_INVOKE_0(GLOBALS.Tony->WaitForEndPattern);
CORO_INVOKE_0(GLOBALS.Tony->waitForEndPattern);
GLOBALS.Freeze();
GLOBALS.Tony->Put(nDirection, 2);
GLOBALS.Tony->put(nDirection, 2);
GLOBALS.Unfreeze();
CORO_END_CODE;
@ -749,9 +749,9 @@ DECLARE_CUSTOM_FUNCTION(TonyPutDown2)(CORO_PARAM, uint32, uint32, uint32, uint32
DECLARE_CUSTOM_FUNCTION(TonyPerTerra)(CORO_PARAM, uint32 dwParte, uint32, uint32, uint32) {
if (dwParte == 0)
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_PERTERRALEFT);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_PERTERRALEFT);
else
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_PERTERRARIGHT);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_PERTERRARIGHT);
}
DECLARE_CUSTOM_FUNCTION(TonySiRialza)(CORO_PARAM, uint32 dwParte, uint32, uint32, uint32) {
@ -761,18 +761,18 @@ DECLARE_CUSTOM_FUNCTION(TonySiRialza)(CORO_PARAM, uint32 dwParte, uint32, uint32
CORO_BEGIN_CODE(_ctx);
if (dwParte == 0)
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_SIRIALZALEFT);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_SIRIALZALEFT);
else
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_SIRIALZARIGHT);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_SIRIALZARIGHT);
if (!GLOBALS.bSkipIdle)
CORO_INVOKE_0(GLOBALS.Tony->WaitForEndPattern);
CORO_INVOKE_0(GLOBALS.Tony->waitForEndPattern);
CORO_END_CODE;
}
DECLARE_CUSTOM_FUNCTION(TonyPastorella)(CORO_PARAM, uint32 bIsPast, uint32, uint32, uint32) {
GLOBALS.Tony->SetPastorella(bIsPast);
GLOBALS.Tony->setPastorella(bIsPast);
}
DECLARE_CUSTOM_FUNCTION(TonyFischietto)(CORO_PARAM, uint32, uint32, uint32, uint32) {
@ -781,11 +781,11 @@ DECLARE_CUSTOM_FUNCTION(TonyFischietto)(CORO_PARAM, uint32, uint32, uint32, uint
CORO_BEGIN_CODE(_ctx);
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_FISCHIETTORIGHT);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_FISCHIETTORIGHT);
if (!GLOBALS.bSkipIdle)
CORO_INVOKE_0(GLOBALS.Tony->WaitForEndPattern);
CORO_INVOKE_0(GLOBALS.Tony->waitForEndPattern);
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_STANDRIGHT);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_STANDRIGHT);
CORO_END_CODE;
}
@ -834,31 +834,31 @@ DECLARE_CUSTOM_FUNCTION(TonySpaventatoSenzaMani)(CORO_PARAM, uint32 dwText, uint
DECLARE_CUSTOM_FUNCTION(TonyConMartello)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
TonySetNumTexts(dwText);
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_CONMARTELLO;
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_CONMARTELLO);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_CONMARTELLO);
}
DECLARE_CUSTOM_FUNCTION(TonyConBicchiere)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
TonySetNumTexts(dwText);
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_CONBICCHIERE;
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_CONBICCHIERE);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_CONBICCHIERE);
}
DECLARE_CUSTOM_FUNCTION(TonyConVerme)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
TonySetNumTexts(dwText);
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_CONVERME;
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_CONVERME);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_CONVERME);
}
DECLARE_CUSTOM_FUNCTION(TonyConCorda)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
TonySetNumTexts(dwText);
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_CONCORDA;
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_CONCORDA);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_CONCORDA);
}
DECLARE_CUSTOM_FUNCTION(TonyConSegretaria)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
TonySetNumTexts(dwText);
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_CONSEGRETARIA;
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_CONSEGRETARIA);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_CONSEGRETARIA);
}
DECLARE_CUSTOM_FUNCTION(TonyConConiglioANIM)(CORO_PARAM, uint32 dwText, uint32, uint32, uint32) {
@ -889,7 +889,7 @@ DECLARE_CUSTOM_FUNCTION(TonyConPupazzoStart)(CORO_PARAM, uint32, uint32, uint32,
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_CONPUPAZZOSTATIC;
GLOBALS.bStaticTalk = true;
CORO_INVOKE_1(GLOBALS.Tony->StartStatic, GLOBALS.Tony->TALK_CONPUPAZZOSTATIC);
CORO_INVOKE_1(GLOBALS.Tony->startStatic, GLOBALS.Tony->TALK_CONPUPAZZOSTATIC);
CORO_END_CODE;
}
@ -900,7 +900,7 @@ DECLARE_CUSTOM_FUNCTION(TonyConPupazzoEnd)(CORO_PARAM, uint32, uint32, uint32, u
CORO_BEGIN_CODE(_ctx);
CORO_INVOKE_1(GLOBALS.Tony->EndStatic, GLOBALS.Tony->TALK_CONPUPAZZOSTATIC);
CORO_INVOKE_1(GLOBALS.Tony->endStatic, GLOBALS.Tony->TALK_CONPUPAZZOSTATIC);
GLOBALS.bStaticTalk = false;
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_NORMAL;
@ -915,7 +915,7 @@ DECLARE_CUSTOM_FUNCTION(TonyConConiglioStart)(CORO_PARAM, uint32, uint32, uint32
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_CONCONIGLIOSTATIC;
GLOBALS.bStaticTalk = true;
CORO_INVOKE_1(GLOBALS.Tony->StartStatic, GLOBALS.Tony->TALK_CONCONIGLIOSTATIC);
CORO_INVOKE_1(GLOBALS.Tony->startStatic, GLOBALS.Tony->TALK_CONCONIGLIOSTATIC);
CORO_END_CODE;
}
@ -926,7 +926,7 @@ DECLARE_CUSTOM_FUNCTION(TonyConConiglioEnd)(CORO_PARAM, uint32, uint32, uint32,
CORO_BEGIN_CODE(_ctx);
CORO_INVOKE_1(GLOBALS.Tony->EndStatic, GLOBALS.Tony->TALK_CONCONIGLIOSTATIC);
CORO_INVOKE_1(GLOBALS.Tony->endStatic, GLOBALS.Tony->TALK_CONCONIGLIOSTATIC);
GLOBALS.bStaticTalk = false;
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_NORMAL;
@ -941,7 +941,7 @@ DECLARE_CUSTOM_FUNCTION(TonyConRicettaStart)(CORO_PARAM, uint32, uint32, uint32,
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_CONRICETTASTATIC;
GLOBALS.bStaticTalk = true;
CORO_INVOKE_1(GLOBALS.Tony->StartStatic, GLOBALS.Tony->TALK_CONRICETTASTATIC);
CORO_INVOKE_1(GLOBALS.Tony->startStatic, GLOBALS.Tony->TALK_CONRICETTASTATIC);
CORO_END_CODE;
}
@ -952,7 +952,7 @@ DECLARE_CUSTOM_FUNCTION(TonyConRicettaEnd)(CORO_PARAM, uint32, uint32, uint32, u
CORO_BEGIN_CODE(_ctx);
CORO_INVOKE_1(GLOBALS.Tony->EndStatic, GLOBALS.Tony->TALK_CONRICETTASTATIC);
CORO_INVOKE_1(GLOBALS.Tony->endStatic, GLOBALS.Tony->TALK_CONRICETTASTATIC);
GLOBALS.bStaticTalk = false;
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_NORMAL;
@ -967,7 +967,7 @@ DECLARE_CUSTOM_FUNCTION(TonyConCarteStart)(CORO_PARAM, uint32, uint32, uint32, u
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_CONCARTESTATIC;
GLOBALS.bStaticTalk = true;
CORO_INVOKE_1(GLOBALS.Tony->StartStatic, GLOBALS.Tony->TALK_CONCARTESTATIC);
CORO_INVOKE_1(GLOBALS.Tony->startStatic, GLOBALS.Tony->TALK_CONCARTESTATIC);
CORO_END_CODE;
}
@ -978,7 +978,7 @@ DECLARE_CUSTOM_FUNCTION(TonyConCarteEnd)(CORO_PARAM, uint32, uint32, uint32, uin
CORO_BEGIN_CODE(_ctx);
CORO_INVOKE_1(GLOBALS.Tony->EndStatic, GLOBALS.Tony->TALK_CONCARTESTATIC);
CORO_INVOKE_1(GLOBALS.Tony->endStatic, GLOBALS.Tony->TALK_CONCARTESTATIC);
GLOBALS.bStaticTalk = false;
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_NORMAL;
@ -993,7 +993,7 @@ DECLARE_CUSTOM_FUNCTION(TonyConTaccuinoStart)(CORO_PARAM, uint32, uint32, uint32
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_CONTACCUINOSTATIC;
GLOBALS.bStaticTalk = true;
CORO_INVOKE_1(GLOBALS.Tony->StartStatic, GLOBALS.Tony->TALK_CONTACCUINOSTATIC);
CORO_INVOKE_1(GLOBALS.Tony->startStatic, GLOBALS.Tony->TALK_CONTACCUINOSTATIC);
CORO_END_CODE;
}
@ -1004,7 +1004,7 @@ DECLARE_CUSTOM_FUNCTION(TonyConTaccuinoEnd)(CORO_PARAM, uint32, uint32, uint32,
CORO_BEGIN_CODE(_ctx);
CORO_INVOKE_1(GLOBALS.Tony->EndStatic, GLOBALS.Tony->TALK_CONTACCUINOSTATIC);
CORO_INVOKE_1(GLOBALS.Tony->endStatic, GLOBALS.Tony->TALK_CONTACCUINOSTATIC);
GLOBALS.bStaticTalk = false;
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_NORMAL;
@ -1019,7 +1019,7 @@ DECLARE_CUSTOM_FUNCTION(TonyConMegafonoStart)(CORO_PARAM, uint32, uint32, uint32
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_CONMEGAFONOSTATIC;
GLOBALS.bStaticTalk = true;
CORO_INVOKE_1(GLOBALS.Tony->StartStatic, GLOBALS.Tony->TALK_CONMEGAFONOSTATIC);
CORO_INVOKE_1(GLOBALS.Tony->startStatic, GLOBALS.Tony->TALK_CONMEGAFONOSTATIC);
CORO_END_CODE;
}
@ -1030,7 +1030,7 @@ DECLARE_CUSTOM_FUNCTION(TonyConMegafonoEnd)(CORO_PARAM, uint32, uint32, uint32,
CORO_BEGIN_CODE(_ctx);
CORO_INVOKE_1(GLOBALS.Tony->EndStatic, GLOBALS.Tony->TALK_CONMEGAFONOSTATIC);
CORO_INVOKE_1(GLOBALS.Tony->endStatic, GLOBALS.Tony->TALK_CONMEGAFONOSTATIC);
GLOBALS.bStaticTalk = false;
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_NORMAL;
@ -1045,7 +1045,7 @@ DECLARE_CUSTOM_FUNCTION(TonyConBarbaStart)(CORO_PARAM, uint32, uint32, uint32, u
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_CONBARBASTATIC;
GLOBALS.bStaticTalk = true;
CORO_INVOKE_1(GLOBALS.Tony->StartStatic, GLOBALS.Tony->TALK_CONBARBASTATIC);
CORO_INVOKE_1(GLOBALS.Tony->startStatic, GLOBALS.Tony->TALK_CONBARBASTATIC);
CORO_END_CODE;
}
@ -1056,7 +1056,7 @@ DECLARE_CUSTOM_FUNCTION(TonyConBarbaEnd)(CORO_PARAM, uint32, uint32, uint32, uin
CORO_BEGIN_CODE(_ctx);
CORO_INVOKE_1(GLOBALS.Tony->EndStatic, GLOBALS.Tony->TALK_CONBARBASTATIC);
CORO_INVOKE_1(GLOBALS.Tony->endStatic, GLOBALS.Tony->TALK_CONBARBASTATIC);
GLOBALS.bStaticTalk = false;
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_NORMAL;
@ -1071,7 +1071,7 @@ DECLARE_CUSTOM_FUNCTION(TonySpaventatoStart)(CORO_PARAM, uint32, uint32, uint32,
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_SPAVENTATOSTATIC;
GLOBALS.bStaticTalk = true;
CORO_INVOKE_1(GLOBALS.Tony->StartStatic, GLOBALS.Tony->TALK_SPAVENTATOSTATIC);
CORO_INVOKE_1(GLOBALS.Tony->startStatic, GLOBALS.Tony->TALK_SPAVENTATOSTATIC);
CORO_END_CODE;
}
@ -1082,7 +1082,7 @@ DECLARE_CUSTOM_FUNCTION(TonySpaventatoEnd)(CORO_PARAM, uint32, uint32, uint32, u
CORO_BEGIN_CODE(_ctx);
CORO_INVOKE_1(GLOBALS.Tony->EndStatic, GLOBALS.Tony->TALK_SPAVENTATOSTATIC);
CORO_INVOKE_1(GLOBALS.Tony->endStatic, GLOBALS.Tony->TALK_SPAVENTATOSTATIC);
GLOBALS.bStaticTalk = false;
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_NORMAL;
@ -1101,8 +1101,8 @@ DECLARE_CUSTOM_FUNCTION(TonySniffaLeft)(CORO_PARAM, uint32, uint32, uint32, uint
CORO_BEGIN_CODE(_ctx);
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_SNIFFA_LEFT);
CORO_INVOKE_0(GLOBALS.Tony->WaitForEndPattern);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_SNIFFA_LEFT);
CORO_INVOKE_0(GLOBALS.Tony->waitForEndPattern);
CORO_INVOKE_4(LeftToMe, 0, 0, 0, 0);
CORO_END_CODE;
@ -1114,8 +1114,8 @@ DECLARE_CUSTOM_FUNCTION(TonySniffaRight)(CORO_PARAM, uint32, uint32, uint32, uin
CORO_BEGIN_CODE(_ctx);
GLOBALS.Tony->SetPattern(GLOBALS.Tony->PAT_SNIFFA_RIGHT);
CORO_INVOKE_0(GLOBALS.Tony->WaitForEndPattern);
GLOBALS.Tony->setPattern(GLOBALS.Tony->PAT_SNIFFA_RIGHT);
CORO_INVOKE_0(GLOBALS.Tony->waitForEndPattern);
CORO_INVOKE_4(RightToMe, 0, 0, 0, 0);
CORO_END_CODE;
@ -1160,11 +1160,11 @@ DECLARE_CUSTOM_FUNCTION(TonyMacbeth)(CORO_PARAM, uint32 nPos, uint32, uint32, ui
DECLARE_CUSTOM_FUNCTION(EnableTony)(CORO_PARAM, uint32, uint32, uint32, uint32) {
GLOBALS.Tony->Show();
GLOBALS.Tony->show();
}
DECLARE_CUSTOM_FUNCTION(DisableTony)(CORO_PARAM, uint32 bShowOmbra, uint32, uint32, uint32) {
GLOBALS.Tony->Hide(bShowOmbra);
GLOBALS.Tony->hide(bShowOmbra);
}
DECLARE_CUSTOM_FUNCTION(WaitForPatternEnd)(CORO_PARAM, uint32 nItem, uint32, uint32, uint32) {
@ -1174,17 +1174,17 @@ DECLARE_CUSTOM_FUNCTION(WaitForPatternEnd)(CORO_PARAM, uint32 nItem, uint32, uin
CORO_BEGIN_CODE(_ctx);
_ctx->item = GLOBALS.Loc->GetItemFromCode(nItem);
_ctx->item = GLOBALS.Loc->getItemFromCode(nItem);
if (!GLOBALS.bSkipIdle && _ctx->item != NULL)
CORO_INVOKE_1(_ctx->item->WaitForEndPattern, GLOBALS.hSkipIdle);
CORO_INVOKE_1(_ctx->item->waitForEndPattern, GLOBALS.hSkipIdle);
CORO_END_CODE;
}
DECLARE_CUSTOM_FUNCTION(SetTonyPosition)(CORO_PARAM, uint32 nX, uint32 nY, uint32 nLoc, uint32) {
GLOBALS.Tony->SetPosition(RMPoint(nX, nY), nLoc);
GLOBALS.Tony->setPosition(RMPoint(nX, nY), nLoc);
}
DECLARE_CUSTOM_FUNCTION(MoveTonyAndWait)(CORO_PARAM, uint32 nX, uint32 nY, uint32, uint32) {
@ -1193,16 +1193,16 @@ DECLARE_CUSTOM_FUNCTION(MoveTonyAndWait)(CORO_PARAM, uint32 nX, uint32 nY, uint3
CORO_BEGIN_CODE(_ctx);
CORO_INVOKE_1(GLOBALS.Tony->Move, RMPoint(nX, nY));
CORO_INVOKE_1(GLOBALS.Tony->move, RMPoint(nX, nY));
if (!GLOBALS.bSkipIdle)
CORO_INVOKE_0(GLOBALS.Tony->WaitForEndMovement);
CORO_INVOKE_0(GLOBALS.Tony->waitForEndMovement);
CORO_END_CODE;
}
DECLARE_CUSTOM_FUNCTION(MoveTony)(CORO_PARAM, uint32 nX, uint32 nY, uint32, uint32) {
GLOBALS.Tony->Move(coroParam, RMPoint(nX, nY));
GLOBALS.Tony->move(coroParam, RMPoint(nX, nY));
}
DECLARE_CUSTOM_FUNCTION(ScrollLocation)(CORO_PARAM, uint32 nX, uint32 nY, uint32 sX, uint32 sY) {
@ -1217,34 +1217,34 @@ DECLARE_CUSTOM_FUNCTION(ScrollLocation)(CORO_PARAM, uint32 nX, uint32 nY, uint32
_ctx->lx = (int32)nX;
_ctx->ly = (int32)nY;
_ctx->pt = GLOBALS.Loc->ScrollPosition();
_ctx->pt = GLOBALS.Loc->scrollPosition();
while ((_ctx->lx != 0 || _ctx->ly != 0) && !GLOBALS.bSkipIdle) {
if (_ctx->lx > 0) {
_ctx->lx -= (int32)sX;
if (_ctx->lx < 0) _ctx->lx = 0;
_ctx->pt.Offset((int32)sX, 0);
_ctx->pt.offset((int32)sX, 0);
} else if (_ctx->lx < 0) {
_ctx->lx += (int32)sX;
if (_ctx->lx > 0) _ctx->lx = 0;
_ctx->pt.Offset(-(int32)sX, 0);
_ctx->pt.offset(-(int32)sX, 0);
}
if (_ctx->ly > 0) {
_ctx->ly -= sY;
if (_ctx->ly < 0) _ctx->ly = 0;
_ctx->pt.Offset(0, sY);
_ctx->pt.offset(0, sY);
} else if (_ctx->ly < 0) {
_ctx->ly += sY;
if (_ctx->ly > 0) _ctx->ly = 0;
_ctx->pt.Offset(0, -(int32)sY);
_ctx->pt.offset(0, -(int32)sY);
}
CORO_INVOKE_0(GLOBALS.WaitFrame);
GLOBALS.Freeze();
GLOBALS.Loc->SetScrollPosition(_ctx->pt);
GLOBALS.Tony->SetScrollPosition(_ctx->pt);
GLOBALS.Loc->setScrollPosition(_ctx->pt);
GLOBALS.Tony->setScrollPosition(_ctx->pt);
GLOBALS.Unfreeze();
}
@ -1276,7 +1276,7 @@ DECLARE_CUSTOM_FUNCTION(SyncScrollLocation)(CORO_PARAM, uint32 nX, uint32 nY, ui
_ctx->stepX = sX;
_ctx->stepY = sY;
_ctx->startpt = GLOBALS.Loc->ScrollPosition();
_ctx->startpt = GLOBALS.Loc->scrollPosition();
_ctx->dwStartTime = _vm->getTime();
@ -1308,8 +1308,8 @@ DECLARE_CUSTOM_FUNCTION(SyncScrollLocation)(CORO_PARAM, uint32 nX, uint32 nY, ui
CORO_INVOKE_0(GLOBALS.WaitFrame);
GLOBALS.Freeze();
GLOBALS.Loc->SetScrollPosition(_ctx->pt);
GLOBALS.Tony->SetScrollPosition(_ctx->pt);
GLOBALS.Loc->setScrollPosition(_ctx->pt);
GLOBALS.Tony->setScrollPosition(_ctx->pt);
GLOBALS.Unfreeze();
}
@ -1329,8 +1329,8 @@ DECLARE_CUSTOM_FUNCTION(SyncScrollLocation)(CORO_PARAM, uint32 nX, uint32 nY, ui
}
GLOBALS.Freeze();
GLOBALS.Loc->SetScrollPosition(_ctx->pt);
GLOBALS.Tony->SetScrollPosition(_ctx->pt);
GLOBALS.Loc->setScrollPosition(_ctx->pt);
GLOBALS.Tony->setScrollPosition(_ctx->pt);
GLOBALS.Unfreeze();
CORO_END_CODE;
@ -1354,7 +1354,7 @@ DECLARE_CUSTOM_FUNCTION(ChangeHotspot)(CORO_PARAM, uint32 dwCode, uint32 nX, uin
GLOBALS.curChangedHotspot++;
}
GLOBALS.Loc->GetItemFromCode(dwCode)->ChangeHotspot(RMPoint(nX, nY));
GLOBALS.Loc->getItemFromCode(dwCode)->changeHotspot(RMPoint(nX, nY));
}
@ -1384,8 +1384,8 @@ DECLARE_CUSTOM_FUNCTION(TremaSchermo)(CORO_PARAM, uint32 nScosse, uint32, uint32
CORO_INVOKE_0(GLOBALS.WaitFrame);
GLOBALS.Freeze();
GLOBALS.Loc->SetFixedScroll(RMPoint(1 * _ctx->dirx, 1 * _ctx->diry));
GLOBALS.Tony->SetFixedScroll(RMPoint(1 * _ctx->dirx, 1 * _ctx->diry));
GLOBALS.Loc->setFixedScroll(RMPoint(1 * _ctx->dirx, 1 * _ctx->diry));
GLOBALS.Tony->setFixedScroll(RMPoint(1 * _ctx->dirx, 1 * _ctx->diry));
GLOBALS.Unfreeze();
_ctx->i = _vm->_randomSource.getRandomNumber(2);
@ -1397,8 +1397,8 @@ DECLARE_CUSTOM_FUNCTION(TremaSchermo)(CORO_PARAM, uint32 nScosse, uint32, uint32
}
GLOBALS.Freeze();
GLOBALS.Loc->SetFixedScroll(RMPoint(0, 0));
GLOBALS.Tony->SetFixedScroll(RMPoint(0, 0));
GLOBALS.Loc->setFixedScroll(RMPoint(0, 0));
GLOBALS.Tony->setFixedScroll(RMPoint(0, 0));
GLOBALS.Unfreeze();
CORO_END_CODE;
@ -1413,7 +1413,7 @@ DECLARE_CUSTOM_FUNCTION(TremaSchermo)(CORO_PARAM, uint32 nScosse, uint32, uint32
DECLARE_CUSTOM_FUNCTION(CharSetCode)(CORO_PARAM, uint32 nChar, uint32 nCode, uint32, uint32) {
assert(nChar < 16);
GLOBALS.Character[nChar].code = nCode;
GLOBALS.Character[nChar].item = GLOBALS.Loc->GetItemFromCode(nCode);
GLOBALS.Character[nChar].item = GLOBALS.Loc->getItemFromCode(nCode);
GLOBALS.Character[nChar].r = 255;
GLOBALS.Character[nChar].g = 255;
GLOBALS.Character[nChar].b = 255;
@ -1461,18 +1461,18 @@ DECLARE_CUSTOM_FUNCTION(CharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMess
_ctx->curOffset = 0;
assert(nChar < 16);
_ctx->pt = GLOBALS.Character[nChar].item->CalculatePos() - RMPoint(-60, 20) - GLOBALS.Loc->ScrollPosition();
_ctx->pt = GLOBALS.Character[nChar].item->calculatePos() - RMPoint(-60, 20) - GLOBALS.Loc->scrollPosition();
if (GLOBALS.Character[nChar].starttalkpattern != 0) {
GLOBALS.Freeze();
GLOBALS.Character[nChar].item->SetPattern(GLOBALS.Character[nChar].starttalkpattern);
GLOBALS.Character[nChar].item->setPattern(GLOBALS.Character[nChar].starttalkpattern);
GLOBALS.Unfreeze();
CORO_INVOKE_0(GLOBALS.Character[nChar].item->WaitForEndPattern);
CORO_INVOKE_0(GLOBALS.Character[nChar].item->waitForEndPattern);
}
GLOBALS.Freeze();
GLOBALS.Character[nChar].item->SetPattern(GLOBALS.Character[nChar].talkpattern);
GLOBALS.Character[nChar].item->setPattern(GLOBALS.Character[nChar].talkpattern);
GLOBALS.Unfreeze();
_ctx->curVoc = SearchVoiceHeader(0, dwMessage);
@ -1483,7 +1483,7 @@ DECLARE_CUSTOM_FUNCTION(CharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMess
_ctx->curOffset = _ctx->curVoc->_offset;
}
for (_ctx->i = 0; _ctx->i < _ctx->msg->NumPeriods() && !GLOBALS.bSkipIdle; _ctx->i++) {
for (_ctx->i = 0; _ctx->i < _ctx->msg->numPeriods() && !GLOBALS.bSkipIdle; _ctx->i++) {
if (bIsBack) {
GLOBALS.curBackText = _ctx->text = new RMTextDialogScrolling(GLOBALS.Loc);
if (GLOBALS.bTonyIsSpeaking)
@ -1545,13 +1545,13 @@ DECLARE_CUSTOM_FUNCTION(CharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMess
if (GLOBALS.Character[nChar].endtalkpattern != 0) {
GLOBALS.Freeze();
GLOBALS.Character[nChar].item->SetPattern(GLOBALS.Character[nChar].endtalkpattern);
GLOBALS.Character[nChar].item->setPattern(GLOBALS.Character[nChar].endtalkpattern);
GLOBALS.Unfreeze();
CORO_INVOKE_0(GLOBALS.Character[nChar].item->WaitForEndPattern);
CORO_INVOKE_0(GLOBALS.Character[nChar].item->waitForEndPattern);
}
GLOBALS.Freeze();
GLOBALS.Character[nChar].item->SetPattern(GLOBALS.Character[nChar].standpattern);
GLOBALS.Character[nChar].item->setPattern(GLOBALS.Character[nChar].standpattern);
GLOBALS.Unfreeze();
delete _ctx->msg;
@ -1581,7 +1581,7 @@ DECLARE_CUSTOM_FUNCTION(MCharSetCode)(CORO_PARAM, uint32 nChar, uint32 nCode, ui
if (nCode == 0)
GLOBALS.MCharacter[nChar].item = NULL;
else
GLOBALS.MCharacter[nChar].item = GLOBALS.Loc->GetItemFromCode(nCode);
GLOBALS.MCharacter[nChar].item = GLOBALS.Loc->getItemFromCode(nCode);
GLOBALS.MCharacter[nChar].r = 255;
GLOBALS.MCharacter[nChar].g = 255;
GLOBALS.MCharacter[nChar].b = 255;
@ -1598,7 +1598,7 @@ DECLARE_CUSTOM_FUNCTION(MCharSetCode)(CORO_PARAM, uint32 nChar, uint32 nCode, ui
}
DECLARE_CUSTOM_FUNCTION(MCharResetCode)(CORO_PARAM, uint32 nChar, uint32, uint32, uint32) {
GLOBALS.MCharacter[nChar].item = GLOBALS.Loc->GetItemFromCode(GLOBALS.MCharacter[nChar].code);
GLOBALS.MCharacter[nChar].item = GLOBALS.Loc->getItemFromCode(GLOBALS.MCharacter[nChar].code);
}
@ -1670,7 +1670,7 @@ DECLARE_CUSTOM_FUNCTION(MCharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMes
// Calculates the position of the text according to the current frame
if (GLOBALS.MCharacter[nChar].x == -1)
_ctx->pt = GLOBALS.MCharacter[nChar].item->CalculatePos() - RMPoint(-60, 20) - GLOBALS.Loc->ScrollPosition();
_ctx->pt = GLOBALS.MCharacter[nChar].item->calculatePos() - RMPoint(-60, 20) - GLOBALS.Loc->scrollPosition();
else
_ctx->pt = RMPoint(GLOBALS.MCharacter[nChar].x, GLOBALS.MCharacter[nChar].y);
@ -1680,7 +1680,7 @@ DECLARE_CUSTOM_FUNCTION(MCharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMes
// Try to run the custom function to initialise the speech
if (GLOBALS.MCharacter[nChar].item) {
_ctx->h = mpalQueryDoAction(30, GLOBALS.MCharacter[nChar].item->MpalCode(), _ctx->parm);
_ctx->h = mpalQueryDoAction(30, GLOBALS.MCharacter[nChar].item->mpalCode(), _ctx->parm);
if (_ctx->h != CORO_INVALID_PID_VALUE) {
CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->h, CORO_INFINITE);
}
@ -1695,7 +1695,7 @@ DECLARE_CUSTOM_FUNCTION(MCharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMes
_ctx->curOffset = _ctx->curVoc->_offset;
}
for (_ctx->i = 0; _ctx->i < _ctx->msg->NumPeriods() && !GLOBALS.bSkipIdle; _ctx->i++) {
for (_ctx->i = 0; _ctx->i < _ctx->msg->numPeriods() && !GLOBALS.bSkipIdle; _ctx->i++) {
// Create a different object depending on whether it's background or not
if (bIsBack) {
GLOBALS.curBackText = _ctx->text = new RMTextDialogScrolling(GLOBALS.Loc);
@ -1759,7 +1759,7 @@ DECLARE_CUSTOM_FUNCTION(MCharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMes
// Try to run the custom function to close the speech
if (GLOBALS.MCharacter[nChar].item) {
_ctx->h = mpalQueryDoAction(31, GLOBALS.MCharacter[nChar].item->MpalCode(), _ctx->parm);
_ctx->h = mpalQueryDoAction(31, GLOBALS.MCharacter[nChar].item->mpalCode(), _ctx->parm);
if (_ctx->h != CORO_INVALID_PID_VALUE)
CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->h, CORO_INFINITE);
}
@ -1767,11 +1767,6 @@ DECLARE_CUSTOM_FUNCTION(MCharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMes
CORO_END_CODE;
}
/*
* Dialoghi
*/
@ -1815,46 +1810,46 @@ DECLARE_CUSTOM_FUNCTION(SendDialogMessage)(CORO_PARAM, uint32 nPers, uint32 nMsg
if (nPers == 0) {
_ctx->text = new RMTextDialog;
_ctx->text->setColor(0, 255, 0);
_ctx->text->setPosition(GLOBALS.Tony->Position() - RMPoint(0, 130) - GLOBALS.Loc->ScrollPosition());
_ctx->text->setPosition(GLOBALS.Tony->position() - RMPoint(0, 130) - GLOBALS.Loc->scrollPosition());
_ctx->text->writeText(_ctx->string, 0);
if (GLOBALS.dwTonyNumTexts > 0) {
if (!GLOBALS.bTonyInTexts) {
if (GLOBALS.nTonyNextTalkType != GLOBALS.Tony->TALK_NORMAL) {
CORO_INVOKE_1(GLOBALS.Tony->StartTalk, GLOBALS.nTonyNextTalkType);
CORO_INVOKE_1(GLOBALS.Tony->startTalk, GLOBALS.nTonyNextTalkType);
if (!GLOBALS.bStaticTalk)
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_NORMAL;
} else
CORO_INVOKE_1(GLOBALS.Tony->StartTalk, GLOBALS.Tony->TALK_NORMAL);
CORO_INVOKE_1(GLOBALS.Tony->startTalk, GLOBALS.Tony->TALK_NORMAL);
GLOBALS.bTonyInTexts = true;
}
GLOBALS.dwTonyNumTexts--;
} else {
CORO_INVOKE_1(GLOBALS.Tony->StartTalk, GLOBALS.nTonyNextTalkType);
CORO_INVOKE_1(GLOBALS.Tony->startTalk, GLOBALS.nTonyNextTalkType);
if (!GLOBALS.bStaticTalk)
GLOBALS.nTonyNextTalkType = GLOBALS.Tony->TALK_NORMAL;
}
} else if (!GLOBALS.IsMChar[nPers]) {
_ctx->text = new RMTextDialog;
_ctx->pt = GLOBALS.Character[nPers].item->CalculatePos() - RMPoint(-60, 20) - GLOBALS.Loc->ScrollPosition();
_ctx->pt = GLOBALS.Character[nPers].item->calculatePos() - RMPoint(-60, 20) - GLOBALS.Loc->scrollPosition();
if (GLOBALS.Character[nPers].starttalkpattern != 0) {
GLOBALS.Freeze();
GLOBALS.Character[nPers].item->SetPattern(GLOBALS.Character[nPers].starttalkpattern);
GLOBALS.Character[nPers].item->setPattern(GLOBALS.Character[nPers].starttalkpattern);
GLOBALS.Unfreeze();
CORO_INVOKE_0(GLOBALS.Character[nPers].item->WaitForEndPattern);
CORO_INVOKE_0(GLOBALS.Character[nPers].item->waitForEndPattern);
}
GLOBALS.Character[nPers].item->SetPattern(GLOBALS.Character[nPers].talkpattern);
GLOBALS.Character[nPers].item->setPattern(GLOBALS.Character[nPers].talkpattern);
_ctx->text->setColor(GLOBALS.Character[nPers].r, GLOBALS.Character[nPers].g, GLOBALS.Character[nPers].b);
_ctx->text->writeText(_ctx->string, 0);
_ctx->text->setPosition(_ctx->pt);
} else {
if (GLOBALS.MCharacter[nPers].x == -1)
_ctx->pt = GLOBALS.MCharacter[nPers].item->CalculatePos() - RMPoint(-60, 20) - GLOBALS.Loc->ScrollPosition();
_ctx->pt = GLOBALS.MCharacter[nPers].item->calculatePos() - RMPoint(-60, 20) - GLOBALS.Loc->scrollPosition();
else
_ctx->pt = RMPoint(GLOBALS.MCharacter[nPers].x, GLOBALS.MCharacter[nPers].y);
@ -1866,7 +1861,7 @@ DECLARE_CUSTOM_FUNCTION(SendDialogMessage)(CORO_PARAM, uint32 nPers, uint32 nMsg
GLOBALS.MCharacter[nPers].numtexts--;
} else {
// Try to run the custom function to initialise the speech
_ctx->h = mpalQueryDoAction(30, GLOBALS.MCharacter[nPers].item->MpalCode(), _ctx->parm);
_ctx->h = mpalQueryDoAction(30, GLOBALS.MCharacter[nPers].item->mpalCode(), _ctx->parm);
if (_ctx->h != CORO_INVALID_PID_VALUE)
CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->h, CORO_INFINITE);
@ -1922,18 +1917,18 @@ DECLARE_CUSTOM_FUNCTION(SendDialogMessage)(CORO_PARAM, uint32 nPers, uint32 nMsg
if (!GLOBALS.IsMChar[nPers]) {
if (GLOBALS.Character[nPers].endtalkpattern != 0) {
GLOBALS.Freeze();
GLOBALS.Character[nPers].item->SetPattern(GLOBALS.Character[nPers].endtalkpattern);
GLOBALS.Character[nPers].item->setPattern(GLOBALS.Character[nPers].endtalkpattern);
GLOBALS.Unfreeze();
CORO_INVOKE_0(GLOBALS.Character[nPers].item->WaitForEndPattern);
CORO_INVOKE_0(GLOBALS.Character[nPers].item->waitForEndPattern);
}
GLOBALS.Character[nPers].item->SetPattern(GLOBALS.Character[nPers].standpattern);
GLOBALS.Character[nPers].item->setPattern(GLOBALS.Character[nPers].standpattern);
delete _ctx->text;
} else {
if ((GLOBALS.MCharacter[nPers].bInTexts && GLOBALS.MCharacter[nPers].numtexts == 0) || !GLOBALS.MCharacter[nPers].bInTexts) {
// Try to run the custom function to close the speech
GLOBALS.MCharacter[nPers].curTalk = (GLOBALS.MCharacter[nPers].curTalk % 10) + GLOBALS.MCharacter[nPers].curgroup * 10;
_ctx->h = mpalQueryDoAction(31, GLOBALS.MCharacter[nPers].item->MpalCode(), GLOBALS.MCharacter[nPers].curTalk);
_ctx->h = mpalQueryDoAction(31, GLOBALS.MCharacter[nPers].item->mpalCode(), GLOBALS.MCharacter[nPers].curTalk);
if (_ctx->h != CORO_INVALID_PID_VALUE)
CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->h, CORO_INFINITE);
@ -1946,7 +1941,7 @@ DECLARE_CUSTOM_FUNCTION(SendDialogMessage)(CORO_PARAM, uint32 nPers, uint32 nMsg
}
} else {
if ((GLOBALS.dwTonyNumTexts == 0 && GLOBALS.bTonyInTexts) || !GLOBALS.bTonyInTexts) {
CORO_INVOKE_0(GLOBALS.Tony->EndTalk);
CORO_INVOKE_0(GLOBALS.Tony->endTalk);
GLOBALS.dwTonyNumTexts = 0;
GLOBALS.bTonyInTexts = false;
}
@ -2201,11 +2196,11 @@ DECLARE_CUSTOM_FUNCTION(PlayStacchetto)(CORO_PARAM, uint32 nMusic, uint32 nFX, u
DECLARE_CUSTOM_FUNCTION(PlayItemSfx)(CORO_PARAM, uint32 nItem, uint32 nSFX, uint32, uint32) {
if (nItem == 0) {
GLOBALS.Tony->PlaySfx(nSFX);
GLOBALS.Tony->playSfx(nSFX);
} else {
RMItem *item = GLOBALS.Loc->GetItemFromCode(nItem);
RMItem *item = GLOBALS.Loc->getItemFromCode(nItem);
if (item)
item->PlaySfx(nSFX);
item->playSfx(nSFX);
}
}
@ -2325,9 +2320,9 @@ DECLARE_CUSTOM_FUNCTION(DoCredits)(CORO_PARAM, uint32 nMsg, uint32 dwTime, uint3
_ctx->msg = new RMMessage(nMsg);
_ctx->hDisable = CoroScheduler.createEvent(true, false);
_ctx->text = new RMTextDialog[_ctx->msg->NumPeriods()];
_ctx->text = new RMTextDialog[_ctx->msg->numPeriods()];
for (_ctx->i = 0; _ctx->i < _ctx->msg->NumPeriods(); _ctx->i++) {
for (_ctx->i = 0; _ctx->i < _ctx->msg->numPeriods(); _ctx->i++) {
_ctx->text[_ctx->i].setInput(GLOBALS.Input);
// Alignment

6
engines/tony/debugger.cpp
View file

@ -87,7 +87,7 @@ bool Debugger::Cmd_Scene(int argc, const char **argv) {
}
int sceneNumber = strToInt(argv[1]);
if (sceneNumber >= _vm->_theBoxes.GetLocBoxesCount()) {
if (sceneNumber >= _vm->_theBoxes.getLocBoxesCount()) {
DebugPrintf("Invalid scene\n");
return true;
}
@ -99,8 +99,8 @@ bool Debugger::Cmd_Scene(int argc, const char **argv) {
} else {
// Get the box areas for the scene, and choose one so as to have a default
// position for Tony that will be in the walkable areas
RMBoxLoc *box = _vm->_theBoxes.GetBoxes(sceneNumber);
scenePos.Set(box->boxes[0].hotspot[0].hotx, box->boxes[0].hotspot[0].hoty);
RMBoxLoc *box = _vm->_theBoxes.getBoxes(sceneNumber);
scenePos.set(box->boxes[0].hotspot[0].hotx, box->boxes[0].hotspot[0].hoty);
}
// Set up a process to change the scene

50
engines/tony/font.cpp
View file

@ -82,8 +82,8 @@ void RMFont::load(const byte *buf, int nChars, int dimx, int dimy, uint32 palRes
void RMFont::load(uint32 resID, int nChars, int dimx, int dimy, uint32 palResID) {
RMRes res(resID);
if ((int)res.Size() < nChars * (dimy * dimx + 8))
nChars = res.Size() / (dimy * dimx + 8);
if ((int)res.size() < nChars * (dimy * dimx + 8))
nChars = res.size() / (dimy * dimx + 8);
load(res, nChars, dimx, dimy, palResID);
}
@ -137,7 +137,7 @@ int RMFont::stringLen(const RMString &text) {
int len, i;
len = 0;
for (i = 0; i < text.Length() - 1; i++)
for (i = 0; i < text.length() - 1; i++)
len += letterLength(text[i], text[i + 1]);
len += letterLength(text[i]);
@ -1968,9 +1968,9 @@ void RMText::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
CORO_BEGIN_CODE(_ctx);
// Horizontally
if (aHorType == HCENTER)
prim->Dst().TopLeft() -= RMPoint(_dimx / 2, 0);
prim->Dst().topLeft() -= RMPoint(_dimx / 2, 0);
else if (aHorType == HRIGHT)
prim->Dst().TopLeft() -= RMPoint(_dimx, 0);
prim->Dst().topLeft() -= RMPoint(_dimx, 0);
// Vertically
@ -2146,7 +2146,7 @@ void RMTextDialog::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *p
if (_bShowed) {
if (GLOBALS.bCfgSottotitoli || _bAlwaysDisplay) {
prim->Dst().TopLeft() = dst;
prim->Dst().topLeft() = dst;
CORO_INVOKE_2(RMText::draw, bigBuf, prim);
}
}
@ -2180,7 +2180,7 @@ RMTextDialogScrolling::RMTextDialogScrolling() {
RMTextDialogScrolling::RMTextDialogScrolling(RMLocation *loc) {
curLoc = loc;
startScroll = loc->ScrollPosition();
startScroll = loc->scrollPosition();
}
RMTextDialogScrolling::~RMTextDialogScrolling() {
@ -2196,7 +2196,7 @@ void RMTextDialogScrolling::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPri
_ctx->curDst = dst;
if (curLoc != NULL)
dst -= curLoc->ScrollPosition() - startScroll;
dst -= curLoc->scrollPosition() - startScroll;
CORO_INVOKE_2(RMTextDialog::draw, bigBuf, prim);
@ -2240,19 +2240,19 @@ void RMTextItemName::doFrame(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMLocation &
bigBuf.addPrim(new RMGfxPrimitive(this));
// Update the scrolling co-ordinates
_curscroll = loc.ScrollPosition();
_curscroll = loc.scrollPosition();
// Check if we are on the inventory
if (inv.itemInFocus(_mpos))
_item = inv.whichItemIsIn(_mpos);
else
_item = loc.WhichItemIsIn(_mpos);
_item = loc.whichItemIsIn(_mpos);
itemName = "";
// If there an item, get its name
if (_item != NULL)
_item->GetName(itemName);
_item->getName(itemName);
// Write it
writeText(itemName, 1);
@ -2262,7 +2262,7 @@ void RMTextItemName::doFrame(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMLocation &
if (_item == NULL)
ptr.setSpecialPointer(RMPointer::PTR_NONE);
else {
_ctx->hThread = mpalQueryDoAction(20, _item->MpalCode(), 0);
_ctx->hThread = mpalQueryDoAction(20, _item->mpalCode(), 0);
if (_ctx->hThread == CORO_INVALID_PID_VALUE)
ptr.setSpecialPointer(RMPointer::PTR_NONE);
else
@ -2285,7 +2285,7 @@ void RMTextItemName::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive
return;
// Set the destination coordinates of the mouse
prim->Dst().TopLeft() = _mpos - RMPoint(0, 30);
prim->Dst().topLeft() = _mpos - RMPoint(0, 30);
CORO_INVOKE_2(RMText::draw, bigBuf, prim);
@ -2296,7 +2296,7 @@ RMPoint RMTextItemName::getHotspot() {
if (_item == NULL)
return _mpos + _curscroll;
else
return _item->Hotspot();
return _item->hotspot();
}
RMItem *RMTextItemName::getSelectedItem() {
@ -2308,7 +2308,7 @@ bool RMTextItemName::isItemSelected() {
}
bool RMTextItemName::isNormalItemSelected() {
return _item != NULL && _itemName.Length() > 0;
return _item != NULL && _itemName.length() > 0;
}
@ -2321,8 +2321,8 @@ RMDialogChoice::RMDialogChoice() {
RMResRaw dlg2(RES_I_DLGTEXTLINE);
RMRes dlgpal(RES_I_DLGTEXTPAL);
DlgText.init(dlg1, dlg1.Width(), dlg1.Height());
DlgTextLine.init(dlg2, dlg2.Width(), dlg2.Height());
DlgText.init(dlg1, dlg1.width(), dlg1.height());
DlgTextLine.init(dlg2, dlg2.width(), dlg2.height());
DlgText.loadPaletteWA(dlgpal);
DlgTextLine.loadPaletteWA(dlgpal);
@ -2407,18 +2407,18 @@ void RMDialogChoice::prepare(CORO_PARAM) {
addPrim(new RMGfxPrimitive(&DlgTextLine, RMPoint(0, 155 + 83 + 83)));
addPrim(new RMGfxPrimitive(&DlgTextLine, RMPoint(0, 155 + 83 + 83 + 83)));
_ctx->ptPos.Set(20, 90);
_ctx->ptPos.set(20, 90);
for (_ctx->i = 0; _ctx->i < _numChoices; _ctx->i++) {
addPrim(new RMGfxPrimitive(&_drawedStrings[_ctx->i], _ctx->ptPos));
_ptDrawStrings[_ctx->i] = _ctx->ptPos;
_ctx->ptPos.Offset(0, _drawedStrings[_ctx->i].getDimy() + 15);
_ctx->ptPos.offset(0, _drawedStrings[_ctx->i].getDimy() + 15);
}
CORO_INVOKE_0(drawOT);
clearOT();
_ptDrawPos.Set(0, 480 - _ctx->ptPos.y);
_ptDrawPos.set(0, 480 - _ctx->ptPos.y);
CORO_END_CODE;
}
@ -2438,8 +2438,8 @@ void RMDialogChoice::setSelected(CORO_PARAM, int pos) {
if (_curSelection != -1) {
_ctx->box.SetColor(0xCC, 0xCC, 0xFF);
_ctx->rc.TopLeft() = RMPoint(18, _ptDrawStrings[_curSelection].y);
_ctx->rc.BottomRight() = _ctx->rc.TopLeft() + RMPoint(597, _drawedStrings[_curSelection].getDimy());
_ctx->rc.topLeft() = RMPoint(18, _ptDrawStrings[_curSelection].y);
_ctx->rc.bottomRight() = _ctx->rc.topLeft() + RMPoint(597, _drawedStrings[_curSelection].getDimy());
addPrim(new RMGfxPrimitive(&_ctx->box, _ctx->rc));
addPrim(new RMGfxPrimitive(&_drawedStrings[_curSelection], _ptDrawStrings[_curSelection]));
@ -2449,8 +2449,8 @@ void RMDialogChoice::setSelected(CORO_PARAM, int pos) {
if (pos != -1) {
_ctx->box.SetColor(100, 100, 100);
_ctx->rc.TopLeft() = RMPoint(18, _ptDrawStrings[pos].y);
_ctx->rc.BottomRight() = _ctx->rc.TopLeft() + RMPoint(597, _drawedStrings[pos].getDimy());
_ctx->rc.topLeft() = RMPoint(18, _ptDrawStrings[pos].y);
_ctx->rc.bottomRight() = _ctx->rc.topLeft() + RMPoint(597, _drawedStrings[pos].getDimy());
addPrim(new RMGfxPrimitive(&_ctx->box, _ctx->rc));
addPrim(new RMGfxPrimitive(&_drawedStrings[pos], _ptDrawStrings[pos]));
}
@ -2485,7 +2485,7 @@ void RMDialogChoice::show(CORO_PARAM, RMGfxTargetBuffer *bigBuf) {
_ctx->starttime = _vm->getTime();
_ctx->deltay = 480 - _ptDrawPos.y;
_ctx->destpt = _ptDrawPos;
_ptDrawPos.Set(0, 480);
_ptDrawPos.set(0, 480);
if (!_nInList && bigBuf != NULL)
bigBuf->addPrim(new RMGfxPrimitive(this));

44
engines/tony/game.cpp
View file

@ -124,11 +124,11 @@ void mainSetPalesati(bool bPalesati) {
RMOptionButton::RMOptionButton(uint32 dwRes, RMPoint pt, bool bDoubleState) {
RMResRaw raw(dwRes);
assert(raw.IsValid());
assert(raw.isValid());
_buf = new RMGfxSourceBuffer16(false);
_buf->init(raw, raw.Width(), raw.Height());
_buf->init(raw, raw.width(), raw.height());
_rect.SetRect(pt.x, pt.y, pt.x + raw.Width() - 1, pt.y + raw.Height() - 1);
_rect.setRect(pt.x, pt.y, pt.x + raw.width() - 1, pt.y + raw.height() - 1);
_bActive = false;
_bHasGfx = true;
_bDoubleState = bDoubleState;
@ -149,7 +149,7 @@ RMOptionButton::~RMOptionButton() {
bool RMOptionButton::doFrame(const RMPoint &mousePos, bool bLeftClick, bool bRightClick) {
if (!_bDoubleState) {
if (_rect.PtInRect(mousePos)) {
if (_rect.ptInRect(mousePos)) {
if (!_bActive) {
_bActive = true;
return true;
@ -161,7 +161,7 @@ bool RMOptionButton::doFrame(const RMPoint &mousePos, bool bLeftClick, bool bRig
}
}
} else {
if (bLeftClick && _rect.PtInRect(mousePos)) {
if (bLeftClick && _rect.ptInRect(mousePos)) {
_bActive = !_bActive;
return true;
}
@ -511,12 +511,12 @@ void RMOptionScreen::refreshAll(CORO_PARAM) {
RMString s;
if (_bEditSaveName && _nEditPos == _ctx->i)
s.Format("%02d)%s*", _statePos + _ctx->i, _EditName);
s.format("%02d)%s*", _statePos + _ctx->i, _EditName);
else {
if (_statePos == 0 && _ctx->i == 0)
s.Format("Autosave");
s.format("Autosave");
else
s.Format("%02d)%s", _statePos + _ctx->i, (const char *)_curThumbName[_ctx->i]);
s.format("%02d)%s", _statePos + _ctx->i, (const char *)_curThumbName[_ctx->i]);
}
_ctx->num[_ctx->i] = new RMText;
@ -585,10 +585,10 @@ void RMOptionScreen::initState(CORO_PARAM) {
error("Invalid state");
}
assert(_ctx->raw->IsValid());
assert(_ctx->raw->isValid());
assert(_menu == NULL);
_menu = new RMGfxSourceBuffer16(false);
_menu->init(*_ctx->raw, _ctx->raw->Width(), _ctx->raw->Height());
_menu->init(*_ctx->raw, _ctx->raw->width(), _ctx->raw->height());
delete _ctx->raw;
if (_nState == MENULOAD || _nState == MENUSAVE) {
@ -647,10 +647,10 @@ void RMOptionScreen::initState(CORO_PARAM) {
_ButtonSoundMenu = new RMOptionButton(RMRect(212, 32, 306, 64));
_ctx->raw = new RMResRaw(20021);
assert(_ctx->raw->IsValid());
assert(_ctx->raw->isValid());
assert(_QuitConfirm == NULL);
_QuitConfirm = new RMGfxSourceBuffer16(false);
_QuitConfirm->init(*_ctx->raw, _ctx->raw->Width(), _ctx->raw->Height());
_QuitConfirm->init(*_ctx->raw, _ctx->raw->width(), _ctx->raw->height());
delete _ctx->raw;
assert(_ButtonQuitYes == NULL);
@ -662,10 +662,10 @@ void RMOptionScreen::initState(CORO_PARAM) {
if (_bNoLoadSave) {
_ctx->raw = new RMResRaw(20028);
assert(_ctx->raw->IsValid());
assert(_ctx->raw->isValid());
assert(_HideLoadSave == NULL);
_HideLoadSave = new RMGfxSourceBuffer16(false);
_HideLoadSave->init(*_ctx->raw, _ctx->raw->Width(), _ctx->raw->Height());
_HideLoadSave->init(*_ctx->raw, _ctx->raw->width(), _ctx->raw->height());
delete _ctx->raw;
}
@ -1485,7 +1485,7 @@ void RMPointer::init(void) {
RMResRaw res(RES_P_GO + i);
_pointer[i] = new RMGfxSourceBuffer8RLEByteAA;
_pointer[i]->init(res, res.Width(), res.Height(), false);
_pointer[i]->init(res, res.width(), res.height(), false);
_pointer[i]->loadPaletteWA(RES_P_PAL);
}
@ -1493,17 +1493,17 @@ void RMPointer::init(void) {
RMRes res(RES_P_PAP1 + i);
RMDataStream ds;
ds.OpenBuffer(res);
ds.openBuffer(res);
_specialPointer[i] = new RMItem;
ds >> *_specialPointer[i];
}
//m_hotspot[0].Set(19,5);
_hotspot[0].Set(5, 1);
_hotspot[1].Set(32, 28);
_hotspot[2].Set(45, 23);
_hotspot[3].Set(35, 25);
_hotspot[4].Set(32, 28);
//m_hotspot[0].set(19,5);
_hotspot[0].set(5, 1);
_hotspot[1].set(32, 28);
_hotspot[2].set(45, 23);
_hotspot[3].set(35, 25);
_hotspot[4].set(32, 28);
// Default=GO
_nCurPointer = 0;

10
engines/tony/game.h
View file

@ -39,18 +39,18 @@ namespace Tony {
#define INIT_GFX16_FROMRAW(dwRes, buf16) \
raw = new RMResRaw(dwRes); \
assert(raw->IsValid()); \
assert(raw->isValid()); \
assert((buf16) == NULL); \
(buf16) = new RMGfxSourceBuffer16(false); \
(buf16)->init(*raw,raw->Width(),raw->Height()); \
(buf16)->init(*raw,raw->width(),raw->height()); \
delete raw;
#define INIT_GFX8_FROMRAW(raw, dwRes, buf8) \
raw = new RMResRaw(dwRes); \
assert(raw->IsValid()); \
assert(raw->isValid()); \
assert((buf8) == NULL); \
(buf8) = new RMGfxSourceBuffer8RLEByte(); \
(buf8)->init(*raw, raw->Width(), raw->Height(), true); \
(buf8)->init(*raw, raw->width(), raw->height(), true); \
delete raw;
@ -115,7 +115,7 @@ public:
void setSpecialPointer(POINTER ptr) {
_nCurSpecialPointer = ptr;
if (_nCurSpecialPointer && _nCurSpecialPointer != PTR_CUSTOM)
_specialPointer[ptr - 1]->SetPattern(1);
_specialPointer[ptr - 1]->setPattern(1);
}
POINTER getSpecialPointer(void) {
return (POINTER)_nCurSpecialPointer;

28
engines/tony/gfxcore.cpp
View file

@ -146,7 +146,7 @@ int RMGfxSourceBuffer::init(const byte *buf, int dimx, int dimy, bool bLoadPalet
void RMGfxSourceBuffer::init(RMDataStream &ds, int dimx, int dimy, bool bLoadPalette) {
create(dimx, dimy, Bpp());
ds.Read(_buf, dimx * dimy * Bpp() / 8);
ds.read(_buf, dimx * dimy * Bpp() / 8);
// Invokes the method for preparing the surface (inherited)
prepareImage();
@ -448,7 +448,7 @@ void RMGfxSourceBufferPal::init(RMDataStream &ds, int dimx, int dimy, bool bLoad
// Load the palette if necessary
if (bLoadPalette) {
byte *suxpal = new byte[256 * 3];
ds.Read(suxpal, 256 * 3);
ds.read(suxpal, 256 * 3);
loadPaletteWA(suxpal);
delete[] suxpal;
}
@ -512,8 +512,8 @@ void RMGfxSourceBuffer8::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimit
u = prim->Src().x1;
v = prim->Src().y1;
width = prim->Src().Width();
height = prim->Src().Height();
width = prim->Src().width();
height = prim->Src().height();
}
if (!clip2D(dst.x1, dst.y1, u, v, width, height, prim->haveSrc(), &bigBuf))
@ -620,8 +620,8 @@ void RMGfxSourceBuffer8AB::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrim
u = prim->Src().x1;
v = prim->Src().y1;
width = prim->Src().Width();
height = prim->Src().Height();
width = prim->Src().width();
height = prim->Src().height();
}
if (!clip2D(dst.x1, dst.y1, u, v, width, height, prim->haveSrc(), &bigBuf))
@ -702,7 +702,7 @@ void RMGfxSourceBuffer8RLE::init(RMDataStream &ds, int dimx, int dimy, bool bLoa
ds >> size;
_buf = new byte[size];
ds.Read(_buf, size);
ds.read(_buf, size);
_dimx = dimx;
_dimy = dimy;
@ -1767,7 +1767,7 @@ void RMGfxSourceBuffer8RLEByteAA::init(RMDataStream &ds, int dimx, int dimy, boo
if (!bNeedRLECompress) {
// Load the anti-aliasing mask
_aabuf = new byte[dimx * dimy];
ds.Read(_aabuf, dimx * dimy);
ds.read(_aabuf, dimx * dimy);
}
}
@ -1805,7 +1805,7 @@ void RMGfxSourceBuffer8RLEWordAA::init(RMDataStream &ds, int dimx, int dimy, boo
if (!bNeedRLECompress) {
// Load the anti-aliasing mask
_aabuf = new byte[dimx * dimy];
ds.Read(_aabuf, dimx * dimy);
ds.read(_aabuf, dimx * dimy);
}
}
@ -1839,8 +1839,8 @@ void RMGfxSourceBuffer16::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimi
if (prim->haveSrc()) {
u = prim->Src().x1;
v = prim->Src().y1;
dimx = prim->Src().Width();
dimy = prim->Src().Height();
dimx = prim->Src().width();
dimy = prim->Src().height();
}
if (prim->haveDst()) {
@ -1932,11 +1932,11 @@ void RMGfxBox::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim)
buf += rcDst.y1 * bigBuf.getDimx() + rcDst.x1;
// Loop through the pixels
for (j = 0; j < rcDst.Height(); j++) {
for (i = 0; i < rcDst.Width(); i++)
for (j = 0; j < rcDst.height(); j++) {
for (i = 0; i < rcDst.width(); i++)
*buf ++ = wFillColor;
buf += bigBuf.getDimx() - rcDst.Width();
buf += bigBuf.getDimx() - rcDst.width();
}
}

28
engines/tony/gfxcore.h
View file

@ -110,8 +110,8 @@ public:
RMGfxPrimitive() {
_bFlag = 0;
_task = NULL;
_src.SetEmpty();
_dst.SetEmpty();
_src.setEmpty();
_dst.setEmpty();
}
RMGfxPrimitive(RMGfxTask *task) {
@ -124,41 +124,41 @@ public:
_src = src;
_dst = dst;
_bFlag = 0;
_bStretch = (src.Width() != dst.Width() || src.Height() != dst.Height());
_bStretch = (src.width() != dst.width() || src.height() != dst.height());
}
RMGfxPrimitive(RMGfxTask *task, const RMPoint &src, RMRect &dst) {
_task = task;
_src.TopLeft() = src;
_src.topLeft() = src;
_dst = dst;
_bFlag = 0;
}
RMGfxPrimitive(RMGfxTask *task, const RMPoint &src, RMPoint &dst) {
_task = task;
_src.TopLeft() = src;
_dst.TopLeft() = dst;
_src.topLeft() = src;
_dst.topLeft() = dst;
_bFlag = 0;
}
RMGfxPrimitive(RMGfxTask *task, const RMRect &src, RMPoint &dst) {
_task = task;
_src = src;
_dst.TopLeft() = dst;
_dst.topLeft() = dst;
_bFlag = 0;
}
RMGfxPrimitive(RMGfxTask *task, const RMRect &dst) {
_task = task;
_dst = dst;
_src.SetEmpty();
_src.setEmpty();
_bFlag = 0;
}
RMGfxPrimitive(RMGfxTask *task, const RMPoint &dst) {
_task = task;
_dst.TopLeft() = dst;
_src.SetEmpty();
_dst.topLeft() = dst;
_src.setEmpty();
_bFlag = 0;
}
@ -174,27 +174,27 @@ public:
_src = src;
}
void setSrc(const RMPoint &src) {
_src.TopLeft() = src;
_src.topLeft() = src;
}
void setDst(const RMRect &dst) {
_dst = dst;
}
void setDst(const RMPoint &dst) {
_dst.TopLeft() = dst;
_dst.topLeft() = dst;
}
void setStrecth(bool bStretch) {
_bStretch = bStretch;
}
bool haveDst() {
return !_dst.IsEmpty();
return !_dst.isEmpty();
}
RMRect &Dst() {
return _dst;
}
bool haveSrc() {
return !_src.IsEmpty();
return !_src.isEmpty();
}
RMRect &Src() {
return _src;

70
engines/tony/gfxengine.cpp
View file

@ -126,7 +126,7 @@ void RMGfxEngine::openOptionScreen(CORO_PARAM, int type) {
if (type == 1 || type == 2) {
GLOBALS.bIdleExited = true;
} else {
CORO_INVOKE_0(_tony.StopNoAction);
CORO_INVOKE_0(_tony.stopNoAction);
GLOBALS.bIdleExited = false;
@ -170,7 +170,7 @@ void RMGfxEngine::doFrame(CORO_PARAM, bool bDrawLocation) {
_loc.doFrame(&_bigBuf);
// Check the mouse input
if (_bInput && !_tony.InAction()) {
if (_bInput && !_tony.inAction()) {
// If we are on the inventory, it is it who controls all input
if (_inv.haveFocus(_input.mousePos()) && !_inter.active()) {
// Left Click
@ -197,7 +197,7 @@ void RMGfxEngine::doFrame(CORO_PARAM, bool bDrawLocation) {
// *************
if (_input.mouseRightReleased()) {
if (_inv.rightRelease(_input.mousePos(), _curAction)) {
CORO_INVOKE_3(_tony.MoveAndDoAction, _itemName.getHotspot(), _itemName.getSelectedItem(), _curAction);
CORO_INVOKE_3(_tony.moveAndDoAction, _itemName.getHotspot(), _itemName.getSelectedItem(), _curAction);
_curAction = TA_GOTO;
_point.setAction(_curAction);
@ -207,7 +207,7 @@ void RMGfxEngine::doFrame(CORO_PARAM, bool bDrawLocation) {
// Options Menu
// ************
if (_bGUIOption) {
if (!_tony.InAction() && _bInput) {
if (!_tony.inAction() && _bInput) {
if ((_input.mouseLeftClicked() && _input.mousePos().x < 3 && _input.mousePos().y < 3)) {
CORO_INVOKE_1(openOptionScreen, 0);
goto SKIPCLICKSINISTRO;
@ -229,9 +229,9 @@ void RMGfxEngine::doFrame(CORO_PARAM, bool bDrawLocation) {
if (_input.mouseLeftClicked() && !_inter.active()) {
if (_curAction != TA_COMBINE)
CORO_INVOKE_3(_tony.MoveAndDoAction, _itemName.getHotspot(), _itemName.getSelectedItem(), _point.curAction());
CORO_INVOKE_3(_tony.moveAndDoAction, _itemName.getHotspot(), _itemName.getSelectedItem(), _point.curAction());
else if (_itemName.getSelectedItem() != NULL)
CORO_INVOKE_4(_tony.MoveAndDoAction, _itemName.getHotspot(), _itemName.getSelectedItem(), TA_COMBINE, _curActionObj);
CORO_INVOKE_4(_tony.moveAndDoAction, _itemName.getHotspot(), _itemName.getSelectedItem(), TA_COMBINE, _curActionObj);
if (_curAction == TA_COMBINE) {
_inv.endCombine();
@ -271,7 +271,7 @@ SKIPCLICKSINISTRO:
if (_bGUIInterface) {
if (_inter.released(_input.mousePos(), _curAction)) {
_point.setAction(_curAction);
CORO_INVOKE_3(_tony.MoveAndDoAction, _itemName.getHotspot(), _itemName.getSelectedItem(), _curAction);
CORO_INVOKE_3(_tony.moveAndDoAction, _itemName.getHotspot(), _itemName.getSelectedItem(), _curAction);
_curAction = TA_GOTO;
_point.setAction(_curAction);
@ -288,23 +288,23 @@ SKIPCLICKSINISTRO:
// Interface & Inventory
_inter.doFrame(_bigBuf, _input.mousePos());
_inv.doFrame(_bigBuf, _point, _input.mousePos(), (!_tony.InAction() && !_inter.active() && _bGUIInventory));
_inv.doFrame(_bigBuf, _point, _input.mousePos(), (!_tony.inAction() && !_inter.active() && _bGUIInventory));
}
// Animate Tony
CORO_INVOKE_2(_tony.DoFrame, &_bigBuf, _nCurLoc);
CORO_INVOKE_2(_tony.doFrame, &_bigBuf, _nCurLoc);
// Update screen scrolling to keep Tony in focus
if (_tony.MustUpdateScrolling() && _bLocationLoaded) {
RMPoint showThis = _tony.Position();
if (_tony.mustUpdateScrolling() && _bLocationLoaded) {
RMPoint showThis = _tony.position();
showThis.y -= 60;
_loc.UpdateScrolling(showThis);
_loc.updateScrolling(showThis);
}
if (_bLocationLoaded)
_tony.SetScrollPosition(_loc.ScrollPosition());
_tony.setScrollPosition(_loc.scrollPosition());
if ((!_tony.InAction() && _bInput) || _bAlwaysDrawMouse) {
if ((!_tony.inAction() && _bInput) || _bAlwaysDrawMouse) {
_point.setCoord(_input.mousePos());
_point.doFrame(&_bigBuf);
}
@ -362,17 +362,17 @@ void RMGfxEngine::itemIrq(uint32 dwItem, int nPattern, int nStatus) {
assert(GLOBALS.GfxEngine);
if (GLOBALS.GfxEngine->_bLocationLoaded) {
item = GLOBALS.GfxEngine->_loc.GetItemFromCode(dwItem);
item = GLOBALS.GfxEngine->_loc.getItemFromCode(dwItem);
if (item != NULL) {
if (nPattern != -1) {
if (GLOBALS.bPatIrqFreeze)
mainFreeze();
item->SetPattern(nPattern, true);
item->setPattern(nPattern, true);
if (GLOBALS.bPatIrqFreeze)
mainUnfreeze();
}
if (nStatus != -1)
item->SetStatus(nStatus);
item->setStatus(nStatus);
}
}
}
@ -384,12 +384,12 @@ void RMGfxEngine::initForNewLocation(int nLoc, RMPoint ptTonyStart, RMPoint star
start.y = ptTonyStart.y - RM_SY / 2;
}
_loc.SetScrollPosition(start);
_loc.setScrollPosition(start);
if (ptTonyStart.x == 0 && ptTonyStart.y == 0) {
} else {
_tony.SetPosition(ptTonyStart, nLoc);
_tony.SetScrollPosition(start);
_tony.setPosition(ptTonyStart, nLoc);
_tony.setScrollPosition(start);
}
_curAction = TA_GOTO;
@ -412,10 +412,10 @@ uint32 RMGfxEngine::loadLocation(int nLoc, RMPoint ptTonyStart, RMPoint start) {
for (i = 0; i < 5; i++) {
// Try the loading of the location
RMRes res(_nCurLoc);
if (!res.IsValid())
if (!res.isValid())
continue;
_loc.Load(res);
_loc.load(res);
initForNewLocation(nLoc, ptTonyStart, start);
bLoaded = true;
break;
@ -455,7 +455,7 @@ void RMGfxEngine::unloadLocation(CORO_PARAM, bool bDoOnExit, uint32 *result) {
_bLocationLoaded = false;
_bigBuf.clearOT();
_loc.Unload();
_loc.unload();
if (result != NULL)
*result = CORO_INVALID_PID_VALUE;
@ -503,7 +503,7 @@ void RMGfxEngine::init() {
// Initialise Tony
_tony.init();
_tony.LinkToBoxes(&_vm->_theBoxes);
_tony.linkToBoxes(&_vm->_theBoxes);
// Initialise the inventory and the interface
_inv.init();
@ -515,7 +515,7 @@ void RMGfxEngine::init() {
enableInput();
// Starting the game
_tony.ExecuteAction(20, 1, 0);
_tony.executeAction(20, 1, 0);
}
void RMGfxEngine::close(void) {
@ -523,7 +523,7 @@ void RMGfxEngine::close(void) {
_inter.close();
_inv.close();
_tony.Close();
_tony.close();
_point.close();
_input.close();
}
@ -579,7 +579,7 @@ void RMGfxEngine::saveState(const Common::String &fn, byte *curThumb, const Comm
uint size;
int i;
char buf[4];
RMPoint tp = _tony.Position();
RMPoint tp = _tony.position();
// Saving: MPAL variables, current location, and Tony inventory position
@ -627,9 +627,9 @@ void RMGfxEngine::saveState(const Common::String &fn, byte *curThumb, const Comm
delete[] state;
// boxes
size = _vm->_theBoxes.GetSaveStateSize();
size = _vm->_theBoxes.getSaveStateSize();
state = new byte[size];
_vm->_theBoxes.SaveState(state);
_vm->_theBoxes.saveState(state);
f->writeUint32LE(size);
f->write(state, size);
delete[] state;
@ -638,7 +638,7 @@ void RMGfxEngine::saveState(const Common::String &fn, byte *curThumb, const Comm
bool bStat;
// Saves the state of the shepherdess and show yourself
bStat = _tony.GetPastorella();
bStat = _tony.getPastorella();
f->writeByte(bStat);
bStat = _inter.getPalesati();
f->writeByte(bStat);
@ -765,7 +765,7 @@ void RMGfxEngine::loadState(CORO_PARAM, const Common::String &fn) {
_ctx->size = _ctx->f->readUint32LE();
_ctx->state = new byte[_ctx->size];
_ctx->f->read(_ctx->state, _ctx->size);
_vm->_theBoxes.LoadState(_ctx->state);
_vm->_theBoxes.loadState(_ctx->state);
delete[] _ctx->state;
}
@ -774,7 +774,7 @@ void RMGfxEngine::loadState(CORO_PARAM, const Common::String &fn) {
bool bStat = false;
bStat = _ctx->f->readByte();
_tony.SetPastorella(bStat);
_tony.setPastorella(bStat);
bStat = _ctx->f->readByte();
_inter.setPalesati(bStat);
@ -813,7 +813,7 @@ void RMGfxEngine::loadState(CORO_PARAM, const Common::String &fn) {
CORO_INVOKE_2(unloadLocation, false, NULL);
loadLocation(_ctx->loc, _ctx->tp, RMPoint(-1, -1));
_tony.SetPattern(RMTony::PAT_STANDRIGHT);
_tony.setPattern(RMTony::PAT_STANDRIGHT);
mainUnfreeze();
// On older versions, need to an enter action
@ -838,7 +838,7 @@ void RMGfxEngine::loadState(CORO_PARAM, const Common::String &fn) {
void RMGfxEngine::pauseSound(bool bPause) {
if (_bLocationLoaded)
_loc.PauseSound(bPause);
_loc.pauseSound(bPause);
}
void RMGfxEngine::initWipe(int type) {
@ -861,7 +861,7 @@ void RMGfxEngine::waitWipeEnd(CORO_PARAM) {
}
bool RMGfxEngine::canLoadSave() {
return _bInput && !_tony.InAction() && !_vm->getIsDemo();
return _bInput && !_tony.inAction() && !_vm->getIsDemo();
}
} // End of namespace Tony

4
engines/tony/input.cpp
View file

@ -34,7 +34,7 @@ namespace Tony {
RMInput::RMInput() {
// Setup mouse fields
_clampMouse = false;
_mousePos.Set(0, 0);
_mousePos.set(0, 0);
_leftButton = _rightButton = false;
_leftClickMouse = _leftReleaseMouse = false;
_rightClickMouse = _rightReleaseMouse = false;
@ -60,7 +60,7 @@ void RMInput::poll(void) {
case Common::EVENT_LBUTTONUP:
case Common::EVENT_RBUTTONDOWN:
case Common::EVENT_RBUTTONUP:
_mousePos.Set(_event.mouse.x, _event.mouse.y);
_mousePos.set(_event.mouse.x, _event.mouse.y);
if (_event.type == Common::EVENT_LBUTTONDOWN) {
_leftButton = true;

106
engines/tony/inventory.cpp
View file

@ -97,47 +97,47 @@ void RMInventory::init(void) {
RMRes res(curres);
RMDataStream ds;
assert(res.IsValid());
assert(res.isValid());
// Initialise the MPAL inventory item by reading it in.
_items[i].icon.SetInitCurPattern(false);
ds.OpenBuffer(res);
_items[i].icon.setInitCurPattern(false);
ds.openBuffer(res);
ds >> _items[i].icon;
ds.Close();
ds.close();
// Puts in the default pattern 1
_items[i].pointer = NULL;
_items[i].status = 1;
_items[i].icon.SetPattern(1);
_items[i].icon.setPattern(1);
_items[i].icon.doFrame(this, false);
curres++;
if (i == 0 || i == 28 || i == 29)
continue;
_items[i].pointer = new RMGfxSourceBuffer8RLEByteAA[_items[i].icon.NumPattern()];
_items[i].pointer = new RMGfxSourceBuffer8RLEByteAA[_items[i].icon.numPattern()];
for (j = 0; j < _items[i].icon.NumPattern(); j++) {
for (j = 0; j < _items[i].icon.numPattern(); j++) {
RMResRaw raw(curres);
assert(raw.IsValid());
assert(raw.isValid());
_items[i].pointer[j].init((const byte *)raw, raw.Width(), raw.Height(), true);
_items[i].pointer[j].init((const byte *)raw, raw.width(), raw.height(), true);
curres++;
}
}
_items[28].icon.SetPattern(1);
_items[29].icon.SetPattern(1);
_items[28].icon.setPattern(1);
_items[29].icon.setPattern(1);
// Download interface
RMDataStream ds;
RMRes res(RES_I_MINIINTER);
assert(res.IsValid());
ds.OpenBuffer(res);
assert(res.isValid());
ds.openBuffer(res);
ds >> miniInterface;
miniInterface.SetPattern(1);
ds.Close();
miniInterface.setPattern(1);
ds.close();
// Create the text for hints on the mini interface
_hints[0].setAlignType(RMText::HCENTER, RMText::VTOP);
@ -202,11 +202,11 @@ void RMInventory::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *pr
if (_state == SELECTING) {
if (!GLOBALS.bCfgInvUp) {
_ctx->pos.Set((_nSelectObj + 1) * 64 - 20, RM_SY - 113);
_ctx->pos2.Set((_nSelectObj + 1) * 64 + 34, RM_SY - 150);
_ctx->pos.set((_nSelectObj + 1) * 64 - 20, RM_SY - 113);
_ctx->pos2.set((_nSelectObj + 1) * 64 + 34, RM_SY - 150);
} else {
_ctx->pos.Set((_nSelectObj + 1) * 64 - 20, 72 - 4); // The brown part is at the top :(
_ctx->pos2.Set((_nSelectObj + 1) * 64 + 34, 119 - 4);
_ctx->pos.set((_nSelectObj + 1) * 64 - 20, 72 - 4); // The brown part is at the top :(
_ctx->pos2.set((_nSelectObj + 1) * 64 + 34, 119 - 4);
}
_ctx->p = new RMGfxPrimitive(prim->_task, _ctx->pos);
@ -264,7 +264,7 @@ void RMInventory::addItem(int code) {
g_system->lockMutex(_csModifyInterface);
if (_curPos + 8 == _nInv) {
// Break through the inventory! On the flashing pattern
_items[28].icon.SetPattern(2);
_items[28].icon.setPattern(2);
}
_inv[_nInv++] = code - 10000;
@ -281,7 +281,7 @@ void RMInventory::changeItemStatus(uint32 code, uint32 dwStatus) {
error("Specified object code is not valid");
} else {
g_system->lockMutex(_csModifyInterface);
_items[code - 10000].icon.SetPattern(dwStatus);
_items[code - 10000].icon.setPattern(dwStatus);
_items[code - 10000].status = dwStatus;
prepare();
@ -355,12 +355,12 @@ bool RMInventory::leftClick(const RMPoint &mpos, int &nCombineObj) {
if (_curPos + 8 >= _nInv) {
_bBlinkingRight = false;
_items[28].icon.SetPattern(1);
_items[28].icon.setPattern(1);
}
if (_curPos > 0) {
_bBlinkingLeft = true;
_items[29].icon.SetPattern(2);
_items[29].icon.setPattern(2);
}
prepare();
@ -376,12 +376,12 @@ bool RMInventory::leftClick(const RMPoint &mpos, int &nCombineObj) {
if (_curPos == 0) {
_bBlinkingLeft = false;
_items[29].icon.SetPattern(1);
_items[29].icon.setPattern(1);
}
if (_curPos + 8 < _nInv) {
_bBlinkingRight = true;
_items[28].icon.SetPattern(2);
_items[28].icon.setPattern(2);
}
prepare();
@ -420,12 +420,12 @@ void RMInventory::rightClick(const RMPoint &mpos) {
if (_curPos + 8 <= _nInv) {
_bBlinkingRight = false;
_items[28].icon.SetPattern(1);
_items[28].icon.setPattern(1);
}
if (_curPos > 0) {
_bBlinkingLeft = true;
_items[29].icon.SetPattern(2);
_items[29].icon.setPattern(2);
}
prepare();
@ -441,12 +441,12 @@ void RMInventory::rightClick(const RMPoint &mpos) {
if (_curPos == 0) {
_bBlinkingLeft = false;
_items[29].icon.SetPattern(1);
_items[29].icon.setPattern(1);
}
if (_curPos + 8 < _nInv) {
_bBlinkingRight = true;
_items[28].icon.SetPattern(2);
_items[28].icon.setPattern(2);
}
prepare();
@ -495,24 +495,24 @@ void RMInventory::doFrame(RMGfxTargetBuffer &bigBuf, RMPointer &ptr, RMPoint mpo
if ((_state == CLOSING || _state == OPENING || _state == OPENED) && checkPointInside(mpos)) {
if (mpos.x > RM_SX - 64) {
if (_curPos + 8 < _nInv && !_bBlinkingRight) {
_items[28].icon.SetPattern(3);
_items[28].icon.setPattern(3);
_bBlinkingRight = true;
bNeedRedraw = true;
}
} else if (_bBlinkingRight) {
_items[28].icon.SetPattern(2);
_items[28].icon.setPattern(2);
_bBlinkingRight = false;
bNeedRedraw = true;
}
if (mpos.x < 64) {
if (_curPos > 0 && !_bBlinkingLeft) {
_items[29].icon.SetPattern(3);
_items[29].icon.setPattern(3);
_bBlinkingLeft = true;
bNeedRedraw = true;
}
} else if (_bBlinkingLeft) {
_items[29].icon.SetPattern(2);
_items[29].icon.setPattern(2);
_bBlinkingLeft = false;
bNeedRedraw = true;
}
@ -633,28 +633,28 @@ void RMInventory::doFrame(RMGfxTargetBuffer &bigBuf, RMPointer &ptr, RMPoint mpo
if (mpos.y > starty && mpos.y < starty + 45) {
if (mpos.x > startx && mpos.x < startx + 40) {
if (miniAction != 1) {
miniInterface.SetPattern(2);
miniInterface.setPattern(2);
miniAction = 1;
_vm->playUtilSFX(1);
}
} else if (mpos.x >= startx + 40 && mpos.x < startx + 80) {
if (miniAction != 2) {
miniInterface.SetPattern(3);
miniInterface.setPattern(3);
miniAction = 2;
_vm->playUtilSFX(1);
}
} else if (mpos.x >= startx + 80 && mpos.x < startx + 108) {
if (miniAction != 3) {
miniInterface.SetPattern(4);
miniInterface.setPattern(4);
miniAction = 3;
_vm->playUtilSFX(1);
}
} else {
miniInterface.SetPattern(1);
miniInterface.setPattern(1);
miniAction = 0;
}
} else {
miniInterface.SetPattern(1);
miniInterface.setPattern(1);
miniAction = 0;
}
@ -729,19 +729,19 @@ int RMInventory::loadState(byte *state) {
if (i < _nItems) {
_items[i].status = x;
_items[i].icon.SetPattern(x);
_items[i].icon.setPattern(x);
}
}
_curPos = 0;
_bCombining = false;
_items[29].icon.SetPattern(1);
_items[29].icon.setPattern(1);
if (_nInv > 8)
_items[28].icon.SetPattern(2);
_items[28].icon.setPattern(2);
else
_items[28].icon.SetPattern(1);
_items[28].icon.setPattern(1);
prepare();
drawOT(Common::nullContext);
@ -774,7 +774,7 @@ int RMInterface::onWhichBox(RMPoint pt) {
// Find the verb
for (i = 0; i < max; i++)
if (_hotbbox[i].PtInRect(pt))
if (_hotbbox[i].ptInRect(pt))
return i;
// Found no verb
@ -788,13 +788,13 @@ void RMInterface::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *pr
CORO_BEGIN_CODE(_ctx);
prim->Dst().TopLeft() = _openStart;
prim->Dst().topLeft() = _openStart;
CORO_INVOKE_2(RMGfxSourceBuffer8RLEByte::draw, bigBuf, prim);
// Check if there is a draw hot zone
_ctx->h = onWhichBox(_mpos);
if (_ctx->h != -1) {
prim->Dst().TopLeft() = _openStart;
prim->Dst().topLeft() = _openStart;
CORO_INVOKE_2(_hotzone[_ctx->h].draw, bigBuf, prim);
if (_lastHotZone != _ctx->h) {
@ -803,7 +803,7 @@ void RMInterface::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *pr
}
if (GLOBALS.bCfgInterTips) {
prim->Dst().TopLeft() = _openStart + RMPoint(70, 177);
prim->Dst().topLeft() = _openStart + RMPoint(70, 177);
CORO_INVOKE_2(_hints[_ctx->h].draw, bigBuf, prim);
}
} else
@ -896,21 +896,21 @@ void RMInterface::init(void) {
setPriority(191);
RMGfxSourceBuffer::init(inter, inter.Width(), inter.Height());
RMGfxSourceBuffer::init(inter, inter.width(), inter.height());
loadPaletteWA(RES_I_INTERPAL);
for (i = 0; i < 5; i++) {
RMResRaw part(RES_I_INTERP1 + i);
_hotzone[i].init(part, part.Width(), part.Height());
_hotzone[i].init(part, part.width(), part.height());
_hotzone[i].loadPaletteWA(pal);
}
_hotbbox[0].SetRect(126, 123, 159, 208); // Take
_hotbbox[1].SetRect(90, 130, 125, 186); // About
_hotbbox[2].SetRect(110, 60, 152, 125);
_hotbbox[3].SetRect(56, 51, 93, 99);
_hotbbox[4].SetRect(51, 105, 82, 172);
_hotbbox[0].setRect(126, 123, 159, 208); // Take
_hotbbox[1].setRect(90, 130, 125, 186); // About
_hotbbox[2].setRect(110, 60, 152, 125);
_hotbbox[3].setRect(56, 51, 93, 99);
_hotbbox[4].setRect(51, 105, 82, 172);
_hints[0].setAlignType(RMText::HRIGHT, RMText::VTOP);
_hints[1].setAlignType(RMText::HRIGHT, RMText::VTOP);

4
engines/tony/inventory.h
View file

@ -123,11 +123,11 @@ public:
// Add an item to the inventory
void addItem(int code);
RMInventory &operator+=(RMItem *item) {
addItem(item->MpalCode());
addItem(item->mpalCode());
return *this;
}
RMInventory &operator+=(RMItem &item) {
addItem(item.MpalCode());
addItem(item.mpalCode());
return *this;
}
RMInventory &operator+=(int code) {

1115
engines/tony/loc.cpp
View file

File diff suppressed because it is too large Load diff

322
engines/tony/loc.h
View file

@ -59,7 +59,7 @@ typedef enum {
*/
class RMPalette {
public:
byte m_data[1024];
byte _data[1024];
public:
friend RMDataStream &operator>>(RMDataStream &ds, RMPalette &pal);
@ -71,9 +71,9 @@ public:
*/
class RMSfx {
public:
RMString m_name;
FPSFX *m_fx;
bool m_bPlayingLoop;
RMString _name;
FPSFX *_fx;
bool _bPlayingLoop;
public:
RMSfx();
@ -81,12 +81,12 @@ public:
friend RMDataStream &operator>>(RMDataStream &ds, RMSfx &sfx);
void Play(bool bLoop = false);
void SetVolume(int vol);
void Pause(bool bPause);
void Stop(void);
void play(bool bLoop = false);
void setVolume(int vol);
void pause(bool bPause);
void stop(void);
void ReadFromStream(RMDataStream &ds, bool bLOX = false);
void readFromStream(RMDataStream &ds, bool bLOX = false);
};
@ -108,38 +108,38 @@ public:
// Class slot
class RMSlot {
private:
RMPoint m_pos; // Child co-ordinates
RMPoint _pos; // Child co-ordinates
public:
RMSlotType m_type;
int m_data;
byte m_flag;
RMSlotType _type;
int _data;
byte _flag;
public:
friend RMDataStream &operator>>(RMDataStream &ds, RMSlot &slot);
RMPoint Pos() {
return m_pos;
RMPoint pos() {
return _pos;
}
void ReadFromStream(RMDataStream &ds, bool bLOX = false);
void readFromStream(RMDataStream &ds, bool bLOX = false);
};
public:
RMString m_name;
RMString _name;
private:
int m_speed;
RMPoint m_pos; // Parent coordinates
RMPoint m_curPos; // Parent + child coordinates
int m_bLoop;
int m_nSlots;
int m_nCurSlot;
int m_nCurSprite;
int _speed;
RMPoint _pos; // Parent coordinates
RMPoint _curPos; // Parent + child coordinates
int _bLoop;
int _nSlots;
int _nCurSlot;
int _nCurSprite;
RMSlot *m_slots;
RMSlot *_slots;
uint32 m_nStartTime;
uint32 _nStartTime;
public:
RMPattern();
@ -148,24 +148,24 @@ public:
friend RMDataStream &operator>>(RMDataStream &ds, RMPattern &pat);
// A warning that the pattern now and the current
int Init(RMSfx *sfx, bool bPlayP0 = false, byte *bFlag = NULL);
int init(RMSfx *sfx, bool bPlayP0 = false, byte *bFlag = NULL);
// Update the pattern, checking to see if it's time to change slot and executing
// any associated commands
int Update(uint32 hEndPattern, byte &bFlag, RMSfx *sfx);
int update(uint32 hEndPattern, byte &bFlag, RMSfx *sfx);
// Stop a sound effect
void StopSfx(RMSfx *sfx);
void stopSfx(RMSfx *sfx);
// Reads the position of the pattern
RMPoint Pos() {
return m_curPos;
RMPoint pos() {
return _curPos;
}
void ReadFromStream(RMDataStream &ds, bool bLOX = false);
void readFromStream(RMDataStream &ds, bool bLOX = false);
private:
void UpdateCoord(void);
void updateCoord(void);
};
@ -174,24 +174,24 @@ private:
*/
class RMSprite : public RMGfxTask {
public:
RMString m_name;
RMRect m_rcBox;
RMString _name;
RMRect _rcBox;
protected:
RMGfxSourceBuffer *m_buf;
RMGfxSourceBuffer *_buf;
public:
RMSprite();
virtual ~RMSprite();
void Init(RMGfxSourceBuffer *buf);
void init(RMGfxSourceBuffer *buf);
friend RMDataStream &operator>>(RMDataStream &ds, RMSprite &sprite);
virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
void SetPalette(byte *lpBuf);
void GetSizeFromStream(RMDataStream &ds, int *dimx, int *dimy);
void setPalette(byte *lpBuf);
void getSizeFromStream(RMDataStream &ds, int *dimx, int *dimy);
void LOXGetSizeFromStream(RMDataStream &ds, int *dimx, int *dimy);
void ReadFromStream(RMDataStream &ds, bool bLOX = false);
void readFromStream(RMDataStream &ds, bool bLOX = false);
};
@ -200,42 +200,42 @@ public:
*/
class RMItem : public RMGfxTask {
public:
RMString m_name;
RMString _name;
protected:
int m_z;
RMPoint m_pos; // Coordinate nonno
RMColorMode m_cm;
RMPoint m_curScroll;
int _z;
RMPoint _pos; // Coordinate nonno
RMColorMode _cm;
RMPoint _curScroll;
byte m_FX;
byte m_FXparm;
byte _FX;
byte _FXparm;
virtual int GetCurPattern() {
return m_nCurPattern;
virtual int getCurPattern() {
return _nCurPattern;
}
private:
int m_nCurPattern;
int m_mpalCode;
RMPoint m_hot;
RMRect m_rcBox;
int m_nSprites, m_nSfx, m_nPatterns;
byte m_bPal;
RMPalette m_pal;
int _nCurPattern;
int _mpalCode;
RMPoint _hot;
RMRect _rcBox;
int _nSprites, _nSfx, _nPatterns;
byte _bPal;
RMPalette _pal;
RMSprite *m_sprites;
RMSfx *m_sfx;
RMPattern *m_patterns;
RMSprite *_sprites;
RMSfx *_sfx;
RMPattern *_patterns;
byte m_bCurFlag;
int m_nCurSprite;
bool m_bIsActive;
uint32 m_hEndPattern;
bool m_bInitCurPattern;
byte _bCurFlag;
int _nCurSprite;
bool _bIsActive;
uint32 _hEndPattern;
bool _bInitCurPattern;
public:
RMPoint CalculatePos(void);
RMPoint calculatePos(void);
public:
RMItem();
@ -248,7 +248,7 @@ public:
bool doFrame(RMGfxTargetBuffer *bigBuf, bool bAddToList = true);
// Sets the current scrolling position
void SetScrollPosition(const RMPoint &scroll);
void setScrollPosition(const RMPoint &scroll);
// Overloading of check whether to remove from active list
virtual void removeThis(CORO_PARAM, bool &result);
@ -258,54 +258,54 @@ public:
// Overloaded priority: it's based on Z ordering
virtual int priority() {
return m_z;
return _z;
}
// Pattern number
int NumPattern() {
return m_nPatterns;
int numPattern() {
return _nPatterns;
}
// Set anew animation pattern, changing abruptly from the current
virtual void SetPattern(int nPattern, bool bPlayP0 = false);
virtual void setPattern(int nPattern, bool bPlayP0 = false);
// Set a new status
void SetStatus(int nStatus);
void setStatus(int nStatus);
bool IsIn(const RMPoint &pt, int *size = NULL);
RMPoint Hotspot() {
return m_hot;
bool isIn(const RMPoint &pt, int *size = NULL);
RMPoint hotspot() {
return _hot;
}
bool GetName(RMString &name);
int MpalCode() {
return m_mpalCode;
bool getName(RMString &name);
int mpalCode() {
return _mpalCode;
}
// Unload
void Unload(void);
void unload(void);
// Wait for the end of the current pattern
void WaitForEndPattern(CORO_PARAM, uint32 hCustomSkip = CORO_INVALID_PID_VALUE);
void waitForEndPattern(CORO_PARAM, uint32 hCustomSkip = CORO_INVALID_PID_VALUE);
// Sets a new hotspot fro the object
void ChangeHotspot(const RMPoint &pt);
void changeHotspot(const RMPoint &pt);
void SetInitCurPattern(bool status) {
m_bInitCurPattern = status;
void setInitCurPattern(bool status) {
_bInitCurPattern = status;
}
void PlaySfx(int nSfx);
void playSfx(int nSfx);
void ReadFromStream(RMDataStream &ds, bool bLOX = false);
void readFromStream(RMDataStream &ds, bool bLOX = false);
void PauseSound(bool bPause);
void pauseSound(bool bPause);
protected:
// Create a primitive that has as it's task this item
virtual RMGfxPrimitive *NewItemPrimitive();
virtual RMGfxPrimitive *newItemPrimitive();
// Allocate memory for the sprites
virtual RMGfxSourceBuffer *NewItemSpriteBuffer(int dimx, int dimy, bool bPreRLE);
virtual RMGfxSourceBuffer *newItemSpriteBuffer(int dimx, int dimy, bool bPreRLE);
};
@ -330,7 +330,7 @@ public:
bool bReversed;
private:
void ReadFromStream(RMDataStream &ds);
void readFromStream(RMDataStream &ds);
public:
friend RMDataStream &operator>>(RMDataStream &ds, RMBox &box);
@ -343,47 +343,47 @@ public:
RMBox *boxes;
private:
void ReadFromStream(RMDataStream &ds);
void readFromStream(RMDataStream &ds);
public:
RMBoxLoc();
virtual ~RMBoxLoc();
friend RMDataStream &operator >>(RMDataStream &ds, RMBoxLoc &bl);
void RecalcAllAdj(void);
void recalcAllAdj(void);
};
#define GAME_BOXES_SIZE 200
class RMGameBoxes {
protected:
RMBoxLoc *m_allBoxes[GAME_BOXES_SIZE];
int m_nLocBoxes;
RMBoxLoc *_allBoxes[GAME_BOXES_SIZE];
int _nLocBoxes;
public:
RMGameBoxes();
~RMGameBoxes();
void Init(void);
void Close(void);
void init(void);
void close(void);
// Get binding boxes for a given location
RMBoxLoc *GetBoxes(int nLoc);
int GetLocBoxesCount() const { return m_nLocBoxes; }
RMBoxLoc *getBoxes(int nLoc);
int getLocBoxesCount() const { return _nLocBoxes; }
// Return the box which contains a given point
int WhichBox(int nLoc, const RMPoint &pt);
int whichBox(int nLoc, const RMPoint &pt);
// Check whether a point is inside a given box
bool IsInBox(int nLoc, int nBox, const RMPoint &pt);
bool isInBox(int nLoc, int nBox, const RMPoint &pt);
// Change the status of a box
void ChangeBoxStatus(int nLoc, int nBox, int status);
void changeBoxStatus(int nLoc, int nBox, int status);
// Save state handling
int GetSaveStateSize(void);
void SaveState(byte *buf);
void LoadState(byte *buf);
int getSaveStateSize(void);
void saveState(byte *buf);
void loadState(byte *buf);
};
class RMCharacter : protected RMItem {
@ -426,21 +426,21 @@ private:
bool bMovingWithoutMinpath;
RMGameBoxes *theBoxes;
RMPoint m_fixedScroll;
RMPoint _fixedScroll;
private:
int InWhichBox(const RMPoint &pt);
int inWhichBox(const RMPoint &pt);
short FindPath(short source, short destination);
RMPoint Searching(char UP, char DOWN, char RIGHT, char LEFT, RMPoint punto);
RMPoint NearestPoint(const RMPoint &punto);
short findPath(short source, short destination);
RMPoint searching(char UP, char DOWN, char RIGHT, char LEFT, RMPoint punto);
RMPoint nearestPoint(const RMPoint &punto);
void GoTo(CORO_PARAM, RMPoint destcoord, bool bReversed = false);
short ScanLine(const RMPoint &punto);
RMPoint InvScanLine(const RMPoint &punto);
RMPoint NearestHotSpot(int sourcebox, int destbox);
void goTo(CORO_PARAM, RMPoint destcoord, bool bReversed = false);
short scanLine(const RMPoint &punto);
RMPoint invScanLine(const RMPoint &punto);
RMPoint nearestHotSpot(int sourcebox, int destbox);
void NewBoxEntered(int nBox);
void newBoxEntered(int nBox);
protected:
bool bMoving;
@ -452,42 +452,42 @@ public:
RMCharacter();
virtual ~RMCharacter();
void LinkToBoxes(RMGameBoxes *theBoxes);
void linkToBoxes(RMGameBoxes *theBoxes);
virtual void removeThis(CORO_PARAM, bool &result);
// Update the position of a character
void DoFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int loc);
void doFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int loc);
// Overloaded draw
virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
// TRUE if you just stopped
bool EndOfPath() {
bool endOfPath() {
return bEndOfPath;
}
// Change the pattern of a character to STOP
virtual void Stop(CORO_PARAM);
virtual void stop(CORO_PARAM);
// Check if the character is moving
bool IsMoving() {
bool isMoving() {
return bMoving;
}
// Move the character to a certain position
void Move(CORO_PARAM, RMPoint pt, bool *result = NULL);
void move(CORO_PARAM, RMPoint pt, bool *result = NULL);
// Place the character in a certain position WITHOUT moving
void SetPosition(const RMPoint &pt, int newloc = -1);
void setPosition(const RMPoint &pt, int newloc = -1);
// Wait for the end of movement
void WaitForEndMovement(CORO_PARAM);
void waitForEndMovement(CORO_PARAM);
void SetFixedScroll(const RMPoint &fix) {
m_fixedScroll = fix;
void setFixedScroll(const RMPoint &fix) {
_fixedScroll = fix;
}
void SetSpeed(int speed) {
void setSpeed(int speed) {
curSpeed = speed;
}
};
@ -495,26 +495,26 @@ public:
class RMWipe : public RMGfxTask {
private:
bool m_bFading;
bool m_bEndFade;
bool m_bUnregister;
uint32 m_hUnregistered;
int m_nFadeStep;
uint32 m_hEndOfFade;
bool m_bMustRegister;
bool _bFading;
bool _bEndFade;
bool _bUnregister;
uint32 _hUnregistered;
int _nFadeStep;
uint32 _hEndOfFade;
bool _bMustRegister;
RMItem m_wip0r;
RMItem _wip0r;
public:
RMWipe();
virtual ~RMWipe();
void DoFrame(RMGfxTargetBuffer &bigBuf);
void doFrame(RMGfxTargetBuffer &bigBuf);
virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
void InitFade(int type);
void CloseFade(void);
void WaitForFadeEnd(CORO_PARAM);
void initFade(int type);
void closeFade(void);
void waitForFadeEnd(CORO_PARAM);
virtual void Unregister(void);
virtual void removeThis(CORO_PARAM, bool &result);
@ -527,17 +527,17 @@ public:
*/
class RMLocation : public RMGfxTaskSetPrior {
public:
RMString m_name; // Name
RMString _name; // Name
private:
RMColorMode m_cmode; // Color mode
RMGfxSourceBuffer *m_buf; // Location picture
RMColorMode _cmode; // Color mode
RMGfxSourceBuffer *_buf; // Location picture
int m_nItems; // Number of objects
RMItem *m_items; // Objects
int _nItems; // Number of objects
RMItem *_items; // Objects
RMPoint m_curScroll; // Current scroll position
RMPoint m_fixedScroll;
RMPoint _curScroll; // Current scroll position
RMPoint _fixedScroll;
public:
// @@@@@@@@@@@@@@@@@@@@@@@
@ -556,14 +556,14 @@ public:
virtual ~RMLocation();
// Load variations
bool Load(const char *lpszFileName);
bool Load(Common::File &file);
bool Load(const byte *buf);
bool Load(RMDataStream &ds);
bool LoadLOX(RMDataStream &ds);
bool load(const char *lpszFileName);
bool load(Common::File &file);
bool load(const byte *buf);
bool load(RMDataStream &ds);
bool loadLOX(RMDataStream &ds);
// Unload
void Unload(void);
void unload(void);
// Overloaded draw
virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
@ -572,27 +572,27 @@ public:
void doFrame(RMGfxTargetBuffer *bigBuf);
// Return the item at a given point
RMItem *WhichItemIsIn(const RMPoint &pt);
RMItem *whichItemIsIn(const RMPoint &pt);
// Return the item based on it's MPAL code
RMItem *GetItemFromCode(uint32 dwCode);
RMItem *getItemFromCode(uint32 dwCode);
// Set the current scroll position
void SetScrollPosition(const RMPoint &scroll);
void setScrollPosition(const RMPoint &scroll);
// Sets an additinal offset for scrolling
void SetFixedScroll(const RMPoint &scroll);
void setFixedScroll(const RMPoint &scroll);
// Update the scrolling coordinates to display the specified point
void UpdateScrolling(const RMPoint &ptShowThis);
void updateScrolling(const RMPoint &ptShowThis);
// Read the current scroll position
RMPoint ScrollPosition() {
return m_curScroll;
RMPoint scrollPosition() {
return _curScroll;
}
// Pause sound
void PauseSound(bool bPause);
void pauseSound(bool bPause);
};
@ -606,21 +606,21 @@ private:
int nPeriods;
private:
void ParseMessage(void);
void parseMessage(void);
public:
RMMessage();
RMMessage(uint32 dwId);
virtual ~RMMessage();
void Load(uint32 dwId);
bool IsValid() {
void load(uint32 dwId);
bool isValid() {
return lpMessage != NULL;
}
int NumPeriods() {
int numPeriods() {
return nPeriods;
}
char *Period(int num) {
char *period(int num) {
return lpPeriods[num];
}
char *operator[](int num) {

36
engines/tony/mpal/mpalutils.cpp
View file

@ -37,42 +37,42 @@ namespace MPAL {
* @param resId MPAL resource to open
*/
RMRes::RMRes(uint32 resID) {
m_h = _vm->_resUpdate.QueryResource(resID);
if (m_h == NULL)
m_h = mpalQueryResource(resID);
if (m_h != NULL)
m_buf = (byte *)GlobalLock(m_h);
_h = _vm->_resUpdate.queryResource(resID);
if (_h == NULL)
_h = mpalQueryResource(resID);
if (_h != NULL)
_buf = (byte *)GlobalLock(_h);
}
/**
* Destructor
*/
RMRes::~RMRes() {
if (m_h != NULL) {
GlobalUnlock(m_h);
GlobalFree(m_h);
if (_h != NULL) {
GlobalUnlock(_h);
GlobalFree(_h);
}
}
/**
* Returns a pointer to the resource
*/
const byte *RMRes::DataPointer() {
return m_buf;
const byte *RMRes::dataPointer() {
return _buf;
}
/**
* Returns a pointer to the resource
*/
RMRes::operator const byte *() {
return DataPointer();
return dataPointer();
}
/**
* Returns the size of the resource
*/
unsigned int RMRes::Size() {
return GlobalSize(m_h);
unsigned int RMRes::size() {
return GlobalSize(_h);
}
/****************************************************************************\
@ -86,19 +86,19 @@ RMResRaw::~RMResRaw() {
}
const byte *RMResRaw::DataPointer() {
return m_buf + 8;
return _buf + 8;
}
RMResRaw::operator const byte *() {
return DataPointer();
}
int RMResRaw::Width() {
return READ_LE_UINT16(m_buf + 4);
int RMResRaw::width() {
return READ_LE_UINT16(_buf + 4);
}
int RMResRaw::Height() {
return READ_LE_UINT16(m_buf + 6);
int RMResRaw::height() {
return READ_LE_UINT16(_buf + 6);
}
} // end of namespace MPAL

14
engines/tony/mpal/mpalutils.h
View file

@ -33,17 +33,17 @@ namespace MPAL {
class RMRes {
protected:
HGLOBAL m_h;
byte *m_buf;
HGLOBAL _h;
byte *_buf;
public:
RMRes(uint32 resID);
virtual ~RMRes();
// Attributes
unsigned int Size();
const byte *DataPointer();
bool IsValid() { return m_h != NULL; }
unsigned int size();
const byte *dataPointer();
bool isValid() { return _h != NULL; }
// Casting for access to data
operator const byte*();
@ -57,8 +57,8 @@ public:
const byte *DataPointer();
operator const byte*();
int Width();
int Height();
int width();
int height();
};
} // end of namespace MPAL

6
engines/tony/tony.cpp
View file

@ -133,7 +133,7 @@ Common::ErrorCode TonyEngine::init() {
return Common::kUnknownError;
// Initialise the update resources
_resUpdate.Init("ROASTED.MPU");
_resUpdate.init("ROASTED.MPU");
// Initialise the music
initMusic();
@ -143,7 +143,7 @@ Common::ErrorCode TonyEngine::init() {
return Common::kReadingFailed;
// Initialise the boxes
_theBoxes.Init();
_theBoxes.init();
// Link to the custom graphics engine
_theEngine.initCustomDll();
@ -570,7 +570,7 @@ void TonyEngine::play(void) {
void TonyEngine::close(void) {
closeMusic();
CoroScheduler.closeEvent(_hEndOfFrame);
_theBoxes.Close();
_theBoxes.close();
_theEngine.close();
_window.close();
delete[] _curThumbnail;

701
engines/tony/tonychar.cpp
View file

File diff suppressed because it is too large Load diff

112
engines/tony/tonychar.h
View file

@ -81,36 +81,36 @@ public:
};
private:
bool m_bShow;
bool m_bShowOmbra;
bool m_bCorpoDavanti;
RMGfxSourceBuffer8AB m_ombra;
bool m_bActionPending;
RMItem *m_ActionItem;
int m_Action;
int m_ActionParm;
static bool m_bAction;
bool _bShow;
bool _bShowOmbra;
bool _bCorpoDavanti;
RMGfxSourceBuffer8AB _ombra;
bool _bActionPending;
RMItem *_ActionItem;
int _Action;
int _ActionParm;
static bool _bAction;
bool m_bPastorella;
bool _bPastorella;
bool m_bIsStaticTalk;
bool m_bIsTalking;
int m_nPatB4Talking;
TALKTYPE m_nTalkType;
DIRECTION m_TalkDirection;
RMPoint m_nBodyOffset;
bool _bIsStaticTalk;
bool _bIsTalking;
int _nPatB4Talking;
TALKTYPE _nTalkType;
DIRECTION _TalkDirection;
RMPoint _nBodyOffset;
int m_nTimeLastStep;
int _nTimeLastStep;
RMItem m_body;
RMItem _body;
uint32 hActionThread;
protected:
// Overload of the allocation allocation of sprites
virtual RMGfxSourceBuffer *NewItemSpriteBuffer(int dimx, int dimy, bool bPreRLE);
virtual RMGfxSourceBuffer *newItemSpriteBuffer(int dimx, int dimy, bool bPreRLE);
// Watch thread which waits for the end of an action
static void WaitEndOfAction(CORO_PARAM, const void *param);
static void waitEndOfAction(CORO_PARAM, const void *param);
public:
enum PATTERNS {
@ -365,87 +365,87 @@ public:
void init(void);
// Free all memory
void Close(void);
void close(void);
// Tony makes a frame, updating the movement, etc.
void DoFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc);
void doFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc);
// Draw method, which controls chararacter display
virtual void draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim);
// Show or hide
void Show(void);
void Hide(bool bShowOmbra = false);
void show(void);
void hide(bool bShowOmbra = false);
// Move and make an action, if necessary
void MoveAndDoAction(CORO_PARAM, RMPoint dst, RMItem *item, int nAction, int nActionParm = 0);
void moveAndDoAction(CORO_PARAM, RMPoint dst, RMItem *item, int nAction, int nActionParm = 0);
// Tony stops (on the right side with respect to any subject)
virtual void Stop(CORO_PARAM);
void StopNoAction(CORO_PARAM);
virtual void stop(CORO_PARAM);
void stopNoAction(CORO_PARAM);
// Set a pattern
void SetPattern(int npatt, bool bPlayP0 = false);
void setPattern(int npatt, bool bPlayP0 = false);
// Reads the current pattern
int GetCurPattern();
int getCurPattern();
// Waits until the end of a pattern
void WaitForEndPattern(CORO_PARAM, uint32 hCustomSkip = CORO_INVALID_PID_VALUE) {
RMCharacter::WaitForEndPattern(coroParam, hCustomSkip);
void waitForEndPattern(CORO_PARAM, uint32 hCustomSkip = CORO_INVALID_PID_VALUE) {
RMCharacter::waitForEndPattern(coroParam, hCustomSkip);
}
// Check if currently in an action
bool InAction() {
return (m_bActionPending && m_Action != 0) | m_bAction;
bool inAction() {
return (_bActionPending && _Action != 0) | _bAction;
}
// Check if there needs to be an update for scrolling movement
bool MustUpdateScrolling() {
return ((!InAction()) || (IsMoving()));
bool mustUpdateScrolling() {
return ((!inAction()) || (isMoving()));
}
// Returns Tony's position
RMPoint Position() {
return m_pos;
RMPoint position() {
return _pos;
}
// Set the scrolling position
void SetScrollPosition(const RMPoint &pt) {
RMCharacter::SetScrollPosition(pt);
void setScrollPosition(const RMPoint &pt) {
RMCharacter::setScrollPosition(pt);
}
// Set the take animation
void Take(int nWhere, int nPart);
void Put(int nWhere, int nPart);
void take(int nWhere, int nPart);
void put(int nWhere, int nPart);
// Start or End Talk
bool StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &bodyStartPat,
bool startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &bodyStartPat,
int &headLoopPat, int &bodyLoopPat);
void StartTalk(CORO_PARAM, TALKTYPE nTalkType);
bool EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPat, int &finalPat, bool &bStatic);
void EndTalk(CORO_PARAM);
void startTalk(CORO_PARAM, TALKTYPE nTalkType);
bool endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPat, int &finalPat, bool &bStatic);
void endTalk(CORO_PARAM);
// Start or End Static
void StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat,
void startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat,
int &bodyStartPat, int &bodyLoopPat);
void StartStatic(CORO_PARAM, TALKTYPE nTalkType);
void EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat, int &headEndPat);
void EndStatic(CORO_PARAM, TALKTYPE nTalkType);
void startStatic(CORO_PARAM, TALKTYPE nTalkType);
void endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat, int &headEndPat);
void endStatic(CORO_PARAM, TALKTYPE nTalkType);
// Tony disguises himself!
void SetPastorella(bool bIsPast) {
m_bPastorella = bIsPast;
void setPastorella(bool bIsPast) {
_bPastorella = bIsPast;
}
int GetPastorella(void) {
return m_bPastorella;
int getPastorella(void) {
return _bPastorella;
}
// Perform an action
void ExecuteAction(int nAction, int nActionItem, int nParm);
void executeAction(int nAction, int nActionItem, int nParm);
void PlaySfx(int nSfx) {
RMItem::PlaySfx(nSfx);
void playSfx(int nSfx) {
RMItem::playSfx(nSfx);
}
};

338
engines/tony/utils.cpp
View file

@ -40,17 +40,17 @@ namespace Tony {
* Constructor
*/
RMString::RMString() {
m_string = NULL;
m_length = 0;
m_realLength = 0;
_string = NULL;
_length = 0;
_realLength = 0;
}
/**
* Destructor
*/
RMString::~RMString() {
if (m_string != NULL)
delete[] m_string;
if (_string != NULL)
delete[] _string;
}
/**
@ -58,9 +58,9 @@ RMString::~RMString() {
*/
RMString::RMString(const RMString &str) {
// Richiama l'overload su '=' per copiare
m_string = NULL;
m_length = 0;
m_realLength = 0;
_string = NULL;
_length = 0;
_realLength = 0;
*this = str;
}
@ -69,9 +69,9 @@ RMString::RMString(const RMString &str) {
*/
RMString::RMString(const char *str) {
// Use the overloaded '=' when copying
m_string = NULL;
m_length = 0;
m_realLength = 0;
_string = NULL;
_length = 0;
_realLength = 0;
*this = str;
}
@ -80,9 +80,9 @@ RMString::RMString(const char *str) {
*/
RMString::RMString(const int ch) {
// Use the overloaded '=' when copying
m_string = NULL;
m_length = 0;
m_realLength = 0;
_string = NULL;
_length = 0;
_realLength = 0;
*this = ch;
}
@ -90,8 +90,8 @@ RMString::RMString(const int ch) {
* Returns the length of the string
* @returns Length
*/
int RMString::Length() const {
return m_length;
int RMString::length() const {
return _length;
}
/**
@ -99,9 +99,9 @@ int RMString::Length() const {
* @param nIndex Position of the character to return
* @returns Character
*/
char RMString::GetAt(int nIndex) {
assert(nIndex < m_length);
return m_string[nIndex];
char RMString::getAt(int nIndex) {
assert(nIndex < _length);
return _string[nIndex];
}
/**
@ -109,9 +109,9 @@ char RMString::GetAt(int nIndex) {
* @param nIndex Position of the character to change
* @param c Character
*/
void RMString::SetAt(int nIndex, char c) {
assert(nIndex < m_length);
m_string[nIndex] = c;
void RMString::setAt(int nIndex, char c) {
assert(nIndex < _length);
_string[nIndex] = c;
}
/**
@ -120,8 +120,8 @@ void RMString::SetAt(int nIndex, char c) {
* @params Reference to the character
*/
char &RMString::operator[](int nIndex) {
assert(nIndex < m_length);
return m_string[nIndex];
assert(nIndex < _length);
return _string[nIndex];
}
/**
@ -131,21 +131,21 @@ char &RMString::operator[](int nIndex) {
*/
const RMString &RMString::operator=(const RMString &str) {
// Set the new length
m_length = str.m_length;
_length = str._length;
// If the source is empty, then destroy the current string buffer
if (m_length == 0) {
if (m_realLength > 0) {
delete[] m_string;
m_string = NULL;
m_realLength = 0;
if (_length == 0) {
if (_realLength > 0) {
delete[] _string;
_string = NULL;
_realLength = 0;
}
} else {
// Resize if necessary
Resize(m_length + 1);
resize(_length + 1);
// Copy the string
Common::copy(str.m_string, str.m_string + m_length + 1, m_string);
Common::copy(str._string, str._string + _length + 1, _string);
}
return *this;
@ -159,20 +159,20 @@ const RMString &RMString::operator=(const RMString &str) {
const RMString &RMString::operator=(const char *str) {
// If the source is empty, then destroy the current string buffer
if (str == NULL) {
if (m_realLength > 0) {
delete[] m_string;
m_string = NULL;
m_realLength = m_length = 0;
if (_realLength > 0) {
delete[] _string;
_string = NULL;
_realLength = _length = 0;
}
} else {
// Calculate the new length
m_length = strlen(str);
_length = strlen(str);
// Resize if necessary
Resize(m_length + 1);
resize(_length + 1);
// Copy the string
Common::copy(str, str + m_length + 1, m_string);
Common::copy(str, str + _length + 1, _string);
}
return *this;
@ -186,18 +186,18 @@ const RMString &RMString::operator=(const char *str) {
const RMString &RMString::operator=(const int ch) {
if (ch == '\0') {
// Destroy the current string
if (m_realLength > 0) {
delete [] m_string;
m_string = NULL;
m_length = m_realLength = 0;
if (_realLength > 0) {
delete [] _string;
_string = NULL;
_length = _realLength = 0;
}
} else {
// Resize if necessary
Resize(2);
resize(2);
m_string[0] = ch;
m_string[1] = '\0';
m_length = 1;
_string[0] = ch;
_string[1] = '\0';
_length = 1;
}
return *this;
@ -208,21 +208,21 @@ const RMString &RMString::operator=(const int ch) {
* @param str String to concatenate
* @param size Length of the string
*/
void RMString::Connect(const char *str, int size) {
void RMString::connect(const char *str, int size) {
int nlen;
if (size > 0) {
// Calculate the new lenght
nlen = m_length + size;
nlen = _length + size;
// Resize
Resize(nlen + 1, true);
resize(nlen + 1, true);
// Linkage with '\0'
Common::copy(str, str + size + 1, m_string + m_length);
Common::copy(str, str + size + 1, _string + _length);
// Save the new length
m_length = nlen;
_length = nlen;
}
}
@ -232,7 +232,7 @@ void RMString::Connect(const char *str, int size) {
* @returns Refrence to our string
*/
const RMString &RMString::operator+=(RMString &str) {
Connect(str, str.Length());
connect(str, str.length());
return *this;
}
@ -242,7 +242,7 @@ const RMString &RMString::operator+=(RMString &str) {
* @returns Refrence to our string
*/
const RMString &RMString::operator+=(const char *str) {
Connect(str, strlen(str));
connect(str, strlen(str));
return *this;
}
@ -258,7 +258,7 @@ const RMString &RMString::operator+=(const int ch) {
str[0] = ch;
str[1] = '\0';
Connect(str, 1);
connect(str, 1);
return *this;
}
@ -267,7 +267,7 @@ const RMString &RMString::operator+=(const int ch) {
* @returns char * reference to string
*/
RMString::operator char *() const {
return m_string;
return _string;
}
/**
@ -276,21 +276,21 @@ RMString::operator char *() const {
* @param bMaintain If true we must keep the original string,
if false we can destroy.
*/
void RMString::Resize(int size, bool bMantain) {
if (m_realLength == 0) {
m_string = new char[size];
m_realLength = size;
} else if (size > m_realLength) {
void RMString::resize(int size, bool bMantain) {
if (_realLength == 0) {
_string = new char[size];
_realLength = size;
} else if (size > _realLength) {
if (bMantain) {
char *app;
app = new char[size];
Common::copy(m_string, m_string + m_length + 1, app);
delete[] m_string;
m_string = app;
Common::copy(_string, _string + _length + 1, app);
delete[] _string;
_string = app;
} else {
delete[] m_string;
m_string = new char[size];
delete[] _string;
_string = new char[size];
}
}
}
@ -298,15 +298,15 @@ void RMString::Resize(int size, bool bMantain) {
/**
* Compacts the string to occupy less memory if possible.
*/
void RMString::Compact(void) {
if (m_realLength + 1 > m_length) {
void RMString::compact(void) {
if (_realLength + 1 > _length) {
char *app;
app = new char[m_length + 1];
Common::copy(m_string, m_string + m_length + 1, app);
app = new char[_length + 1];
Common::copy(_string, _string + _length + 1, app);
delete[] m_string;
m_string = app;
delete[] _string;
_string = app;
}
}
@ -359,14 +359,14 @@ RMDataStream &operator>>(RMDataStream &df, RMString &var) {
int i;
df >> len;
var.Resize(len + 1);
var.m_length = len + 1;
var.resize(len + 1);
var._length = len + 1;
for (i = 0; i < len; i++)
df >> var[i];
var[i] = '\0';
var.m_length = len;
var._length = len;
return df;
}
@ -374,7 +374,7 @@ RMDataStream &operator>>(RMDataStream &df, RMString &var) {
/**
* Formats a string
*/
void RMString::Format(const char *str, ...) {
void RMString::format(const char *str, ...) {
static char buf[2048];
va_list argList;
@ -393,29 +393,29 @@ RMFileStreamSlow::RMFileStreamSlow() : RMDataStream() {
}
RMFileStreamSlow::~RMFileStreamSlow() {
Close();
close();
}
void RMFileStreamSlow::Close() {
void RMFileStreamSlow::close() {
delete _stream;
}
bool RMFileStreamSlow::OpenFile(Common::File &file) {
bool RMFileStreamSlow::openFile(Common::File &file) {
_stream = file.readStream(file.size());
m_length = _stream->pos();
_length = _stream->pos();
return true;
}
bool RMFileStreamSlow::OpenFile(const char *lpFN) {
bool RMFileStreamSlow::openFile(const char *lpFN) {
// Open file for reading
Common::File f;
if (!f.open(lpFN))
return false;
m_length = f.size();
_length = f.size();
_stream = f.readStream(f.size());
return true;
@ -423,20 +423,20 @@ bool RMFileStreamSlow::OpenFile(const char *lpFN) {
RMDataStream &RMFileStreamSlow::operator+=(int nBytes) {
Seek(nBytes);
seek(nBytes);
return *this;
}
int RMFileStreamSlow::Pos() {
int RMFileStreamSlow::pos() {
return _stream->pos();
}
bool RMFileStreamSlow::IsEOF() {
return (Pos() >= m_length);
bool RMFileStreamSlow::isEOF() {
return (pos() >= _length);
}
int RMFileStreamSlow::Seek(int nBytes, RMDSPos where) {
int RMFileStreamSlow::seek(int nBytes, RMDSPos where) {
switch (where) {
case START:
return _stream->seek(nBytes);
@ -453,7 +453,7 @@ int RMFileStreamSlow::Seek(int nBytes, RMDSPos where) {
}
bool RMFileStreamSlow::Read(void *buf, int size) {
bool RMFileStreamSlow::read(void *buf, int size) {
uint32 dwRead;
dwRead = _stream->read(buf, size);
@ -462,39 +462,39 @@ bool RMFileStreamSlow::Read(void *buf, int size) {
RMFileStreamSlow &operator>>(RMFileStreamSlow &df, char &var) {
df.Read(&var, 1);
df.read(&var, 1);
return df;
}
RMFileStreamSlow &operator>>(RMFileStreamSlow &df, byte &var) {
df.Read(&var, 1);
df.read(&var, 1);
return df;
}
RMFileStreamSlow &operator>>(RMFileStreamSlow &df, uint16 &var) {
uint16 v;
df.Read(&v, 2);
df.read(&v, 2);
v = FROM_LE_16(v);
return df;
}
RMFileStreamSlow &operator>>(RMFileStreamSlow &df, int16 &var) {
uint16 v;
df.Read(&v, 2);
df.read(&v, 2);
var = (int16)FROM_LE_16(v);
return df;
}
RMFileStreamSlow &operator>>(RMFileStreamSlow &df, int &var) {
int v;
df.Read(&v, 4);
df.read(&v, 4);
var = FROM_LE_32(v);
return df;
}
RMFileStreamSlow &operator>>(RMFileStreamSlow &df, uint32 &var) {
uint32 v;
df.Read(&v, 4);
df.read(&v, 4);
var = FROM_LE_32(v);
return df;
}
@ -508,24 +508,24 @@ RMFileStreamSlow &operator>>(RMFileStreamSlow &df, uint32 &var) {
* Constructor
*/
RMDataStream::RMDataStream() {
m_length = 0;
m_pos = 0;
m_bError = false;
_length = 0;
_pos = 0;
_bError = false;
}
/**
* Destructor
*/
RMDataStream::~RMDataStream() {
Close();
close();
}
/**
* Close a stream
*/
void RMDataStream::Close(void) {
m_length = 0;
m_pos = 0;
void RMDataStream::close(void) {
_length = 0;
_pos = 0;
}
/**
@ -535,27 +535,27 @@ void RMDataStream::Close(void) {
* @remarks If the length of the buffer is not known, and cannot be
* specified, then EOF() and Seek() to end won't work.
*/
void RMDataStream::OpenBuffer(const byte *lpBuf, int size) {
m_length = size;
m_buf = lpBuf;
m_bError = false;
m_pos = 0;
void RMDataStream::openBuffer(const byte *lpBuf, int size) {
_length = size;
_buf = lpBuf;
_bError = false;
_pos = 0;
}
/**
* Returns the length of the stream
* @returns Stream length
*/
int RMDataStream::Length() {
return m_length;
int RMDataStream::length() {
return _length;
}
/**
* Determines if the end of the stream has been reached
* @returns true if end of stream reached, false if not
*/
bool RMDataStream::IsEOF() {
return (m_pos >= m_length);
bool RMDataStream::isEOF() {
return (_pos >= _length);
}
/**
@ -565,7 +565,7 @@ bool RMDataStream::IsEOF() {
* @returns Value read from the stream
*/
RMDataStream &operator>>(RMDataStream &df, char &var) {
df.Read(&var, 1);
df.read(&var, 1);
return df;
}
@ -576,7 +576,7 @@ RMDataStream &operator>>(RMDataStream &df, char &var) {
* @returns Value read from the stream
*/
RMDataStream &operator>>(RMDataStream &df, uint8 &var) {
df.Read(&var, 1);
df.read(&var, 1);
return df;
}
@ -588,7 +588,7 @@ RMDataStream &operator>>(RMDataStream &df, uint8 &var) {
*/
RMDataStream &operator>>(RMDataStream &df, uint16 &var) {
uint16 v;
df.Read(&v, 2);
df.read(&v, 2);
var = FROM_LE_16(v);
return df;
@ -602,7 +602,7 @@ RMDataStream &operator>>(RMDataStream &df, uint16 &var) {
*/
RMDataStream &operator>>(RMDataStream &df, int16 &var) {
uint16 v;
df.Read(&v, 2);
df.read(&v, 2);
var = (int16)FROM_LE_16(v);
return df;
@ -616,7 +616,7 @@ RMDataStream &operator>>(RMDataStream &df, int16 &var) {
*/
RMDataStream &operator>>(RMDataStream &df, int &var) {
uint32 v;
df.Read(&v, 4);
df.read(&v, 4);
var = (int)FROM_LE_32(v);
return df;
@ -630,7 +630,7 @@ RMDataStream &operator>>(RMDataStream &df, int &var) {
*/
RMDataStream &operator>>(RMDataStream &df, uint32 &var) {
uint32 v;
df.Read(&v, 4);
df.read(&v, 4);
var = FROM_LE_32(v);
return df;
@ -642,17 +642,17 @@ RMDataStream &operator>>(RMDataStream &df, uint32 &var) {
* @param size Size of the buffer
* @returns true if we have reached the end, false if not
*/
bool RMDataStream::Read(void *lpBuf, int size) {
bool RMDataStream::read(void *lpBuf, int size) {
byte *dest = (byte *)lpBuf;
if ((m_pos + size) > m_length) {
Common::copy(m_buf + m_pos, m_buf + m_pos + (m_length - m_pos), dest);
if ((_pos + size) > _length) {
Common::copy(_buf + _pos, _buf + _pos + (_length - _pos), dest);
return true;
} else {
Common::copy(m_buf + m_pos, m_buf + m_pos + size, dest);
Common::copy(_buf + _pos, _buf + _pos + size, dest);
m_pos += size;
_pos += size;
return false;
}
}
@ -663,7 +663,7 @@ bool RMDataStream::Read(void *lpBuf, int size) {
* @returns The stream
*/
RMDataStream &RMDataStream::operator+=(int nBytes) {
m_pos += nBytes;
_pos += nBytes;
return *this;
}
@ -673,57 +673,57 @@ RMDataStream &RMDataStream::operator+=(int nBytes) {
* @param origin Origin to do offset from
* @returns The absolute current position in bytes
*/
int RMDataStream::Seek(int nBytes, RMDSPos origin) {
int RMDataStream::seek(int nBytes, RMDSPos origin) {
switch (origin) {
case CUR:
break;
case START:
m_pos = 0;
_pos = 0;
break;
case END:
if (m_length == SIZENOTKNOWN)
return m_pos;
m_pos = m_length;
if (_length == SIZENOTKNOWN)
return _pos;
_pos = _length;
break;
}
m_pos += nBytes;
return m_pos;
_pos += nBytes;
return _pos;
}
/**
* Returns the current position of the stream
* @returns The current position
*/
int RMDataStream::Pos() {
return m_pos;
int RMDataStream::pos() {
return _pos;
}
/**
* Check if an error occurred during reading the stream
* @returns true if there was an error, false otherwise
*/
bool RMDataStream::IsError() {
return m_bError;
bool RMDataStream::isError() {
return _bError;
}
/**
* Sets an error code for the stream
* @param code Error code
*/
void RMDataStream::SetError(int code) {
m_bError = true;
m_ecode = code;
void RMDataStream::setError(int code) {
_bError = true;
_ecode = code;
}
/**
* Returns the error code for the stream
* @returns Error code
*/
int RMDataStream::GetError() {
return m_ecode;
int RMDataStream::getError() {
return _ecode;
}
/****************************************************************************\
@ -766,7 +766,7 @@ RMPoint &RMPoint::operator=(RMPoint p) {
/**
* Offsets the point by another point
*/
void RMPoint::Offset(const RMPoint &p) {
void RMPoint::offset(const RMPoint &p) {
x += p.x;
y += p.y;
}
@ -774,7 +774,7 @@ void RMPoint::Offset(const RMPoint &p) {
/**
* Offsets the point by a specified offset
*/
void RMPoint::Offset(int xOff, int yOff) {
void RMPoint::offset(int xOff, int yOff) {
x += xOff;
y += yOff;
}
@ -801,7 +801,7 @@ RMPoint operator-(RMPoint p1, RMPoint p2) {
* Sum (offset) of a point
*/
RMPoint &RMPoint::operator+=(RMPoint p) {
Offset(p);
offset(p);
return *this;
}
@ -809,7 +809,7 @@ RMPoint &RMPoint::operator+=(RMPoint p) {
* Subtract (offset) of a point
*/
RMPoint &RMPoint::operator-=(RMPoint p) {
Offset(-p);
offset(-p);
return *this;
}
@ -852,93 +852,93 @@ RMDataStream &operator>>(RMDataStream &ds, RMPoint &p) {
\****************************************************************************/
RMRect::RMRect() {
SetEmpty();
setEmpty();
}
void RMRect::SetEmpty(void) {
void RMRect::setEmpty(void) {
x1 = y1 = x2 = y2 = 0;
}
RMRect::RMRect(const RMPoint &p1, const RMPoint &p2) {
SetRect(p1, p2);
setRect(p1, p2);
}
RMRect::RMRect(int X1, int Y1, int X2, int Y2) {
SetRect(X1, Y1, X2, Y2);
setRect(X1, Y1, X2, Y2);
}
RMRect::RMRect(const RMRect &rc) {
CopyRect(rc);
copyRect(rc);
}
void RMRect::SetRect(const RMPoint &p1, const RMPoint &p2) {
void RMRect::setRect(const RMPoint &p1, const RMPoint &p2) {
x1 = p1.x;
y1 = p1.y;
x2 = p2.x;
y2 = p2.y;
}
void RMRect::SetRect(int X1, int Y1, int X2, int Y2) {
void RMRect::setRect(int X1, int Y1, int X2, int Y2) {
x1 = X1;
y1 = Y1;
x2 = X2;
y2 = Y2;
}
void RMRect::SetRect(const RMRect &rc) {
CopyRect(rc);
void RMRect::setRect(const RMRect &rc) {
copyRect(rc);
}
void RMRect::CopyRect(const RMRect &rc) {
void RMRect::copyRect(const RMRect &rc) {
x1 = rc.x1;
y1 = rc.y1;
x2 = rc.x2;
y2 = rc.y2;
}
RMPoint &RMRect::TopLeft() {
RMPoint &RMRect::topLeft() {
// FIXME: This seems very bad
return *((RMPoint *)this);
}
RMPoint &RMRect::BottomRight() {
RMPoint &RMRect::bottomRight() {
// FIXME: This seems very bad
return *((RMPoint *)this + 1);
}
RMPoint RMRect::Center() {
RMPoint RMRect::center() {
return RMPoint((x2 - x1) / 2, (y2 - y1) / 2);
}
int RMRect::Width() const {
int RMRect::width() const {
return x2 - x1;
}
int RMRect::Height() const {
int RMRect::height() const {
return y2 - y1;
}
int RMRect::Size() const {
return Width() * Height();
int RMRect::size() const {
return width() * height();
}
bool RMRect::IsEmpty() const {
bool RMRect::isEmpty() const {
return (x1 == 0 && y1 == 0 && x2 == 0 && y2 == 0);
}
const RMRect &RMRect::operator=(const RMRect &rc) {
CopyRect(rc);
copyRect(rc);
return *this;
}
void RMRect::Offset(int xOff, int yOff) {
void RMRect::offset(int xOff, int yOff) {
x1 += xOff;
y1 += yOff;
x2 += xOff;
y2 += yOff;
}
void RMRect::Offset(const RMPoint &p) {
void RMRect::offset(const RMPoint &p) {
x1 += p.x;
y1 += p.y;
x2 += p.x;
@ -946,12 +946,12 @@ void RMRect::Offset(const RMPoint &p) {
}
const RMRect &RMRect::operator+=(RMPoint p) {
Offset(p);
offset(p);
return *this;
}
const RMRect &RMRect::operator-=(RMPoint p) {
Offset(-p);
offset(-p);
return *this;
}
@ -986,8 +986,8 @@ bool RMRect::operator!=(const RMRect &rc) {
return ((x1 != rc.x1) || (y1 != rc.y1) || (x2 != rc.x2) || (y2 != rc.y2));
}
void RMRect::NormalizeRect(void) {
SetRect(MIN(x1, x2), MIN(y1, y2), MAX(x1, x2), MAX(y1, y2));
void RMRect::normalizeRect(void) {
setRect(MIN(x1, x2), MIN(y1, y2), MAX(x1, x2), MAX(y1, y2));
}
RMDataStream &operator>>(RMDataStream &ds, RMRect &rc) {
@ -1014,7 +1014,7 @@ RMResUpdate::~RMResUpdate() {
_hFile.close();
}
void RMResUpdate::Init(const Common::String &fileName) {
void RMResUpdate::init(const Common::String &fileName) {
// Open the resource update file
if (!_hFile.open(fileName))
// It doesn't exist, so exit immediately
@ -1039,7 +1039,7 @@ void RMResUpdate::Init(const Common::String &fileName) {
}
}
HGLOBAL RMResUpdate::QueryResource(uint32 dwRes) {
HGLOBAL RMResUpdate::queryResource(uint32 dwRes) {
// If there isn't an update file, return NULL
if (!_hFile.isOpen())
return NULL;

114
engines/tony/utils.h
View file

@ -44,11 +44,11 @@ using namespace ::Tony::MPAL;
*/
class RMDataStream {
protected:
const byte *m_buf;
int m_length;
int m_pos;
bool m_bError;
int m_ecode;
const byte *_buf;
int _length;
int _pos;
bool _bError;
int _ecode;
public:
enum RMDSPos {
@ -68,15 +68,15 @@ public:
virtual ~RMDataStream();
// Loading buffer
void OpenBuffer(const byte *buf, int size = SIZENOTKNOWN);
void Close(void);
void openBuffer(const byte *buf, int size = SIZENOTKNOWN);
void close(void);
// Attributei
int Length();
virtual int Pos();
int length();
virtual int pos();
// EOF
virtual bool IsEOF();
virtual bool isEOF();
// Read methods
friend RMDataStream &operator>>(RMDataStream &df, char &var);
@ -87,16 +87,16 @@ public:
friend RMDataStream &operator>>(RMDataStream &df, uint32 &var);
// General read
virtual bool Read(void *buf, int size);
virtual bool read(void *buf, int size);
// Skipping & Seeking
virtual RMDataStream &operator+=(int nBytes);
virtual int Seek(int nBytes, RMDSPos origin = CUR);
virtual int seek(int nBytes, RMDSPos origin = CUR);
// Error handling
void SetError(int ecode);
int GetError();
bool IsError();
void setError(int ecode);
int getError();
bool isError();
};
@ -105,17 +105,17 @@ public:
*/
class RMFileStream : public RMDataStream {
private:
byte *m_buf;
byte *_buf;
public:
RMFileStream();
virtual ~RMFileStream();
// Methods for opening file
bool OpenFile(const char *lpFN);
bool OpenFile(Common::File &file);
bool openFile(const char *lpFN);
bool openFile(Common::File &file);
void Close(void);
void close(void);
};
@ -126,18 +126,18 @@ public:
RMFileStreamSlow();
virtual ~RMFileStreamSlow();
bool OpenFile(const char *lpFN);
bool OpenFile(Common::File &file);
bool openFile(const char *lpFN);
bool openFile(Common::File &file);
void Close(void);
void close(void);
RMDataStream &operator+=(int nBytes);
int Seek(int nBytes, RMDSPos where = CUR);
int seek(int nBytes, RMDSPos where = CUR);
int Pos();
virtual bool IsEOF();
int pos();
virtual bool isEOF();
bool Read(void *buf, int size);
bool read(void *buf, int size);
friend RMFileStreamSlow &operator>>(RMFileStreamSlow &df, char &var);
friend RMFileStreamSlow &operator>>(RMFileStreamSlow &df, byte &var);
@ -152,9 +152,9 @@ public:
*/
class RMString {
private:
char *m_string;
int m_length;
int m_realLength;
char *_string;
int _length;
int _realLength;
public:
RMString();
@ -166,12 +166,12 @@ public:
RMString(const int ch);
// General methods
int Length() const;
void Compact();
int length() const;
void compact();
// Access characters within string
char GetAt(int nIndex);
void SetAt(int nIndex, char c);
char getAt(int nIndex);
void setAt(int nIndex, char c);
char &operator[](int nIndex);
// String cast
@ -200,11 +200,11 @@ public:
friend RMDataStream &operator>>(RMDataStream &df, RMString &var);
// String formatting
void Format(const char *str, ...);
void format(const char *str, ...);
private:
void Resize(int size, bool bMantain = false);
void Connect(const char *str, int size);
void resize(int size, bool bMantain = false);
void connect(const char *str, int size);
};
/**
@ -224,14 +224,14 @@ public:
RMPoint &operator=(RMPoint p);
// Set
void Set(int x1, int y1) {
void set(int x1, int y1) {
x = x1;
y = y1;
}
// Offset
void Offset(int xOff, int yOff);
void Offset(const RMPoint &p);
void offset(int xOff, int yOff);
void offset(const RMPoint &p);
friend RMPoint operator+(RMPoint p1, RMPoint p2);
friend RMPoint operator-(RMPoint p1, RMPoint p2);
RMPoint &operator+=(RMPoint p);
@ -261,27 +261,27 @@ public:
RMRect(const RMRect &rc);
// Attributes
RMPoint &TopLeft();
RMPoint &BottomRight();
RMPoint Center();
int Width() const;
int Height() const;
bool IsEmpty() const;
int Size() const;
RMPoint &topLeft();
RMPoint &bottomRight();
RMPoint center();
int width() const;
int height() const;
bool isEmpty() const;
int size() const;
// Set
void SetRect(int x1, int y1, int x2, int y2);
void SetRect(const RMPoint &p1, const RMPoint &p2);
void SetEmpty(void);
void setRect(int x1, int y1, int x2, int y2);
void setRect(const RMPoint &p1, const RMPoint &p2);
void setEmpty(void);
// Copiers
void SetRect(const RMRect &rc);
void CopyRect(const RMRect &rc);
void setRect(const RMRect &rc);
void copyRect(const RMRect &rc);
const RMRect &operator=(const RMRect &rc);
// Offset
void Offset(int xOff, int yOff);
void Offset(const RMPoint &p);
void offset(int xOff, int yOff);
void offset(const RMPoint &p);
friend RMRect operator+(const RMRect &rc, RMPoint p);
friend RMRect operator-(const RMRect &rc, RMPoint p);
friend RMRect operator+(RMPoint p, const RMRect &rc);
@ -294,10 +294,10 @@ public:
bool operator!=(const RMRect &rc);
// Normalise
void NormalizeRect();
void normalizeRect();
// Point in rect
bool PtInRect(const RMPoint &pt) {
bool ptInRect(const RMPoint &pt) {
return (pt.x >= x1 && pt.x <= x2 && pt.y >= y1 && pt.y <= y2);
}
@ -324,8 +324,8 @@ public:
RMResUpdate();
~RMResUpdate();
void Init(const Common::String &fileName);
HGLOBAL QueryResource(uint32 dwRes);
void init(const Common::String &fileName);
HGLOBAL queryResource(uint32 dwRes);
};
} // End of namespace Tony

4
engines/tony/window.h
View file

@ -57,8 +57,8 @@ private:
void plotLines(const byte *lpBuf, const Common::Point &center, int x, int y);
protected:
void * /*LPDIRECTDRAWCLIPPER*/ m_MainClipper;
void * /*LPDIRECTDRAWCLIPPER*/ m_BackClipper;
// void * /*LPDIRECTDRAWCLIPPER*/ _MainClipper;
// void * /*LPDIRECTDRAWCLIPPER*/ _BackClipper;
int fps, fcount;
int lastsecond, lastfcount;