From c831248e652a892fe49f8ab7778ea5f5e1aa1ee8 Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Tue, 1 May 2012 23:44:02 +1000
Subject: TONY: Cleanup of GfxEngine, and added RMTony class methods

---
 engines/tony/tonychar.cpp | 1813 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1813 insertions(+)
 create mode 100644 engines/tony/tonychar.cpp

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
new file mode 100644
index 0000000000..493f10ef29
--- /dev/null
+++ b/engines/tony/tonychar.cpp
@@ -0,0 +1,1813 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+/**************************************************************************
+ *                                     ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ *
+ *                                             Nayma Software srl         *
+ *                    e                -= We create much MORE than ALL =- *
+ *        u-        z$$$c        '.    ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ *
+ *      .d"        d$$$$$b        "b.                                     *
+ *   .z$*         d$$$$$$$L        ^*$c.                                  *
+ *  #$$$.         $$$$$$$$$         .$$$" Project: Roasted Moths........  *
+ *    ^*$b       4$$$$$$$$$F      .d$*"                                   *
+ *      ^$$.     4$$$$$$$$$F     .$P"     Module:  TonyChar.CPP.........  *
+ *        *$.    '$$$$$$$$$     4$P 4                                     *
+ *     J   *$     "$$$$$$$"     $P   r    Author:  Giovanni Bajo........  *
+ *    z$   '$$$P*4c.*$$$*.z@*R$$$    $.                                   *
+ *   z$"    ""       #$F^      ""    '$c                                  *
+ *  z$$beu     .ue="  $  "=e..    .zed$$c                                 *
+ *      "#$e z$*"   .  `.   ^*Nc e$""                                     *
+ *         "$$".  .r"   ^4.  .^$$"                                        *
+ *          ^.@*"6L=\ebu^+C$"*b."                                         *
+ *        "**$.  "c 4$$$  J"  J$P*"    OS:  [ ] DOS  [X] WIN95  [ ] PORT  *
+ *            ^"--.^ 9$"  .--""      COMP:  [ ] WATCOM  [X] VISUAL C++    *
+ *                    "                     [ ] EIFFEL  [ ] GCC/GXX/DJGPP *
+ *                                                                        *
+ * This source code is Copyright (C) Nayma Software.  ALL RIGHTS RESERVED *
+ *                                                                        *
+ **************************************************************************/
+
+#include "tony/mpal/memory.h"
+#include "tony/mpal/mpalutils.h"
+#include "tony/game.h"
+#include "tony/tonychar.h"
+#include "tony/tony.h"
+
+namespace Tony {
+
+/****************************************************************************\
+*       Metodi di RMTony
+\****************************************************************************/
+
+bool RMTony::m_bAction = false;
+
+uint32 RMTony::WaitEndOfAction(HANDLE hThread) {
+	WaitForSingleObject(hThread, INFINITE);
+	m_bAction = false;
+
+	return 1;
+}
+
+RMGfxSourceBuffer *RMTony::NewItemSpriteBuffer(int dimx, int dimy, bool bPreRLE) {
+	RMGfxSourceBuffer8RLE *spr;
+	
+	assert(m_cm == CM_256);
+	spr = new RMGfxSourceBuffer8RLEByteAA;
+	spr->SetAlphaBlendColor(1);
+	if (bPreRLE)
+		spr->SetAlreadyCompressed();
+	return spr;
+}
+
+void RMTony::Init(void) {
+	RMRes tony(0);
+	RMRes body(9999);
+	RMDataStream ds;
+
+	// Apre il buffer
+	ds.OpenBuffer(tony);
+
+	// Legge dallo stream l'oggetto corrente (cioè Tony)
+	ReadFromStream(ds, true);	// da OGX
+	
+	// Chiude il buffer
+	ds.Close();
+
+	// Legge il corpo di Tony
+	ds.OpenBuffer(body);
+	m_body.ReadFromStream(ds, true); // da OGX
+	ds.Close();
+	m_body.SetPattern(0);
+
+	// Mostra Tony di default
+	m_bShow=m_bShowOmbra = true;
+
+  // Nessuna azione in attesa
+	m_bActionPending = false;
+	m_bAction = false;
+
+	m_bPastorella = false;
+	m_bIsTalking = false;
+	m_bIsStaticTalk = false;
+
+	m_nTimeLastStep = _vm->GetTime();
+}
+
+
+void RMTony::Close(void) {
+	// Disalloca @@@ Manca la disallocazione di un item
+	m_ombra.Destroy();
+}
+
+void RMTony::DoFrame(RMGfxTargetBuffer *bigBuf, int curLoc) {
+	if (!m_nInList && m_bShow)
+		bigBuf->AddPrim(new RMGfxPrimitive(this));
+	
+	SetSpeed(nCfgTonySpeed);	
+
+	// Esegue il movimento normale del personaggio
+	int time = _vm->GetTime();
+
+	do 	{
+		m_nTimeLastStep += (1000 / 40);
+		RMCharacter::DoFrame(bigBuf, curLoc);
+
+	} while (time > m_nTimeLastStep + (1000 / 40));
+
+	// Controlla se siamo alla fine del percorso
+	if (EndOfPath() && m_bActionPending) {
+		// Bisogna eseguire l'azione sulla quale abbiamo clickato
+		m_bActionPending = false;	
+	}
+
+	if (m_bIsTalking || m_bIsStaticTalk)
+		m_body.DoFrame(bigBuf, false);
+}
+
+void RMTony::Show(void) {
+	m_bShow = true;
+	m_bShowOmbra = true;
+}
+
+void RMTony::Hide(bool bShowOmbra) {
+	m_bShow = false;
+	m_bShowOmbra = bShowOmbra;
+}
+
+
+void RMTony::Draw(RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+	// Richiama il Draw() della classe madre se tony è visibile
+	if (m_bShow && bDrawNow) 	{
+		if (m_bCorpoDavanti) 		{
+			prim->Dst().SetEmpty();
+			prim->Dst().Offset(-44, -134);
+			if (m_bPastorella)
+				prim->Dst().Offset(1, 4);
+			RMCharacter::Draw(bigBuf, prim);
+		}
+
+		if (m_bIsTalking || m_bIsStaticTalk) {
+			// Offset inverso per lo scrolling
+			prim->Dst().SetEmpty();
+			prim->Dst().Offset(-m_curScroll);
+    		prim->Dst().Offset(m_pos);
+			prim->Dst().Offset(-44, -134);
+			prim->Dst() += m_nBodyOffset;	
+			m_body.Draw(bigBuf, prim);
+		}
+
+		if (!m_bCorpoDavanti) {
+			prim->Dst().SetEmpty();
+			prim->Dst().Offset(-44, -134);
+			if (m_bPastorella)
+				prim->Dst().Offset(0, 3);
+			RMCharacter::Draw(bigBuf, prim);
+		}
+	}
+}
+
+void RMTony::MoveAndDoAction(RMPoint dst, RMItem *item, int nAction, int nActionParm) {
+	// Fa il movimento normale, ma si ricorda se deve poi eseguire un azione
+	if (item == NULL) {
+		m_bActionPending = false;
+		m_ActionItem = NULL;
+	} else {
+		m_ActionItem = item;
+		m_Action = nAction;
+		m_ActionParm = nActionParm;
+		m_bActionPending = true;
+	}
+
+	if (!RMCharacter::Move(dst)) {
+		m_bActionPending = false;
+		m_ActionItem = NULL;
+	}
+}
+
+
+void RMTony::ExecuteAction(int nAction, int nActionItem, int nParm) {
+	HANDLE hThread;
+	
+	if (nAction == TA_COMBINE) {
+		hThread = mpalQueryDoAction(TA_COMBINE, nParm, nActionItem);
+		
+		// Se è fallito il combine, proviamo con il ReceiveCombine
+		if (hThread == INVALID_HANDLE_VALUE) {
+			hThread = mpalQueryDoAction(TA_RECEIVECOMBINE, nActionItem, nParm); 
+			
+			// Se è fallito il receive, andiamo con quelli generici
+			// @@@ CombineGive!
+			if (hThread == INVALID_HANDLE_VALUE) {
+				hThread = mpalQueryDoAction(TA_COMBINE, nParm, 0);
+				
+				if (hThread == INVALID_HANDLE_VALUE){
+					hThread = mpalQueryDoAction(TA_RECEIVECOMBINE, nActionItem, 0);
+				}
+			}
+		}
+	} else {
+		// Esegue l'azione
+		hThread = mpalQueryDoAction(nAction, nActionItem, 0); 
+	}
+					
+	if (hThread != INVALID_HANDLE_VALUE) {
+		uint32 id;
+		m_bAction = true;
+		CreateThread(NULL, 10240,(LPTHREAD_START_ROUTINE)WaitEndOfAction, (void *)hThread, 0, &id);
+		hActionThread = hThread;
+	} else if (nAction != TA_GOTO) {
+ 		uint32 id;
+
+		if (nAction == TA_TALK) {
+			hThread = mpalQueryDoAction(6, 1, 0); 
+			m_bAction = true;
+			CreateThread(NULL,10240,(LPTHREAD_START_ROUTINE)WaitEndOfAction, (void *)hThread,0,&id);
+  			hActionThread=hThread;
+		} else if (nAction == TA_PALESATI) {
+			hThread = mpalQueryDoAction(7, 1, 0);
+			m_bAction = true; 
+			CreateThread(NULL,10240,(LPTHREAD_START_ROUTINE)WaitEndOfAction,(void *)hThread, 0, &id);
+  			hActionThread=hThread;
+		} else {
+			hThread = mpalQueryDoAction(5, 1, 0); 
+			m_bAction = true;
+			CreateThread(NULL, 10240, (LPTHREAD_START_ROUTINE)WaitEndOfAction, (void *)hThread, 0, &id);
+			hActionThread = hThread;
+		}
+	}
+}
+
+
+void RMTony::StopNoAction(void) {
+	if (m_bAction)
+		WaitForSingleObject(hActionThread, INFINITE);
+
+	m_bActionPending = false;
+	m_ActionItem = NULL;
+	Stop();
+}
+
+void RMTony::Stop(void) {
+	HANDLE hThread;
+
+	if (m_ActionItem != NULL) {
+		// Richiama l'MPAL per scegliere la direzione
+		hThread = mpalQueryDoAction(21, m_ActionItem->MpalCode(), 0);
+
+		if (hThread==INVALID_HANDLE_VALUE)
+			RMCharacter::Stop();
+		else {
+			bNeedToStop = false;	// Se facciamo la OnWhichDirection, almeno dopo non dobbiamo fare la Stop()
+			bMoving = false;
+			WaitForSingleObject(hThread, INFINITE); // @@@ Mettere un assert dopo 10 secondi
+		}
+	} else {
+		RMCharacter::Stop();
+	}
+
+	if (!m_bActionPending)
+		return;
+
+	m_bActionPending = false;
+
+	ExecuteAction(m_Action, m_ActionItem->MpalCode(), m_ActionParm);
+	
+	m_ActionItem=NULL;
+}
+
+
+int RMTony::GetCurPattern(void) {
+	int nPatt=RMCharacter::GetCurPattern();
+
+	if (!m_bPastorella)
+		return nPatt;
+	
+	switch (nPatt) {
+	case PAT_PAST_STANDUP:
+		return PAT_STANDUP;
+	case PAT_PAST_STANDDOWN:
+		return PAT_STANDDOWN;
+	case PAT_PAST_STANDLEFT:
+		return PAT_STANDLEFT;
+	case PAT_PAST_STANDRIGHT:
+		return PAT_STANDRIGHT;
+
+	case PAT_PAST_WALKUP:
+		return PAT_WALKUP;
+	case PAT_PAST_WALKDOWN:
+		return PAT_WALKDOWN;
+	case PAT_PAST_WALKLEFT:
+		return PAT_WALKLEFT;
+	case PAT_PAST_WALKRIGHT:
+		return PAT_WALKRIGHT;
+	}
+
+	return nPatt;
+}
+
+void RMTony::SetPattern(int nPatt, bool bPlayP0) {
+	if (m_bPastorella) {
+		switch (nPatt) {
+		case PAT_STANDUP:
+			nPatt=PAT_PAST_STANDUP;
+			break;
+		case PAT_STANDDOWN:
+			nPatt=PAT_PAST_STANDDOWN;
+			break;
+		case PAT_STANDLEFT:
+			nPatt=PAT_PAST_STANDLEFT;
+			break;
+		case PAT_STANDRIGHT:
+			nPatt=PAT_PAST_STANDRIGHT;
+			break;
+		case PAT_WALKUP:
+			nPatt=PAT_PAST_WALKUP;
+			break;
+		case PAT_WALKDOWN:
+			nPatt=PAT_PAST_WALKDOWN;
+			break;
+		case PAT_WALKLEFT:
+			nPatt=PAT_PAST_WALKLEFT;
+			break;
+		case PAT_WALKRIGHT:
+			nPatt=PAT_PAST_WALKRIGHT;
+			break;
+		}
+	}
+
+	RMCharacter::SetPattern(nPatt, bPlayP0);
+}
+
+
+void RMTony::Take(int nWhere, int nPart) {
+	if (nPart == 0) {
+		switch (GetCurPattern()) {
+		case PAT_STANDDOWN:
+			assert(0);	// Non esiste il prende mentre sei in StandDown
+			break;
+
+		case PAT_STANDUP:
+			switch (nWhere) {
+			case 0:
+				SetPattern(PAT_TAKEUP_UP1);
+				break;
+			case 1:
+				SetPattern(PAT_TAKEUP_MID1);
+				break;
+			case 2:
+				SetPattern(PAT_TAKEUP_DOWN1);
+				break;
+			}
+			break;
+
+		case PAT_STANDRIGHT:
+			switch (nWhere) {
+			case 0:
+				SetPattern(PAT_TAKERIGHT_UP1);
+				break;
+			case 1:
+				SetPattern(PAT_TAKERIGHT_MID1);
+				break;
+			case 2:
+				SetPattern(PAT_TAKERIGHT_DOWN1);
+				break;
+			}
+			break;
+
+
+		case PAT_STANDLEFT:
+			switch (nWhere) {
+			case 0:
+				SetPattern(PAT_TAKELEFT_UP1);
+				break;
+			case 1:
+				SetPattern(PAT_TAKELEFT_MID1);
+				break;
+			case 2:
+				SetPattern(PAT_TAKELEFT_DOWN1);
+				break;
+			}
+			break;
+		}
+	} else if (nPart == 1) {
+		SetPattern(GetCurPattern()+1);
+	} else if (nPart == 2) {
+		switch (GetCurPattern()) {
+		case PAT_TAKEUP_UP2:
+		case PAT_TAKEUP_MID2:
+		case PAT_TAKEUP_DOWN2:
+			SetPattern(PAT_STANDUP);
+			break;
+
+		case PAT_TAKELEFT_UP2:
+		case PAT_TAKELEFT_MID2:
+		case PAT_TAKELEFT_DOWN2:
+			SetPattern(PAT_STANDLEFT);
+			break;
+
+		case PAT_TAKERIGHT_UP2:
+		case PAT_TAKERIGHT_MID2:
+		case PAT_TAKERIGHT_DOWN2:
+			SetPattern(PAT_STANDRIGHT);
+			break;
+		}
+	}
+}
+
+
+void RMTony::Put(int nWhere, int nPart) {
+	if (nPart == 0) {
+		switch (GetCurPattern()) {
+		case PAT_STANDDOWN:
+			//assert(0);	// Non esiste il prende mentre sei in StandDown
+			break;
+
+		case PAT_STANDUP:
+			switch (nWhere) {
+			case 0:
+				SetPattern(PAT_PUTUP_UP1);
+				break;
+			case 1:
+				SetPattern(PAT_PUTUP_MID1);
+				break;
+			case 2:
+				SetPattern(PAT_PUTUP_DOWN1);
+				break;
+			}
+			break;
+
+		case PAT_STANDRIGHT:
+			switch (nWhere) {
+			case 0:
+				SetPattern(PAT_PUTRIGHT_UP1);
+				break;
+			case 1:
+				SetPattern(PAT_PUTRIGHT_MID1);
+				break;
+			case 2:
+				SetPattern(PAT_PUTRIGHT_DOWN1);
+				break;
+			}
+			break;
+
+
+		case PAT_STANDLEFT:
+			switch (nWhere) {
+			case 0:
+				SetPattern(PAT_PUTLEFT_UP1);
+				break;
+			case 1:
+				SetPattern(PAT_PUTLEFT_MID1);
+				break;
+			case 2:
+				SetPattern(PAT_PUTLEFT_DOWN1);
+				break;
+			}
+			break;
+		}
+	} else if (nPart == 1) {
+		SetPattern(GetCurPattern()+1);
+	} else if (nPart == 2) {
+		switch (GetCurPattern()) {
+		case PAT_PUTUP_UP2:
+		case PAT_PUTUP_MID2:
+		case PAT_PUTUP_DOWN2:
+			SetPattern(PAT_STANDUP);
+			break;
+
+		case PAT_PUTLEFT_UP2:
+		case PAT_PUTLEFT_MID2:
+		case PAT_PUTLEFT_DOWN2:
+			SetPattern(PAT_STANDLEFT);
+			break;
+
+		case PAT_PUTRIGHT_UP2:
+		case PAT_PUTRIGHT_MID2:
+		case PAT_PUTRIGHT_DOWN2:
+			SetPattern(PAT_STANDRIGHT);
+			break;
+		}
+	}
+}
+
+
+void RMTony::StartTalk(TALKTYPE nTalkType) {
+	int headStartPat = 0, bodyStartPat = 0;
+	int headLoopPat = 0, bodyLoopPat = 0;
+	
+	assert(!m_bIsTalking);
+
+	m_bIsTalking = true;
+	m_nPatB4Talking = GetCurPattern();
+	m_nTalkType = nTalkType;
+
+	// Setta la direzione di parlata SOLO se non siamo in una static animation (perché l'ha già fatto)
+	if (!m_bIsStaticTalk) {
+		switch (m_nPatB4Talking) {
+		case PAT_STANDDOWN:
+			m_TalkDirection=DOWN;
+			break;
+
+		case PAT_TAKELEFT_UP2:
+		case PAT_TAKELEFT_MID2:
+		case PAT_TAKELEFT_DOWN2:
+		case PAT_SIRIALZALEFT:
+		case PAT_STANDLEFT:
+			m_TalkDirection=LEFT;
+			break;
+		
+		case PAT_TAKERIGHT_UP2:
+		case PAT_TAKERIGHT_MID2:
+		case PAT_TAKERIGHT_DOWN2:
+		case PAT_SIRIALZARIGHT:
+		case PAT_STANDRIGHT:
+			m_TalkDirection=RIGHT;
+			break;
+
+		case PAT_TAKEUP_UP2:
+		case PAT_TAKEUP_MID2:
+		case PAT_TAKEUP_DOWN2:
+		case PAT_STANDUP:
+			m_TalkDirection=UP;
+			break;
+		}
+
+		// Mette davanti il corpo di default
+		m_bCorpoDavanti = true;
+	}
+
+	if (m_bPastorella) {
+		// Da pastorella, c'è un solo parlato
+		MainFreeze();
+		switch (m_TalkDirection) {
+		case UP:
+			SetPattern(PAT_PAST_TALKUP);
+			break;
+
+		case DOWN:
+			SetPattern(PAT_PAST_TALKDOWN);
+			break;
+			
+		case LEFT:
+			SetPattern(PAT_PAST_TALKLEFT);
+			break;
+
+		case RIGHT:
+			SetPattern(PAT_PAST_TALKRIGHT);
+			break;
+		}
+		MainUnfreeze();
+		return;
+	}
+
+	headStartPat = bodyStartPat = 0;
+	bodyLoopPat = 0;
+
+	switch (nTalkType) {
+	case TALK_NORMAL: 
+		m_bCorpoDavanti = false;
+		headStartPat = 0;
+		bodyStartPat = 0;
+
+		switch (m_TalkDirection) {
+		case DOWN:
+			headLoopPat = PAT_TALK_DOWN;
+			bodyLoopPat = BPAT_STANDDOWN;
+			m_nBodyOffset.Set(4, 53);
+			break;
+
+		case LEFT:
+			headLoopPat = PAT_TALK_LEFT;
+			bodyLoopPat = BPAT_STANDLEFT;
+			m_nBodyOffset.Set(6, 56);
+			break;
+
+		case RIGHT:
+			headLoopPat = PAT_TALK_RIGHT;
+			bodyLoopPat = BPAT_STANDRIGHT;
+			m_nBodyOffset.Set(6, 56);
+			break;
+
+		case UP:
+			headLoopPat = PAT_TALK_UP;
+			bodyLoopPat = BPAT_STANDUP;
+			m_nBodyOffset.Set(6, 53);
+			break;
+		}
+		break;
+
+	case TALK_FIANCHI:	
+		m_bCorpoDavanti = false;
+		switch (m_TalkDirection) {
+		case UP:
+			m_nBodyOffset.Set(2, 42);
+			headStartPat = PAT_TESTA_UP;
+			bodyStartPat = BPAT_FIANCHIUP_START;
+			headLoopPat = PAT_TALK_UP;
+			bodyLoopPat = BPAT_FIANCHIUP_LOOP;
+			break;
+
+		case DOWN:
+			m_nBodyOffset.Set(2, 48);
+			headStartPat = PAT_TESTA_DOWN;
+			bodyStartPat = BPAT_FIANCHIDOWN_START;
+			headLoopPat = PAT_TALK_DOWN;
+			bodyLoopPat = BPAT_FIANCHIDOWN_LOOP;
+			break;
+
+		case LEFT:
+			m_nBodyOffset.Set(-3, 53);
+			headStartPat = PAT_TESTA_LEFT;
+			bodyStartPat = BPAT_FIANCHILEFT_START;
+			headLoopPat = PAT_TALK_LEFT;
+			bodyLoopPat = BPAT_FIANCHILEFT_LOOP;
+			break;
+
+		case RIGHT:
+			m_nBodyOffset.Set(2, 53);
+			headStartPat = PAT_TESTA_RIGHT;
+			bodyStartPat = BPAT_FIANCHIRIGHT_START;
+			headLoopPat = PAT_TALK_RIGHT;
+			bodyLoopPat = BPAT_FIANCHIRIGHT_LOOP;
+			break;
+		}
+		break;
+
+
+	case TALK_CANTA:
+		m_nBodyOffset.Set(-10, 25);
+		headStartPat = PAT_TESTA_LEFT;
+		bodyStartPat = BPAT_CANTALEFT_START;
+		headLoopPat = PAT_TALK_LEFT;
+		bodyLoopPat = BPAT_CANTALEFT_LOOP;
+		break;
+
+	case TALK_RIDE:
+		m_bCorpoDavanti = false;
+		switch (m_TalkDirection) {
+		case UP:
+		case DOWN:
+		case LEFT:
+			m_nBodyOffset.Set(6, 56);
+			headStartPat = PAT_RIDELEFT_START;
+			bodyStartPat = BPAT_STANDLEFT;
+			headLoopPat = PAT_RIDELEFT_LOOP;
+			bodyLoopPat = BPAT_RIDELEFT;
+			break;
+
+		case RIGHT:
+			m_nBodyOffset.Set(6, 56);
+			headStartPat = PAT_RIDERIGHT_START;
+			bodyStartPat = BPAT_STANDRIGHT;
+			headLoopPat = PAT_RIDERIGHT_LOOP;
+			bodyLoopPat = BPAT_RIDERIGHT;
+			break;
+		}
+		break;
+
+	case TALK_RIDE2:
+		m_bCorpoDavanti = false;
+		switch (m_TalkDirection) {
+		case UP:
+		case DOWN:
+		case LEFT:
+			m_nBodyOffset.Set(6, 56);
+			headStartPat = PAT_RIDELEFT_START;
+			bodyStartPat = BPAT_STANDLEFT;
+			headLoopPat = PAT_RIDELEFT_LOOP;
+			break;
+
+		case RIGHT:
+			m_nBodyOffset.Set(6, 56);
+			headStartPat = PAT_RIDERIGHT_START;
+			bodyStartPat = BPAT_STANDRIGHT;
+			headLoopPat = PAT_RIDERIGHT_LOOP;
+			bodyLoopPat = BPAT_RIDERIGHT;
+			break;
+		}
+		break;
+
+
+	case TALK_SIINDICA:
+		switch (m_TalkDirection) {
+		case UP:
+		case DOWN:
+		case LEFT:
+			m_nBodyOffset.Set(-4, 40);
+			headLoopPat = PAT_TALK_LEFT;
+			bodyLoopPat = BPAT_SIINDICALEFT;
+			break;
+
+		case RIGHT:
+			m_nBodyOffset.Set(5, 40);
+			headLoopPat = PAT_TALK_RIGHT;
+			bodyLoopPat = BPAT_SIINDICARIGHT;
+			break;					
+		}
+		break;
+
+	case TALK_SPAVENTATO:
+		switch (m_TalkDirection) {
+		case UP:
+			m_nBodyOffset.Set(-4, -11);
+			headStartPat = PAT_TESTA_UP;
+			bodyStartPat = BPAT_SPAVENTOUP_START;
+			headLoopPat = PAT_TALK_UP;
+			bodyLoopPat = BPAT_SPAVENTOUP_LOOP;
+			break;
+
+		case DOWN:
+			m_nBodyOffset.Set(-5, 45);
+			headStartPat = PAT_SPAVENTODOWN_START;
+			bodyStartPat = BPAT_SPAVENTODOWN_START;
+			headLoopPat = PAT_SPAVENTODOWN_LOOP;
+			bodyLoopPat = BPAT_SPAVENTODOWN_LOOP;
+			break;
+
+		case RIGHT:
+			m_nBodyOffset.Set(-4, 41);
+			headStartPat = PAT_SPAVENTORIGHT_START;
+			bodyStartPat = BPAT_SPAVENTORIGHT_START;
+			headLoopPat = PAT_SPAVENTORIGHT_LOOP;
+			bodyLoopPat = BPAT_SPAVENTORIGHT_LOOP;
+			break;
+
+		case LEFT:
+			m_nBodyOffset.Set(-10, 41);
+			headStartPat = PAT_SPAVENTOLEFT_START;
+			bodyStartPat = BPAT_SPAVENTOLEFT_START;
+			headLoopPat = PAT_SPAVENTOLEFT_LOOP;
+			bodyLoopPat = BPAT_SPAVENTOLEFT_LOOP;
+			break;
+		}
+		break;
+
+	case TALK_SPAVENTATO2:
+		m_bCorpoDavanti = false;
+		switch (m_TalkDirection) {
+		case UP:
+			bodyStartPat = BPAT_STANDUP;
+			bodyLoopPat = BPAT_STANDUP;
+			m_nBodyOffset.Set(6, 53);
+
+			headStartPat = PAT_TESTA_UP;
+			headLoopPat = PAT_TALK_UP;
+			break;
+
+		case DOWN:
+			bodyStartPat = BPAT_STANDDOWN;
+			bodyLoopPat = BPAT_STANDDOWN;
+			m_nBodyOffset.Set(4, 53);
+
+			headStartPat = PAT_SPAVENTODOWN_START;
+			headLoopPat = PAT_SPAVENTODOWN_LOOP;
+			break;
+
+		case RIGHT:
+			bodyStartPat = BPAT_STANDRIGHT;
+			bodyLoopPat = BPAT_STANDRIGHT;
+			m_nBodyOffset.Set(6, 56);
+
+			headStartPat = PAT_SPAVENTORIGHT_START;
+			headLoopPat = PAT_SPAVENTORIGHT_LOOP;
+			break;
+
+		case LEFT:
+			bodyStartPat = BPAT_STANDLEFT;
+			bodyLoopPat = BPAT_STANDLEFT;
+			m_nBodyOffset.Set(6, 56);
+
+			headStartPat = PAT_SPAVENTOLEFT_START;
+			headLoopPat = PAT_SPAVENTOLEFT_LOOP;
+			break;
+		}
+		break;
+
+	case TALK_CONBICCHIERE:
+		m_nBodyOffset.Set(4, 53);
+		headLoopPat = PAT_TALK_DOWN;
+		bodyLoopPat = BPAT_BICCHIERE;
+		break;
+	case TALK_CONVERME:
+		m_nBodyOffset.Set(9, 56);
+		headLoopPat = PAT_TALK_RIGHT;
+		bodyLoopPat = BPAT_VERME;
+		break;
+	case TALK_CONMARTELLO:
+		m_nBodyOffset.Set(6, 56);
+		headLoopPat = PAT_TALK_LEFT;
+		bodyLoopPat = BPAT_MARTELLO;
+		break;
+	case TALK_CONCORDA:
+		m_nBodyOffset.Set(-3, 38);
+		headLoopPat = PAT_TALK_RIGHT;
+		bodyLoopPat = BPAT_CORDA;
+		break;
+	case TALK_CONSEGRETARIA:
+		m_nBodyOffset.Set(-17, 12);
+		headLoopPat = PAT_TALK_RIGHT;
+		bodyLoopPat = BPAT_CONSEGRETARIA;
+		break;
+
+	case TALK_CONCONIGLIO:
+		switch (m_TalkDirection) {
+		case LEFT:
+		case UP:
+			m_nBodyOffset.Set(-21, -5);
+			bodyStartPat = BPAT_CONCONIGLIOLEFT_START;
+			headLoopPat = PAT_TALK_LEFT;
+			bodyLoopPat = BPAT_CONCONIGLIOLEFT_LOOP;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			m_nBodyOffset.Set(-4, -5);
+			bodyStartPat = BPAT_CONCONIGLIORIGHT_START;
+			headLoopPat = PAT_TALK_RIGHT;
+			bodyLoopPat = BPAT_CONCONIGLIORIGHT_LOOP;
+			break;
+		}
+		break;
+
+	case TALK_CONRICETTA:
+		switch (m_TalkDirection) {
+		case LEFT:
+		case UP:
+			m_nBodyOffset.Set(-61, -7);
+			bodyStartPat = BPAT_CONRICETTALEFT_START;
+			headLoopPat = PAT_TALK_LEFT;
+			bodyLoopPat = BPAT_CONRICETTALEFT_LOOP;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			m_nBodyOffset.Set(-5, -7);
+			bodyStartPat = BPAT_CONRICETTARIGHT_START;
+			headLoopPat = PAT_TALK_RIGHT;
+			bodyLoopPat = BPAT_CONRICETTARIGHT_LOOP;
+			break;
+		}
+		break;
+
+	case TALK_CONCARTE:
+		switch (m_TalkDirection) {
+		case LEFT:
+		case UP:
+			m_nBodyOffset.Set(-34, -2);
+			bodyStartPat = BPAT_CONCARTELEFT_START;
+			headLoopPat = PAT_TALK_LEFT;
+			bodyLoopPat = BPAT_CONCARTELEFT_LOOP;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			m_nBodyOffset.Set(-4, -2);
+			bodyStartPat = BPAT_CONCARTERIGHT_START;
+			headLoopPat = PAT_TALK_RIGHT;
+			bodyLoopPat = BPAT_CONCARTERIGHT_LOOP;
+			break;
+		}
+		break;
+
+	case TALK_CONPUPAZZO:
+		switch (m_TalkDirection) {
+		case LEFT:
+		case UP:
+			m_nBodyOffset.Set(-35, 2);
+			bodyStartPat = BPAT_CONPUPAZZOLEFT_START;
+			headLoopPat = PAT_TALK_LEFT;
+			bodyLoopPat = BPAT_CONPUPAZZOLEFT_LOOP;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			m_nBodyOffset.Set(-14, 2);
+			bodyStartPat = BPAT_CONPUPAZZORIGHT_START;
+			headLoopPat = PAT_TALK_RIGHT;
+			bodyLoopPat = BPAT_CONPUPAZZORIGHT_LOOP;
+			break;
+		}
+		break;
+
+	case TALK_CONPUPAZZOSTATIC:
+	case TALK_CONRICETTASTATIC:
+	case TALK_CONCONIGLIOSTATIC:
+	case TALK_CONCARTESTATIC:
+	case TALK_CONTACCUINOSTATIC:
+	case TALK_CONMEGAFONOSTATIC:
+		switch (m_TalkDirection) {
+		case LEFT:
+		case UP:
+			headLoopPat = PAT_TALK_LEFT;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			headLoopPat = PAT_TALK_RIGHT;
+			break;
+		}
+		break;
+
+	// La barba è l'unico caso in cui la testa è animata a parte
+	//  mentre il corpo è quello standard
+	case TALK_CONBARBASTATIC:
+		switch (m_TalkDirection) {
+		case LEFT:
+		case UP:
+			headLoopPat = PAT_TALKBARBA_LEFT;
+			bodyLoopPat = BPAT_STANDLEFT;
+			m_nBodyOffset.Set(6, 56);
+			break;
+
+		case DOWN:
+		case RIGHT:
+			headLoopPat = PAT_TALKBARBA_RIGHT;
+			bodyLoopPat = BPAT_STANDRIGHT;
+			m_nBodyOffset.Set(6, 56);
+			break;
+		}
+		break;
+	
+	case TALK_SCHIFATO:
+		switch (m_TalkDirection) {
+		case LEFT:
+		case UP:
+			m_nBodyOffset.Set(6, 56);
+			headStartPat = PAT_SCHIFATOLEFT_START;
+			bodyStartPat = BPAT_STANDLEFT;
+			headLoopPat = PAT_SCHIFATOLEFT_LOOP;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			m_nBodyOffset.Set(6, 56);
+			headStartPat = PAT_SCHIFATORIGHT_START;
+			bodyStartPat = BPAT_STANDRIGHT;
+			headLoopPat = PAT_SCHIFATORIGHT_LOOP;
+			break;
+		}
+		break;
+
+	case TALK_NAAH:
+		switch (m_TalkDirection) {
+		case LEFT:
+		case UP:
+			m_nBodyOffset.Set(6, 56);
+			headStartPat = PAT_NAAHLEFT_START;
+			bodyStartPat = BPAT_STANDLEFT;
+			headLoopPat = PAT_NAAHLEFT_LOOP;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			m_nBodyOffset.Set(6, 56);
+			headStartPat = PAT_NAAHRIGHT_START;
+			bodyStartPat = BPAT_STANDRIGHT;
+			headLoopPat = PAT_NAAHRIGHT_LOOP;
+			break;
+		}
+		break;
+
+	case TALK_MACBETH1:
+		m_nBodyOffset.Set(-33, -1);
+		headLoopPat = PAT_TALK_LEFT;
+		bodyLoopPat = BPAT_MACBETH1;
+		break;
+	case TALK_MACBETH2:
+		m_nBodyOffset.Set(-33, -1);
+		headLoopPat = PAT_TALK_LEFT;
+		bodyLoopPat = BPAT_MACBETH2;
+		break;
+	case TALK_MACBETH3:
+		m_nBodyOffset.Set(-33, -1);
+		headLoopPat = PAT_TALK_LEFT;
+		bodyLoopPat = BPAT_MACBETH3;
+		break;
+	case TALK_MACBETH4:
+		m_nBodyOffset.Set(-33, -1);
+		headLoopPat = PAT_TALK_LEFT;
+		bodyLoopPat = BPAT_MACBETH4;
+		break;
+	case TALK_MACBETH5:
+		m_nBodyOffset.Set(-33, -1);
+		headLoopPat = PAT_TALK_LEFT;
+		bodyLoopPat = BPAT_MACBETH5;
+		break;
+	case TALK_MACBETH6:
+		m_nBodyOffset.Set(-33, -1);
+		headLoopPat = PAT_TALK_LEFT;
+		bodyLoopPat = BPAT_MACBETH6;
+		break;
+	case TALK_MACBETH7:
+		m_nBodyOffset.Set(-33, -1);
+		headLoopPat = PAT_TALK_LEFT;
+		bodyLoopPat = BPAT_MACBETH7;
+		break;
+	case TALK_MACBETH8:
+		m_nBodyOffset.Set(-33, -1);
+		headLoopPat = PAT_TALK_LEFT;
+		bodyLoopPat = BPAT_MACBETH8;
+		break;
+	case TALK_MACBETH9:
+		m_nBodyOffset.Set(-33, -1);
+		headLoopPat = PAT_TALK_LEFT;
+		bodyLoopPat = BPAT_MACBETH9;
+		break;
+
+	case TALK_SPAVENTATOSTATIC:
+		m_bCorpoDavanti = false;
+		switch (m_TalkDirection) {
+		case DOWN:
+			bodyStartPat = BPAT_STANDDOWN;
+			bodyLoopPat = BPAT_STANDDOWN;
+			m_nBodyOffset.Set(4, 53);
+
+			headStartPat = PAT_SPAVENTODOWN_STAND;
+			headLoopPat = PAT_SPAVENTODOWN_LOOP;
+			break;
+
+		case RIGHT:
+			bodyStartPat = BPAT_STANDRIGHT;
+			bodyLoopPat = BPAT_STANDRIGHT;
+			m_nBodyOffset.Set(6, 56);
+
+			headStartPat = PAT_SPAVENTORIGHT_STAND;
+			headLoopPat = PAT_SPAVENTORIGHT_LOOP;
+			break;
+
+		case LEFT:
+			bodyStartPat = BPAT_STANDLEFT;
+			bodyLoopPat = BPAT_STANDLEFT;
+			m_nBodyOffset.Set(6, 56);
+
+			headStartPat = PAT_SPAVENTOLEFT_STAND;
+			headLoopPat = PAT_SPAVENTOLEFT_LOOP;
+			break;
+		}
+		break;
+	}			
+
+	// Esegue il set dei pattern vero e proprio
+	if (headStartPat != 0 || bodyStartPat != 0) {
+		MainFreeze();
+		SetPattern(headStartPat);
+		m_body.SetPattern(bodyStartPat);
+		MainUnfreeze();
+	
+		if (bodyStartPat!=0)
+			m_body.WaitForEndPattern();
+		if (headStartPat!=0)
+			WaitForEndPattern();
+	}
+	
+	MainFreeze();
+	SetPattern(headLoopPat);
+	if (bodyLoopPat)
+		m_body.SetPattern(bodyLoopPat);
+	MainUnfreeze();
+}
+
+
+void RMTony::EndTalk(void) {
+	int headStandPat = 0;
+	int headEndPat = 0;
+	int bodyEndPat = 0;
+	int finalPat = 0;
+	bool bStatic = false;
+
+	bodyEndPat = 0;
+	headEndPat = 0;
+	
+	switch (m_TalkDirection) {
+	case UP:
+		finalPat = PAT_STANDUP;
+		headStandPat = PAT_TESTA_UP;
+		break;
+
+	case DOWN:
+		finalPat = PAT_STANDDOWN;
+		headStandPat = PAT_TESTA_DOWN;
+		break;
+
+	case LEFT:
+		finalPat = PAT_STANDLEFT;
+		headStandPat = PAT_TESTA_LEFT;
+		break;
+
+	case RIGHT:
+		finalPat = PAT_STANDRIGHT;
+		headStandPat = PAT_TESTA_RIGHT;
+		break;
+	}
+
+	if (m_bPastorella) {
+		MainFreeze();
+		SetPattern(finalPat);
+		MainUnfreeze();
+  		m_bIsTalking = false; 
+		return;
+	}
+
+
+	bStatic = false;
+	switch (m_nTalkType) {
+	case TALK_NORMAL:
+		bodyEndPat = 0;
+		break;
+
+	case TALK_FIANCHI:
+		switch (m_TalkDirection) {
+		case UP:
+			bodyEndPat = BPAT_FIANCHIUP_END;
+			break;
+
+		case DOWN:
+			bodyEndPat = BPAT_FIANCHIDOWN_END;
+			break;
+
+		case LEFT:
+			bodyEndPat = BPAT_FIANCHILEFT_END;
+			break;
+
+		case RIGHT:	
+			bodyEndPat = BPAT_FIANCHIRIGHT_END;
+			break;
+		}
+		break;
+
+	case TALK_CANTA:
+		bodyEndPat = BPAT_CANTALEFT_END;
+		break;
+
+	case TALK_RIDE:
+	case TALK_RIDE2:
+		if (m_TalkDirection==LEFT)
+			headEndPat = PAT_RIDELEFT_END;
+		else if (m_TalkDirection==RIGHT)
+			headEndPat = PAT_RIDERIGHT_END;
+			
+		bodyEndPat = 0;
+		break;
+
+	case TALK_SCHIFATO:
+		switch (m_TalkDirection) {	
+		case UP:
+		case LEFT:
+			headEndPat = PAT_SCHIFATOLEFT_END;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			headEndPat = PAT_SCHIFATORIGHT_END;
+			break;
+		}
+			
+		bodyEndPat = 0;
+		break;
+
+	case TALK_NAAH:
+		switch (m_TalkDirection) {	
+		case UP:
+		case LEFT:
+			headEndPat = PAT_NAAHLEFT_END;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			headEndPat = PAT_NAAHRIGHT_END;
+			break;
+		}
+			
+		bodyEndPat = 0;
+		break;
+
+	case TALK_SIINDICA:
+		break;
+
+	case TALK_SPAVENTATO:
+		switch (m_TalkDirection) {	
+		case UP:
+			bodyEndPat = BPAT_SPAVENTOUP_END;
+			break;
+
+		case DOWN:
+			headEndPat = PAT_SPAVENTODOWN_END;
+			bodyEndPat = BPAT_SPAVENTODOWN_END;
+			break;
+
+		case RIGHT:
+			headEndPat = PAT_SPAVENTORIGHT_END;
+			bodyEndPat = BPAT_SPAVENTORIGHT_END;
+			break;
+
+		case LEFT:
+			headEndPat = PAT_SPAVENTOLEFT_END;
+			bodyEndPat = BPAT_SPAVENTOLEFT_END;
+			break;
+		}
+		break;
+
+	case TALK_SPAVENTATO2:
+		switch (m_TalkDirection) {	
+		case UP:
+			bodyEndPat = 0;
+			break;
+
+		case DOWN:
+			headEndPat = PAT_SPAVENTODOWN_END;
+			bodyEndPat = 0;
+			break;
+
+		case RIGHT:
+			headEndPat = PAT_SPAVENTORIGHT_END;
+			bodyEndPat = 0;
+			break;
+
+		case LEFT:
+			headEndPat = PAT_SPAVENTOLEFT_END;
+			bodyEndPat = 0;
+			break;
+		}
+		break;
+
+	case TALK_CONCONIGLIO:
+		switch (m_TalkDirection) {	
+		case UP:
+		case LEFT:
+			finalPat = PAT_STANDLEFT;
+			bodyEndPat = BPAT_CONCONIGLIOLEFT_END;
+			break;
+
+		case RIGHT:
+		case DOWN:
+			finalPat = PAT_STANDRIGHT;
+			bodyEndPat = BPAT_CONCONIGLIORIGHT_END;
+			break;
+		}
+		break;
+
+	case TALK_CONRICETTA:
+		switch (m_TalkDirection) {	
+		case UP:
+		case LEFT:
+			finalPat = PAT_STANDLEFT;
+			bodyEndPat = BPAT_CONRICETTALEFT_END;
+			break;
+
+		case RIGHT:
+		case DOWN:
+			finalPat = PAT_STANDRIGHT;
+			bodyEndPat = BPAT_CONRICETTARIGHT_END;
+			break;
+		}
+		break;
+
+	case TALK_CONCARTE:
+		switch (m_TalkDirection) {	
+		case UP:
+		case LEFT:
+			finalPat = PAT_STANDLEFT;
+			bodyEndPat = BPAT_CONCARTELEFT_END;
+			break;
+
+		case RIGHT:
+		case DOWN:
+			finalPat = PAT_STANDRIGHT;
+			bodyEndPat = BPAT_CONCARTERIGHT_END;
+			break;
+		}
+		break;
+
+	case TALK_CONPUPAZZO:
+		switch (m_TalkDirection) {	
+		case UP:
+		case LEFT:
+			finalPat = PAT_STANDLEFT;
+			bodyEndPat = BPAT_CONPUPAZZOLEFT_END;
+			break;
+
+		case RIGHT:
+		case DOWN:
+			finalPat = PAT_STANDRIGHT;
+			bodyEndPat = BPAT_CONPUPAZZORIGHT_END;
+			break;
+		}
+		break;
+
+	case TALK_CONVERME:
+		finalPat = PAT_CONVERME;
+		break;
+	case TALK_CONCORDA:
+		finalPat = PAT_CONCORDA;
+		break;
+	case TALK_CONSEGRETARIA:
+		finalPat = PAT_CONSEGRETARIA;
+		break;
+	case TALK_CONMARTELLO:
+		finalPat = PAT_CONMARTELLO;
+		break;
+	case TALK_CONBICCHIERE:
+		finalPat = PAT_CONBICCHIERE;
+		break;
+
+	case TALK_MACBETH1:
+	case TALK_MACBETH2:
+	case TALK_MACBETH3:
+	case TALK_MACBETH4:
+	case TALK_MACBETH5:
+	case TALK_MACBETH6:
+	case TALK_MACBETH7:
+	case TALK_MACBETH8:
+		finalPat = 0;
+		break;
+
+	case TALK_SPAVENTATOSTATIC:
+		switch (m_TalkDirection) {	
+		case DOWN:
+			headStandPat = PAT_SPAVENTODOWN_STAND;
+			bodyEndPat = 0;
+			break;
+
+		case RIGHT:
+			headStandPat = PAT_SPAVENTORIGHT_STAND;
+			bodyEndPat = 0;
+			break;
+
+		case LEFT:
+			headStandPat = PAT_SPAVENTOLEFT_STAND;
+			bodyEndPat = 0;
+			break;
+		}
+		break;
+	}
+
+	// Gestisce la fine di una animazione static lasciando tutto invariato
+	if (m_bIsStaticTalk) {
+		if (m_nTalkType == TALK_CONBARBASTATIC) {
+			MainFreeze();
+			SetPattern(0);
+			if (m_TalkDirection == UP || m_TalkDirection == LEFT) {
+				m_body.SetPattern(BPAT_CONBARBALEFT_STATIC);
+				m_nBodyOffset.Set(-41, -14);
+			} else if (m_TalkDirection == DOWN || m_TalkDirection == RIGHT) {
+				m_body.SetPattern(BPAT_CONBARBARIGHT_STATIC);
+				m_nBodyOffset.Set(-26, -14);
+			}
+			MainUnfreeze();
+		} else {
+			MainFreeze();
+			SetPattern(headStandPat);
+			MainUnfreeze();
+
+			m_body.WaitForEndPattern();
+		}
+
+		m_bIsTalking = false;  
+		return;
+	}
+
+	// Set dei pattern
+	if (headEndPat != 0 && bodyEndPat != 0) {
+		MainFreeze();
+		SetPattern(headEndPat);
+		MainUnfreeze();
+
+		m_body.WaitForEndPattern();
+
+		MainFreeze();
+		m_body.SetPattern(bodyEndPat);
+		MainUnfreeze();
+		
+		WaitForEndPattern();
+		m_body.WaitForEndPattern();
+	} else if (bodyEndPat != 0) {
+		MainFreeze();
+		SetPattern(headStandPat);
+		MainUnfreeze();
+
+		m_body.WaitForEndPattern();
+
+		MainFreeze();
+		m_body.SetPattern(bodyEndPat);
+		MainUnfreeze();
+		
+		m_body.WaitForEndPattern();
+	} else if (headEndPat != 0) {
+		m_body.WaitForEndPattern();
+
+		MainFreeze();
+		SetPattern(headEndPat);
+		MainUnfreeze();
+
+		WaitForEndPattern();
+	} else {
+		m_body.WaitForEndPattern();
+	}
+
+	if (finalPat != 0) {
+		MainFreeze();
+		m_body.SetPattern(0);
+		SetPattern(finalPat);
+		MainUnfreeze();
+	}
+
+	m_bIsTalking = false;  
+}
+
+void RMTony::StartStatic(TALKTYPE nTalk) {
+	int nPat = 0;
+	int headPat = 0, headLoopPat = 0;
+	int bodyStartPat = 0;
+	int bodyLoopPat = 0;
+
+	nPat = GetCurPattern();
+
+	headLoopPat = -1;
+
+	switch (nPat) {
+	case PAT_STANDDOWN:
+		m_TalkDirection=DOWN;
+		headPat = PAT_TESTA_RIGHT;
+		break;
+
+	case PAT_TAKELEFT_UP2:
+	case PAT_TAKELEFT_MID2:
+	case PAT_TAKELEFT_DOWN2:
+	case PAT_SIRIALZALEFT:
+	case PAT_STANDLEFT:
+		m_TalkDirection=LEFT;
+		headPat = PAT_TESTA_LEFT;
+		break;
+		
+	case PAT_TAKERIGHT_UP2:
+	case PAT_TAKERIGHT_MID2:
+	case PAT_TAKERIGHT_DOWN2:
+	case PAT_SIRIALZARIGHT:
+	case PAT_STANDRIGHT:
+		m_TalkDirection=RIGHT;
+		headPat = PAT_TESTA_RIGHT;
+		break;
+
+	case PAT_TAKEUP_UP2:
+	case PAT_TAKEUP_MID2:
+	case PAT_TAKEUP_DOWN2:
+	case PAT_STANDUP:
+		m_TalkDirection=UP;
+		headPat = PAT_TESTA_LEFT;
+		break;
+	}
+
+	m_bCorpoDavanti = true;
+
+	switch (nTalk) {
+	case TALK_CONCONIGLIOSTATIC:
+		switch (m_TalkDirection) {
+		case UP:
+		case LEFT:
+			m_nBodyOffset.Set(-21, -5);
+			bodyStartPat = BPAT_CONCONIGLIOLEFT_START;
+			bodyLoopPat = BPAT_CONCONIGLIOLEFT_LOOP;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			m_nBodyOffset.Set(-4, -5);
+			bodyStartPat = BPAT_CONCONIGLIORIGHT_START;
+			bodyLoopPat = BPAT_CONCONIGLIORIGHT_LOOP;
+			break;
+		}
+		break;
+
+	case TALK_CONCARTESTATIC:
+		switch (m_TalkDirection) {
+		case UP:
+		case LEFT:
+			m_nBodyOffset.Set(-34, -2);
+			bodyStartPat = BPAT_CONCARTELEFT_START;
+			bodyLoopPat = BPAT_CONCARTELEFT_LOOP;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			m_nBodyOffset.Set(-4, -2);
+			bodyStartPat = BPAT_CONCARTERIGHT_START;
+			bodyLoopPat = BPAT_CONCARTERIGHT_LOOP;
+			break;
+		}
+		break;
+
+	case TALK_CONRICETTASTATIC:
+		switch (m_TalkDirection) {
+		case UP:
+		case LEFT:
+			m_nBodyOffset.Set(-61, -7);
+			bodyStartPat = BPAT_CONRICETTALEFT_START;
+			bodyLoopPat = BPAT_CONRICETTALEFT_LOOP;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			m_nBodyOffset.Set(-5, -7);
+			bodyStartPat = BPAT_CONRICETTARIGHT_START;
+			bodyLoopPat = BPAT_CONRICETTARIGHT_LOOP;
+			break;
+		}
+		break;
+
+	case TALK_CONPUPAZZOSTATIC:
+		switch (m_TalkDirection) {
+		case UP:
+		case LEFT:
+			m_nBodyOffset.Set(-35, 2);
+			bodyStartPat = BPAT_CONPUPAZZOLEFT_START;
+			bodyLoopPat = BPAT_CONPUPAZZOLEFT_LOOP;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			m_nBodyOffset.Set(-14, 2);
+			bodyStartPat = BPAT_CONPUPAZZORIGHT_START;
+			bodyLoopPat = BPAT_CONPUPAZZORIGHT_LOOP;
+			break;
+		}
+		break;
+
+	case TALK_CONTACCUINOSTATIC:
+		switch (m_TalkDirection) {
+		case UP:
+		case LEFT:
+			m_nBodyOffset.Set(-16, -9);
+			bodyStartPat = BPAT_CONTACCUINOLEFT_START;
+			bodyLoopPat = BPAT_CONTACCUINOLEFT_LOOP;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			m_nBodyOffset.Set(-6, -9);
+			bodyStartPat = BPAT_CONTACCUINORIGHT_START;
+			bodyLoopPat = BPAT_CONTACCUINORIGHT_LOOP;
+			break;
+		}
+		break;
+
+	case TALK_CONMEGAFONOSTATIC:
+		switch (m_TalkDirection) {
+		case UP:
+		case LEFT:
+			m_nBodyOffset.Set(-41, -8);
+			bodyStartPat = BPAT_CONMEGAFONOLEFT_START;
+			bodyLoopPat = BPAT_CONMEGAFONOLEFT_LOOP;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			m_nBodyOffset.Set(-14, -8);
+			bodyStartPat = BPAT_CONMEGAFONORIGHT_START;
+			bodyLoopPat = BPAT_CONMEGAFONORIGHT_LOOP;
+			break;
+		}
+		break;
+
+	case TALK_CONBARBASTATIC:
+		switch (m_TalkDirection) {
+		case UP:
+		case LEFT:
+			m_nBodyOffset.Set(-41, -14);
+			bodyStartPat = BPAT_CONBARBALEFT_START;
+			bodyLoopPat = BPAT_STANDLEFT;
+			headLoopPat = PAT_TALKBARBA_LEFT;
+			headPat = 0;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			m_nBodyOffset.Set(-26, -14);
+			bodyStartPat = BPAT_CONBARBARIGHT_START;
+			bodyLoopPat = BPAT_STANDRIGHT;
+			headLoopPat = PAT_TALKBARBA_RIGHT;
+			headPat = 0;
+			break;
+		}
+		break;
+
+	case TALK_SPAVENTATOSTATIC:
+		switch (m_TalkDirection) {
+		case DOWN:
+			headPat = PAT_SPAVENTODOWN_START;
+			bodyLoopPat = BPAT_STANDDOWN;
+			bodyStartPat = BPAT_STANDDOWN;
+			headLoopPat = PAT_SPAVENTODOWN_STAND;
+			m_nBodyOffset.Set(4, 53);
+			break;
+
+		case LEFT:
+			headPat = PAT_SPAVENTOLEFT_START;
+			bodyLoopPat = BPAT_STANDLEFT;
+			bodyStartPat = BPAT_STANDLEFT;
+			headLoopPat = PAT_SPAVENTOLEFT_STAND;
+			m_nBodyOffset.Set(6, 56);
+			break;
+
+		case RIGHT:
+			headPat = PAT_SPAVENTORIGHT_START;
+			bodyLoopPat = BPAT_STANDRIGHT;
+			bodyStartPat = BPAT_STANDRIGHT;
+			headLoopPat = PAT_SPAVENTORIGHT_STAND;
+			m_nBodyOffset.Set(6, 56);
+			break;
+		}
+	}
+
+	// e vai con i pattern
+	m_bIsStaticTalk = true;
+
+	MainFreeze();
+	SetPattern(headPat);
+	m_body.SetPattern(bodyStartPat);
+	MainUnfreeze();
+
+	m_body.WaitForEndPattern();	
+	WaitForEndPattern();
+
+	MainFreeze();
+	if (headLoopPat != -1)
+		SetPattern(headLoopPat);
+	m_body.SetPattern(bodyLoopPat);
+	MainUnfreeze();
+}
+
+
+void RMTony::EndStatic(TALKTYPE nTalk) {
+	int bodyEndPat = 0;
+	int finalPat = 0;
+	int headEndPat = 0;
+
+	switch (m_TalkDirection) {
+	case UP:
+	case LEFT:
+		finalPat = PAT_STANDLEFT;
+		break;
+
+	case RIGHT:
+	case DOWN:
+		finalPat = PAT_STANDRIGHT;
+		break;
+	}
+
+	switch (nTalk) {
+	case TALK_CONPUPAZZOSTATIC:
+		switch (m_TalkDirection) {
+		case UP: case LEFT:
+			bodyEndPat = BPAT_CONPUPAZZOLEFT_END;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			bodyEndPat = BPAT_CONPUPAZZORIGHT_END;
+			break;
+		}
+		break;
+
+	case TALK_CONRICETTASTATIC:
+		switch (m_TalkDirection) {
+		case UP:
+		case LEFT:
+			bodyEndPat = BPAT_CONRICETTALEFT_END;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			bodyEndPat = BPAT_CONRICETTARIGHT_END;
+			break;
+		}
+		break;
+
+	case TALK_CONCONIGLIOSTATIC:
+		switch (m_TalkDirection) {
+		case UP:
+		case LEFT:
+			bodyEndPat = BPAT_CONCONIGLIOLEFT_END;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			bodyEndPat = BPAT_CONCONIGLIORIGHT_END;
+			break;
+		}
+		break;
+	
+	case TALK_CONCARTESTATIC:
+		switch (m_TalkDirection) {
+		case UP:
+		case LEFT:
+			bodyEndPat = BPAT_CONCARTELEFT_END;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			bodyEndPat = BPAT_CONCARTERIGHT_END;
+			break;
+		}
+		break;
+
+	case TALK_CONTACCUINOSTATIC:
+		switch (m_TalkDirection) {
+		case UP:
+		case LEFT:
+			bodyEndPat = BPAT_CONTACCUINOLEFT_END;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			bodyEndPat = BPAT_CONTACCUINORIGHT_END;
+			break;
+		}
+		break;
+
+	case TALK_CONMEGAFONOSTATIC:
+		switch (m_TalkDirection) {
+		case UP:
+		case LEFT:
+			bodyEndPat = BPAT_CONMEGAFONOLEFT_END;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			bodyEndPat = BPAT_CONMEGAFONORIGHT_END;
+			break;
+		}
+		break;
+
+	case TALK_CONBARBASTATIC:
+		switch (m_TalkDirection) {
+		case UP:
+		case LEFT:
+			bodyEndPat = BPAT_CONBARBALEFT_END;
+			break;
+
+		case DOWN:
+		case RIGHT:
+			bodyEndPat = BPAT_CONBARBARIGHT_END;
+			break;
+		}
+		break;
+
+	case TALK_SPAVENTATOSTATIC:
+		switch (m_TalkDirection) {
+		case LEFT:
+			headEndPat = PAT_SPAVENTOLEFT_END;
+			break;
+
+		case DOWN:
+			headEndPat = PAT_SPAVENTODOWN_END;
+			break;
+
+		case RIGHT:
+			headEndPat = PAT_SPAVENTORIGHT_END;
+			break;
+		}
+		break;
+	}
+
+	if (headEndPat != 0) {
+		MainFreeze();
+		SetPattern(headEndPat);
+		MainUnfreeze();
+
+		WaitForEndPattern();	
+	} else {
+		// Play please
+		MainFreeze();
+		m_body.SetPattern(bodyEndPat);
+		MainUnfreeze();
+
+		m_body.WaitForEndPattern();	
+	}
+
+	MainFreeze();
+	SetPattern(finalPat);
+	m_body.SetPattern(0);
+	MainUnfreeze();
+	
+	m_bIsStaticTalk = false;
+}
+
+} // End of namespace Tony
-- 
cgit v1.2.3


From 6d0f1fca46c8bd9b5b4e7ccaf6631850c29d1447 Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Thu, 3 May 2012 23:08:19 +1000
Subject: TONY: Formatting fixes

---
 engines/tony/tonychar.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 493f10ef29..7809d9c080 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -126,7 +126,7 @@ void RMTony::DoFrame(RMGfxTargetBuffer *bigBuf, int curLoc) {
 	// Esegue il movimento normale del personaggio
 	int time = _vm->GetTime();
 
-	do 	{
+	do {
 		m_nTimeLastStep += (1000 / 40);
 		RMCharacter::DoFrame(bigBuf, curLoc);
 
@@ -155,8 +155,8 @@ void RMTony::Hide(bool bShowOmbra) {
 
 void RMTony::Draw(RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 	// Richiama il Draw() della classe madre se tony è visibile
-	if (m_bShow && bDrawNow) 	{
-		if (m_bCorpoDavanti) 		{
+	if (m_bShow && bDrawNow) {
+		if (m_bCorpoDavanti) {
 			prim->Dst().SetEmpty();
 			prim->Dst().Offset(-44, -134);
 			if (m_bPastorella)
-- 
cgit v1.2.3


From 23cd3b7730c292539649578d1aea373812e6b4ce Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Fri, 4 May 2012 22:28:51 +1000
Subject: TONY: Fixed many warnings identified by gcc

---
 engines/tony/tonychar.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 7809d9c080..b7ecb3c0d4 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -1357,6 +1357,9 @@ void RMTony::EndTalk(void) {
 			break;
 		}
 		break;
+
+	default:
+		break;
 	}
 
 	// Gestisce la fine di una animazione static lasciando tutto invariato
@@ -1634,6 +1637,9 @@ void RMTony::StartStatic(TALKTYPE nTalk) {
 			m_nBodyOffset.Set(6, 56);
 			break;
 		}
+
+	default:
+		break;
 	}
 
 	// e vai con i pattern
@@ -1783,8 +1789,14 @@ void RMTony::EndStatic(TALKTYPE nTalk) {
 		case RIGHT:
 			headEndPat = PAT_SPAVENTORIGHT_END;
 			break;
+
+		default:
+			break;
 		}
 		break;
+
+	default:
+		break;
 	}
 
 	if (headEndPat != 0) {
-- 
cgit v1.2.3


From 3184a5a874f3cfaa75424e7efb21f1cca3702988 Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Fri, 4 May 2012 22:58:42 +1000
Subject: TONY: Fix warnings about return values not being used

---
 engines/tony/tonychar.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index b7ecb3c0d4..12a8c8eabb 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -1061,6 +1061,9 @@ void RMTony::StartTalk(TALKTYPE nTalkType) {
 			headStartPat = PAT_SPAVENTOLEFT_STAND;
 			headLoopPat = PAT_SPAVENTOLEFT_LOOP;
 			break;
+
+		default:
+			break;
 		}
 		break;
 	}			
@@ -1355,6 +1358,10 @@ void RMTony::EndTalk(void) {
 			headStandPat = PAT_SPAVENTOLEFT_STAND;
 			bodyEndPat = 0;
 			break;
+
+
+		default:
+			break;
 		}
 		break;
 
@@ -1636,6 +1643,9 @@ void RMTony::StartStatic(TALKTYPE nTalk) {
 			headLoopPat = PAT_SPAVENTORIGHT_STAND;
 			m_nBodyOffset.Set(6, 56);
 			break;
+
+		default:
+			break;
 		}
 
 	default:
-- 
cgit v1.2.3


From 657d93ea8f5e123024c4618b8a3dc441a9f45cbc Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Sat, 5 May 2012 09:31:21 +1000
Subject: TONY: Fix some Valgrind identified warnings

---
 engines/tony/tonychar.cpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 12a8c8eabb..a2648318fe 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -82,6 +82,17 @@ void RMTony::Init(void) {
 	RMRes body(9999);
 	RMDataStream ds;
 
+	// Mostra Tony di default
+	m_bShow=m_bShowOmbra = true;
+
+	// Nessuna azione in attesa
+	m_bActionPending = false;
+	m_bAction = false;
+
+	m_bPastorella = false;
+	m_bIsTalking = false;
+	m_bIsStaticTalk = false;
+
 	// Apre il buffer
 	ds.OpenBuffer(tony);
 
@@ -97,17 +108,6 @@ void RMTony::Init(void) {
 	ds.Close();
 	m_body.SetPattern(0);
 
-	// Mostra Tony di default
-	m_bShow=m_bShowOmbra = true;
-
-  // Nessuna azione in attesa
-	m_bActionPending = false;
-	m_bAction = false;
-
-	m_bPastorella = false;
-	m_bIsTalking = false;
-	m_bIsStaticTalk = false;
-
 	m_nTimeLastStep = _vm->GetTime();
 }
 
-- 
cgit v1.2.3


From 10deebed553fc5d458a20756d963835aa1a86afe Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Sun, 6 May 2012 12:21:29 +1000
Subject: TONY: Beginnings of refactoring Tony engine's threads to use
 coroutines

---
 engines/tony/tonychar.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index a2648318fe..e4f334d0e5 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -224,7 +224,7 @@ void RMTony::ExecuteAction(int nAction, int nActionItem, int nParm) {
 			}
 		}
 	} else {
-		// Esegue l'azione
+		// Perform the action
 		hThread = mpalQueryDoAction(nAction, nActionItem, 0); 
 	}
 					
-- 
cgit v1.2.3


From 770e55d06578f7f51959ea331da7baaaaa0e360d Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Sun, 6 May 2012 15:18:03 +1000
Subject: TONY: Further conversion of initially launched threads to processes.

This includes all the dependent routines that they call.
---
 engines/tony/tonychar.cpp | 32 +++++++++++++++++++++-----------
 1 file changed, 21 insertions(+), 11 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index e4f334d0e5..de6189876b 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -59,11 +59,19 @@ namespace Tony {
 
 bool RMTony::m_bAction = false;
 
-uint32 RMTony::WaitEndOfAction(HANDLE hThread) {
-	WaitForSingleObject(hThread, INFINITE);
+void RMTony::WaitEndOfAction(CORO_PARAM, const void *param) {
+	CORO_BEGIN_CONTEXT;
+	CORO_END_CONTEXT(_ctx);
+
+	uint32 pid = *(const uint32 *)param;
+
+	CORO_BEGIN_CODE(_ctx);
+
+	CORO_INVOKE_2(_vm->_scheduler.waitForSingleObject, pid, INFINITE);
+
 	m_bAction = false;
 
-	return 1;
+	CORO_END_CODE;
 }
 
 RMGfxSourceBuffer *RMTony::NewItemSpriteBuffer(int dimx, int dimy, bool bPreRLE) {
@@ -205,6 +213,7 @@ void RMTony::MoveAndDoAction(RMPoint dst, RMItem *item, int nAction, int nAction
 
 void RMTony::ExecuteAction(int nAction, int nActionItem, int nParm) {
 	HANDLE hThread;
+	uint32 pid;
 	
 	if (nAction == TA_COMBINE) {
 		hThread = mpalQueryDoAction(TA_COMBINE, nParm, nActionItem);
@@ -229,27 +238,28 @@ void RMTony::ExecuteAction(int nAction, int nActionItem, int nParm) {
 	}
 					
 	if (hThread != INVALID_HANDLE_VALUE) {
-		uint32 id;
 		m_bAction = true;
-		CreateThread(NULL, 10240,(LPTHREAD_START_ROUTINE)WaitEndOfAction, (void *)hThread, 0, &id);
+		pid = (uint32)hThread;
+		_vm->_scheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
 		hActionThread = hThread;
 	} else if (nAction != TA_GOTO) {
- 		uint32 id;
-
 		if (nAction == TA_TALK) {
 			hThread = mpalQueryDoAction(6, 1, 0); 
 			m_bAction = true;
-			CreateThread(NULL,10240,(LPTHREAD_START_ROUTINE)WaitEndOfAction, (void *)hThread,0,&id);
-  			hActionThread=hThread;
+			pid = (uint32)hThread;
+			_vm->_scheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
+  			hActionThread = hThread;
 		} else if (nAction == TA_PALESATI) {
 			hThread = mpalQueryDoAction(7, 1, 0);
 			m_bAction = true; 
-			CreateThread(NULL,10240,(LPTHREAD_START_ROUTINE)WaitEndOfAction,(void *)hThread, 0, &id);
+			pid = (uint32)hThread;
+			_vm->_scheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
   			hActionThread=hThread;
 		} else {
 			hThread = mpalQueryDoAction(5, 1, 0); 
 			m_bAction = true;
-			CreateThread(NULL, 10240, (LPTHREAD_START_ROUTINE)WaitEndOfAction, (void *)hThread, 0, &id);
+			pid = (uint32)hThread;
+			_vm->_scheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
 			hActionThread = hThread;
 		}
 	}
-- 
cgit v1.2.3


From 8527302057052e784c3ea32ca8eebb0220bf15e6 Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Tue, 8 May 2012 08:25:33 +1000
Subject: TONY: Added support for threading events to scheduler, converted more
 procs to coroutines

---
 engines/tony/tonychar.cpp | 194 ++++++++++++++++++++++++++++++----------------
 1 file changed, 126 insertions(+), 68 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index de6189876b..073ebf2be4 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -519,10 +519,8 @@ void RMTony::Put(int nWhere, int nPart) {
 }
 
 
-void RMTony::StartTalk(TALKTYPE nTalkType) {
-	int headStartPat = 0, bodyStartPat = 0;
-	int headLoopPat = 0, bodyLoopPat = 0;
-	
+bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &bodyStartPat,
+								int &headLoopPat, int &bodyLoopPat) {
 	assert(!m_bIsTalking);
 
 	m_bIsTalking = true;
@@ -585,7 +583,7 @@ void RMTony::StartTalk(TALKTYPE nTalkType) {
 			break;
 		}
 		MainUnfreeze();
-		return;
+		return false;
 	}
 
 	headStartPat = bodyStartPat = 0;
@@ -1077,35 +1075,47 @@ void RMTony::StartTalk(TALKTYPE nTalkType) {
 		}
 		break;
 	}			
+}
+
+void RMTony::StartTalk(CORO_PARAM, TALKTYPE nTalkType) {
+	CORO_BEGIN_CONTEXT;
+		int headStartPat, bodyStartPat;
+		int headLoopPat, bodyLoopPat;
+	CORO_END_CONTEXT(_ctx);
+
+	CORO_BEGIN_CODE(_ctx);
+
+	_ctx->headStartPat = _ctx->bodyStartPat = 0;
+	_ctx->headLoopPat = _ctx->bodyLoopPat = 0;
+
+	if (!StartTalkCalculate(nTalkType, _ctx->headStartPat, _ctx->bodyStartPat,
+			_ctx->headLoopPat, _ctx->bodyLoopPat))
+		return;
 
 	// Esegue il set dei pattern vero e proprio
-	if (headStartPat != 0 || bodyStartPat != 0) {
+	if (_ctx->headStartPat != 0 || _ctx->bodyStartPat != 0) {
 		MainFreeze();
-		SetPattern(headStartPat);
-		m_body.SetPattern(bodyStartPat);
+		SetPattern(_ctx->headStartPat);
+		m_body.SetPattern(_ctx->bodyStartPat);
 		MainUnfreeze();
 	
-		if (bodyStartPat!=0)
-			m_body.WaitForEndPattern();
-		if (headStartPat!=0)
-			WaitForEndPattern();
+		if (_ctx->bodyStartPat != 0)
+			CORO_INVOKE_0(m_body.WaitForEndPattern);
+		if (_ctx->headStartPat != 0)
+			CORO_INVOKE_0(WaitForEndPattern);
 	}
 	
 	MainFreeze();
-	SetPattern(headLoopPat);
-	if (bodyLoopPat)
-		m_body.SetPattern(bodyLoopPat);
+	SetPattern(_ctx->headLoopPat);
+	if (_ctx->bodyLoopPat)
+		m_body.SetPattern(_ctx->bodyLoopPat);
 	MainUnfreeze();
-}
 
+	CORO_END_CODE;
+}
 
-void RMTony::EndTalk(void) {
-	int headStandPat = 0;
-	int headEndPat = 0;
-	int bodyEndPat = 0;
-	int finalPat = 0;
-	bool bStatic = false;
 
+bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPat, int &finalPat, bool &bStatic) {
 	bodyEndPat = 0;
 	headEndPat = 0;
 	
@@ -1136,7 +1146,7 @@ void RMTony::EndTalk(void) {
 		SetPattern(finalPat);
 		MainUnfreeze();
   		m_bIsTalking = false; 
-		return;
+		return false;
 	}
 
 
@@ -1379,6 +1389,28 @@ void RMTony::EndTalk(void) {
 		break;
 	}
 
+	return true;
+}
+
+void RMTony::EndTalk(CORO_PARAM) {
+	CORO_BEGIN_CONTEXT;
+		int headStandPat, headEndPat;
+		int bodyEndPat, finalPat;
+		bool bStatic;
+	CORO_END_CONTEXT(_ctx);
+
+	CORO_BEGIN_CODE(_ctx);
+
+	_ctx->headStandPat = _ctx->headEndPat = 0;
+	_ctx->bodyEndPat = _ctx->finalPat = 0;
+	_ctx->bStatic = false;
+
+	_ctx->bodyEndPat = 0;
+	_ctx->headEndPat = 0;
+
+	if (!EndTalkCalculate(_ctx->headStandPat, _ctx->headEndPat, _ctx->bodyEndPat, _ctx->finalPat, _ctx->bStatic))
+		return;
+
 	// Gestisce la fine di una animazione static lasciando tutto invariato
 	if (m_bIsStaticTalk) {
 		if (m_nTalkType == TALK_CONBARBASTATIC) {
@@ -1394,10 +1426,10 @@ void RMTony::EndTalk(void) {
 			MainUnfreeze();
 		} else {
 			MainFreeze();
-			SetPattern(headStandPat);
+			SetPattern(_ctx->headStandPat);
 			MainUnfreeze();
 
-			m_body.WaitForEndPattern();
+			CORO_INVOKE_0(m_body.WaitForEndPattern);
 		}
 
 		m_bIsTalking = false;  
@@ -1405,60 +1437,58 @@ void RMTony::EndTalk(void) {
 	}
 
 	// Set dei pattern
-	if (headEndPat != 0 && bodyEndPat != 0) {
+	if (_ctx->headEndPat != 0 && _ctx->bodyEndPat != 0) {
 		MainFreeze();
-		SetPattern(headEndPat);
+		SetPattern(_ctx->headEndPat);
 		MainUnfreeze();
 
-		m_body.WaitForEndPattern();
+		CORO_INVOKE_0(m_body.WaitForEndPattern);
 
 		MainFreeze();
-		m_body.SetPattern(bodyEndPat);
+		m_body.SetPattern(_ctx->bodyEndPat);
 		MainUnfreeze();
 		
-		WaitForEndPattern();
-		m_body.WaitForEndPattern();
-	} else if (bodyEndPat != 0) {
+		CORO_INVOKE_0(WaitForEndPattern);
+		CORO_INVOKE_0(m_body.WaitForEndPattern);
+	} else if (_ctx->bodyEndPat != 0) {
 		MainFreeze();
-		SetPattern(headStandPat);
+		SetPattern(_ctx->headStandPat);
 		MainUnfreeze();
 
-		m_body.WaitForEndPattern();
+		CORO_INVOKE_0(m_body.WaitForEndPattern);
 
 		MainFreeze();
-		m_body.SetPattern(bodyEndPat);
+		m_body.SetPattern(_ctx->bodyEndPat);
 		MainUnfreeze();
 		
-		m_body.WaitForEndPattern();
-	} else if (headEndPat != 0) {
-		m_body.WaitForEndPattern();
+		CORO_INVOKE_0(m_body.WaitForEndPattern);
+	} else if (_ctx->headEndPat != 0) {
+		CORO_INVOKE_0(m_body.WaitForEndPattern);
 
 		MainFreeze();
-		SetPattern(headEndPat);
+		SetPattern(_ctx->headEndPat);
 		MainUnfreeze();
 
-		WaitForEndPattern();
+		CORO_INVOKE_0(WaitForEndPattern);
 	} else {
-		m_body.WaitForEndPattern();
+		CORO_INVOKE_0(m_body.WaitForEndPattern);
 	}
 
-	if (finalPat != 0) {
+	if (_ctx->finalPat != 0) {
 		MainFreeze();
 		m_body.SetPattern(0);
-		SetPattern(finalPat);
+		SetPattern(_ctx->finalPat);
 		MainUnfreeze();
 	}
 
 	m_bIsTalking = false;  
-}
 
-void RMTony::StartStatic(TALKTYPE nTalk) {
-	int nPat = 0;
-	int headPat = 0, headLoopPat = 0;
-	int bodyStartPat = 0;
-	int bodyLoopPat = 0;
+	CORO_END_CODE;
+}
 
-	nPat = GetCurPattern();
+void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat,
+						  int &bodyStartPat, int &bodyLoopPat) {
+	int nPat = GetCurPattern();
 
 	headLoopPat = -1;
 
@@ -1661,31 +1691,41 @@ void RMTony::StartStatic(TALKTYPE nTalk) {
 	default:
 		break;
 	}
+}
+
+void RMTony::StartStatic(CORO_PARAM, TALKTYPE nTalk) {
+	CORO_BEGIN_CONTEXT;
+		int headPat, headLoopPat;
+		int bodyStartPat, bodyLoopPat;
+	CORO_END_CONTEXT(_ctx);
+
+	CORO_BEGIN_CODE(_ctx);
+
+	_ctx->headPat = _ctx->headLoopPat = 0;
+	_ctx->bodyStartPat = _ctx->bodyLoopPat = 0;
 
 	// e vai con i pattern
 	m_bIsStaticTalk = true;
 
 	MainFreeze();
-	SetPattern(headPat);
-	m_body.SetPattern(bodyStartPat);
+	SetPattern(_ctx->headPat);
+	m_body.SetPattern(_ctx->bodyStartPat);
 	MainUnfreeze();
 
-	m_body.WaitForEndPattern();	
-	WaitForEndPattern();
+	CORO_INVOKE_0(m_body.WaitForEndPattern);	
+	CORO_INVOKE_0(WaitForEndPattern);
 
 	MainFreeze();
-	if (headLoopPat != -1)
-		SetPattern(headLoopPat);
-	m_body.SetPattern(bodyLoopPat);
+	if (_ctx->headLoopPat != -1)
+		SetPattern(_ctx->headLoopPat);
+	m_body.SetPattern(_ctx->bodyLoopPat);
 	MainUnfreeze();
-}
 
+	CORO_END_CODE;
+}
 
-void RMTony::EndStatic(TALKTYPE nTalk) {
-	int bodyEndPat = 0;
-	int finalPat = 0;
-	int headEndPat = 0;
 
+void RMTony::EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat, int &headEndPat) {
 	switch (m_TalkDirection) {
 	case UP:
 	case LEFT:
@@ -1818,28 +1858,46 @@ void RMTony::EndStatic(TALKTYPE nTalk) {
 	default:
 		break;
 	}
+}
+
+void RMTony::EndStatic(CORO_PARAM, TALKTYPE nTalk) {
+	CORO_BEGIN_CONTEXT;
+		int bodyEndPat;
+		int finalPat;
+		int headEndPat;
+	CORO_END_CONTEXT(_ctx);
 
-	if (headEndPat != 0) {
+	CORO_BEGIN_CODE(_ctx);
+
+	_ctx->bodyEndPat = 0;
+	_ctx->finalPat = 0;
+	_ctx->headEndPat = 0;
+
+	EndStaticCalculate(nTalk, _ctx->bodyEndPat, _ctx->finalPat, _ctx->headEndPat);
+
+	if (_ctx->headEndPat != 0) {
 		MainFreeze();
-		SetPattern(headEndPat);
+		SetPattern(_ctx->headEndPat);
 		MainUnfreeze();
 
-		WaitForEndPattern();	
+		CORO_INVOKE_0(WaitForEndPattern);	
 	} else {
 		// Play please
 		MainFreeze();
-		m_body.SetPattern(bodyEndPat);
+		m_body.SetPattern(_ctx->bodyEndPat);
 		MainUnfreeze();
 
-		m_body.WaitForEndPattern();	
+		CORO_INVOKE_0(m_body.WaitForEndPattern);	
 	}
 
 	MainFreeze();
-	SetPattern(finalPat);
+	SetPattern(_ctx->finalPat);
 	m_body.SetPattern(0);
 	MainUnfreeze();
 	
 	m_bIsStaticTalk = false;
+
+	CORO_END_CODE;
 }
 
 } // End of namespace Tony
-- 
cgit v1.2.3


From a254f100253bda1b23f280226b7b4d909206d49c Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Tue, 8 May 2012 09:32:21 +1000
Subject: TONY: Added support for Windows-style threading events to scheduler

---
 engines/tony/tonychar.cpp | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 073ebf2be4..ad13d49d54 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -67,7 +67,7 @@ void RMTony::WaitEndOfAction(CORO_PARAM, const void *param) {
 
 	CORO_BEGIN_CODE(_ctx);
 
-	CORO_INVOKE_2(_vm->_scheduler.waitForSingleObject, pid, INFINITE);
+	CORO_INVOKE_2(g_scheduler->waitForSingleObject, pid, INFINITE);
 
 	m_bAction = false;
 
@@ -240,26 +240,26 @@ void RMTony::ExecuteAction(int nAction, int nActionItem, int nParm) {
 	if (hThread != INVALID_HANDLE_VALUE) {
 		m_bAction = true;
 		pid = (uint32)hThread;
-		_vm->_scheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
+		g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
 		hActionThread = hThread;
 	} else if (nAction != TA_GOTO) {
 		if (nAction == TA_TALK) {
 			hThread = mpalQueryDoAction(6, 1, 0); 
 			m_bAction = true;
 			pid = (uint32)hThread;
-			_vm->_scheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
+			g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
   			hActionThread = hThread;
 		} else if (nAction == TA_PALESATI) {
 			hThread = mpalQueryDoAction(7, 1, 0);
 			m_bAction = true; 
 			pid = (uint32)hThread;
-			_vm->_scheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
+			g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
   			hActionThread=hThread;
 		} else {
 			hThread = mpalQueryDoAction(5, 1, 0); 
 			m_bAction = true;
 			pid = (uint32)hThread;
-			_vm->_scheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
+			g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
 			hActionThread = hThread;
 		}
 	}
@@ -1074,7 +1074,9 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 		}
 		break;
-	}			
+	}
+
+	return true;
 }
 
 void RMTony::StartTalk(CORO_PARAM, TALKTYPE nTalkType) {
-- 
cgit v1.2.3


From 26898dd7ad399a641f63eabf04aa2d839f8508fc Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Wed, 9 May 2012 00:42:27 +1000
Subject: TONY: Completed bulk of initial coro refactoring

---
 engines/tony/tonychar.cpp | 38 ++++++++++++++++++++++++++------------
 1 file changed, 26 insertions(+), 12 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index ad13d49d54..ea233233d2 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -212,6 +212,7 @@ void RMTony::MoveAndDoAction(RMPoint dst, RMItem *item, int nAction, int nAction
 
 
 void RMTony::ExecuteAction(int nAction, int nActionItem, int nParm) {
+	// fixme: See if hThread can be converted to uint32
 	HANDLE hThread;
 	uint32 pid;
 	
@@ -241,53 +242,64 @@ void RMTony::ExecuteAction(int nAction, int nActionItem, int nParm) {
 		m_bAction = true;
 		pid = (uint32)hThread;
 		g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
-		hActionThread = hThread;
+		hActionThread = pid;
 	} else if (nAction != TA_GOTO) {
 		if (nAction == TA_TALK) {
 			hThread = mpalQueryDoAction(6, 1, 0); 
 			m_bAction = true;
 			pid = (uint32)hThread;
 			g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
-  			hActionThread = hThread;
+  			hActionThread = pid;
 		} else if (nAction == TA_PALESATI) {
 			hThread = mpalQueryDoAction(7, 1, 0);
 			m_bAction = true; 
 			pid = (uint32)hThread;
 			g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
-  			hActionThread=hThread;
+  			hActionThread = pid;
 		} else {
 			hThread = mpalQueryDoAction(5, 1, 0); 
 			m_bAction = true;
 			pid = (uint32)hThread;
 			g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
-			hActionThread = hThread;
+			hActionThread = pid;
 		}
 	}
 }
 
 
-void RMTony::StopNoAction(void) {
+void RMTony::StopNoAction(CORO_PARAM) {
+	CORO_BEGIN_CONTEXT;
+	CORO_END_CONTEXT(_ctx);
+
+	CORO_BEGIN_CODE(_ctx);
+
 	if (m_bAction)
-		WaitForSingleObject(hActionThread, INFINITE);
+		CORO_INVOKE_2(g_scheduler->waitForSingleObject, hActionThread, INFINITE);
 
 	m_bActionPending = false;
 	m_ActionItem = NULL;
-	Stop();
+	CORO_INVOKE_0(Stop);
+
+	CORO_END_CODE;
 }
 
-void RMTony::Stop(void) {
-	HANDLE hThread;
+void RMTony::Stop(CORO_PARAM) {
+	CORO_BEGIN_CONTEXT;
+		uint32 hThread;
+	CORO_END_CONTEXT(_ctx);
+
+	CORO_BEGIN_CODE(_ctx);
 
 	if (m_ActionItem != NULL) {
 		// Richiama l'MPAL per scegliere la direzione
-		hThread = mpalQueryDoAction(21, m_ActionItem->MpalCode(), 0);
+		_ctx->hThread = mpalQueryDoActionU32(21, m_ActionItem->MpalCode(), 0);
 
-		if (hThread==INVALID_HANDLE_VALUE)
+		if (_ctx->hThread == INVALID_PID_VALUE)
 			RMCharacter::Stop();
 		else {
 			bNeedToStop = false;	// Se facciamo la OnWhichDirection, almeno dopo non dobbiamo fare la Stop()
 			bMoving = false;
-			WaitForSingleObject(hThread, INFINITE); // @@@ Mettere un assert dopo 10 secondi
+			CORO_INVOKE_2(g_scheduler->waitForSingleObject, _ctx->hThread, INFINITE); // @@@ Mettere un assert dopo 10 secondi
 		}
 	} else {
 		RMCharacter::Stop();
@@ -301,6 +313,8 @@ void RMTony::Stop(void) {
 	ExecuteAction(m_Action, m_ActionItem->MpalCode(), m_ActionParm);
 	
 	m_ActionItem=NULL;
+
+	CORO_END_CODE;
 }
 
 
-- 
cgit v1.2.3


From 5a069cdc861538fe763de48de8628d7d754f7959 Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Wed, 9 May 2012 23:15:41 +1000
Subject: TONY: Refactored out usage of nullContext in favour of proper
 coroutines

---
 engines/tony/tonychar.cpp | 37 ++++++++++++++++---------------------
 1 file changed, 16 insertions(+), 21 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index ea233233d2..06adcd15b8 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -213,53 +213,48 @@ void RMTony::MoveAndDoAction(RMPoint dst, RMItem *item, int nAction, int nAction
 
 void RMTony::ExecuteAction(int nAction, int nActionItem, int nParm) {
 	// fixme: See if hThread can be converted to uint32
-	HANDLE hThread;
 	uint32 pid;
 	
 	if (nAction == TA_COMBINE) {
-		hThread = mpalQueryDoAction(TA_COMBINE, nParm, nActionItem);
+		pid = mpalQueryDoAction(TA_COMBINE, nParm, nActionItem);
 		
 		// Se è fallito il combine, proviamo con il ReceiveCombine
-		if (hThread == INVALID_HANDLE_VALUE) {
-			hThread = mpalQueryDoAction(TA_RECEIVECOMBINE, nActionItem, nParm); 
+		if (pid == INVALID_PID_VALUE) {
+			pid = mpalQueryDoAction(TA_RECEIVECOMBINE, nActionItem, nParm); 
 			
 			// Se è fallito il receive, andiamo con quelli generici
 			// @@@ CombineGive!
-			if (hThread == INVALID_HANDLE_VALUE) {
-				hThread = mpalQueryDoAction(TA_COMBINE, nParm, 0);
+			if (pid == INVALID_PID_VALUE) {
+				pid = mpalQueryDoAction(TA_COMBINE, nParm, 0);
 				
-				if (hThread == INVALID_HANDLE_VALUE){
-					hThread = mpalQueryDoAction(TA_RECEIVECOMBINE, nActionItem, 0);
+				if (pid == INVALID_PID_VALUE){
+					pid = mpalQueryDoAction(TA_RECEIVECOMBINE, nActionItem, 0);
 				}
 			}
 		}
 	} else {
 		// Perform the action
-		hThread = mpalQueryDoAction(nAction, nActionItem, 0); 
+		pid = mpalQueryDoAction(nAction, nActionItem, 0); 
 	}
 					
-	if (hThread != INVALID_HANDLE_VALUE) {
+	if (pid != INVALID_PID_VALUE) {
 		m_bAction = true;
-		pid = (uint32)hThread;
 		g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
 		hActionThread = pid;
 	} else if (nAction != TA_GOTO) {
 		if (nAction == TA_TALK) {
-			hThread = mpalQueryDoAction(6, 1, 0); 
+			pid = mpalQueryDoAction(6, 1, 0); 
 			m_bAction = true;
-			pid = (uint32)hThread;
 			g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
   			hActionThread = pid;
 		} else if (nAction == TA_PALESATI) {
-			hThread = mpalQueryDoAction(7, 1, 0);
+			pid = mpalQueryDoAction(7, 1, 0);
 			m_bAction = true; 
-			pid = (uint32)hThread;
 			g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
   			hActionThread = pid;
 		} else {
-			hThread = mpalQueryDoAction(5, 1, 0); 
+			pid = mpalQueryDoAction(5, 1, 0); 
 			m_bAction = true;
-			pid = (uint32)hThread;
 			g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
 			hActionThread = pid;
 		}
@@ -285,21 +280,21 @@ void RMTony::StopNoAction(CORO_PARAM) {
 
 void RMTony::Stop(CORO_PARAM) {
 	CORO_BEGIN_CONTEXT;
-		uint32 hThread;
+		uint32 pid;
 	CORO_END_CONTEXT(_ctx);
 
 	CORO_BEGIN_CODE(_ctx);
 
 	if (m_ActionItem != NULL) {
 		// Richiama l'MPAL per scegliere la direzione
-		_ctx->hThread = mpalQueryDoActionU32(21, m_ActionItem->MpalCode(), 0);
+		_ctx->pid = mpalQueryDoAction(21, m_ActionItem->MpalCode(), 0);
 
-		if (_ctx->hThread == INVALID_PID_VALUE)
+		if (_ctx->pid == INVALID_PID_VALUE)
 			RMCharacter::Stop();
 		else {
 			bNeedToStop = false;	// Se facciamo la OnWhichDirection, almeno dopo non dobbiamo fare la Stop()
 			bMoving = false;
-			CORO_INVOKE_2(g_scheduler->waitForSingleObject, _ctx->hThread, INFINITE); // @@@ Mettere un assert dopo 10 secondi
+			CORO_INVOKE_2(g_scheduler->waitForSingleObject, _ctx->pid, INFINITE); // @@@ Mettere un assert dopo 10 secondi
 		}
 	} else {
 		RMCharacter::Stop();
-- 
cgit v1.2.3


From 82361a3ea3efb9b6454eb4805e777cd4bfc3a0e3 Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Fri, 11 May 2012 00:09:34 +1000
Subject: TONY: Fixed some missed methods to coroutines

---
 engines/tony/tonychar.cpp | 33 +++++++++++++++++++++++++--------
 1 file changed, 25 insertions(+), 8 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 06adcd15b8..c3deae497b 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -125,20 +125,26 @@ void RMTony::Close(void) {
 	m_ombra.Destroy();
 }
 
-void RMTony::DoFrame(RMGfxTargetBuffer *bigBuf, int curLoc) {
+void RMTony::DoFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
+	CORO_BEGIN_CONTEXT;
+		int time;
+	CORO_END_CONTEXT(_ctx);
+
+	CORO_BEGIN_CODE(_ctx);
+
 	if (!m_nInList && m_bShow)
 		bigBuf->AddPrim(new RMGfxPrimitive(this));
 	
 	SetSpeed(nCfgTonySpeed);	
 
 	// Esegue il movimento normale del personaggio
-	int time = _vm->GetTime();
+	_ctx->time = _vm->GetTime();
 
 	do {
 		m_nTimeLastStep += (1000 / 40);
-		RMCharacter::DoFrame(bigBuf, curLoc);
+		CORO_INVOKE_2(RMCharacter::DoFrame, bigBuf, curLoc);
 
-	} while (time > m_nTimeLastStep + (1000 / 40));
+	} while (_ctx->time > m_nTimeLastStep + (1000 / 40));
 
 	// Controlla se siamo alla fine del percorso
 	if (EndOfPath() && m_bActionPending) {
@@ -148,6 +154,8 @@ void RMTony::DoFrame(RMGfxTargetBuffer *bigBuf, int curLoc) {
 
 	if (m_bIsTalking || m_bIsStaticTalk)
 		m_body.DoFrame(bigBuf, false);
+
+	CORO_END_CODE;
 }
 
 void RMTony::Show(void) {
@@ -192,7 +200,13 @@ void RMTony::Draw(RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 	}
 }
 
-void RMTony::MoveAndDoAction(RMPoint dst, RMItem *item, int nAction, int nActionParm) {
+void RMTony::MoveAndDoAction(CORO_PARAM, RMPoint dst, RMItem *item, int nAction, int nActionParm) {
+	CORO_BEGIN_CONTEXT;
+		bool result;
+	CORO_END_CONTEXT(_ctx);
+
+	CORO_BEGIN_CODE(_ctx);
+
 	// Fa il movimento normale, ma si ricorda se deve poi eseguire un azione
 	if (item == NULL) {
 		m_bActionPending = false;
@@ -204,10 +218,13 @@ void RMTony::MoveAndDoAction(RMPoint dst, RMItem *item, int nAction, int nAction
 		m_bActionPending = true;
 	}
 
-	if (!RMCharacter::Move(dst)) {
+	CORO_INVOKE_2(RMCharacter::Move, dst, &_ctx->result);
+	if (!_ctx->result) {
 		m_bActionPending = false;
 		m_ActionItem = NULL;
 	}
+
+	CORO_END_CODE;
 }
 
 
@@ -290,14 +307,14 @@ void RMTony::Stop(CORO_PARAM) {
 		_ctx->pid = mpalQueryDoAction(21, m_ActionItem->MpalCode(), 0);
 
 		if (_ctx->pid == INVALID_PID_VALUE)
-			RMCharacter::Stop();
+			CORO_INVOKE_0(RMCharacter::Stop);
 		else {
 			bNeedToStop = false;	// Se facciamo la OnWhichDirection, almeno dopo non dobbiamo fare la Stop()
 			bMoving = false;
 			CORO_INVOKE_2(g_scheduler->waitForSingleObject, _ctx->pid, INFINITE); // @@@ Mettere un assert dopo 10 secondi
 		}
 	} else {
-		RMCharacter::Stop();
+		CORO_INVOKE_0(RMCharacter::Stop);
 	}
 
 	if (!m_bActionPending)
-- 
cgit v1.2.3


From 68c1b0b0e46b0575a4670d1ffda2fa3c8ae94ed8 Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Fri, 11 May 2012 23:15:59 +1000
Subject: TONY: Refactored Tony to use the Common coroutine scheduler

---
 engines/tony/tonychar.cpp | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index c3deae497b..6a5d80f51e 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -67,7 +67,7 @@ void RMTony::WaitEndOfAction(CORO_PARAM, const void *param) {
 
 	CORO_BEGIN_CODE(_ctx);
 
-	CORO_INVOKE_2(g_scheduler->waitForSingleObject, pid, INFINITE);
+	CORO_INVOKE_2(CoroScheduler.waitForSingleObject, pid, CORO_INFINITE);
 
 	m_bAction = false;
 
@@ -236,15 +236,15 @@ void RMTony::ExecuteAction(int nAction, int nActionItem, int nParm) {
 		pid = mpalQueryDoAction(TA_COMBINE, nParm, nActionItem);
 		
 		// Se è fallito il combine, proviamo con il ReceiveCombine
-		if (pid == INVALID_PID_VALUE) {
+		if (pid == CORO_INVALID_PID_VALUE) {
 			pid = mpalQueryDoAction(TA_RECEIVECOMBINE, nActionItem, nParm); 
 			
 			// Se è fallito il receive, andiamo con quelli generici
 			// @@@ CombineGive!
-			if (pid == INVALID_PID_VALUE) {
+			if (pid == CORO_INVALID_PID_VALUE) {
 				pid = mpalQueryDoAction(TA_COMBINE, nParm, 0);
 				
-				if (pid == INVALID_PID_VALUE){
+				if (pid == CORO_INVALID_PID_VALUE){
 					pid = mpalQueryDoAction(TA_RECEIVECOMBINE, nActionItem, 0);
 				}
 			}
@@ -254,25 +254,25 @@ void RMTony::ExecuteAction(int nAction, int nActionItem, int nParm) {
 		pid = mpalQueryDoAction(nAction, nActionItem, 0); 
 	}
 					
-	if (pid != INVALID_PID_VALUE) {
+	if (pid != CORO_INVALID_PID_VALUE) {
 		m_bAction = true;
-		g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
+		CoroScheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
 		hActionThread = pid;
 	} else if (nAction != TA_GOTO) {
 		if (nAction == TA_TALK) {
 			pid = mpalQueryDoAction(6, 1, 0); 
 			m_bAction = true;
-			g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
+			CoroScheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
   			hActionThread = pid;
 		} else if (nAction == TA_PALESATI) {
 			pid = mpalQueryDoAction(7, 1, 0);
 			m_bAction = true; 
-			g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
+			CoroScheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
   			hActionThread = pid;
 		} else {
 			pid = mpalQueryDoAction(5, 1, 0); 
 			m_bAction = true;
-			g_scheduler->createProcess(WaitEndOfAction, &pid, sizeof(uint32));
+			CoroScheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
 			hActionThread = pid;
 		}
 	}
@@ -286,7 +286,7 @@ void RMTony::StopNoAction(CORO_PARAM) {
 	CORO_BEGIN_CODE(_ctx);
 
 	if (m_bAction)
-		CORO_INVOKE_2(g_scheduler->waitForSingleObject, hActionThread, INFINITE);
+		CORO_INVOKE_2(CoroScheduler.waitForSingleObject, hActionThread, CORO_INFINITE);
 
 	m_bActionPending = false;
 	m_ActionItem = NULL;
@@ -306,12 +306,12 @@ void RMTony::Stop(CORO_PARAM) {
 		// Richiama l'MPAL per scegliere la direzione
 		_ctx->pid = mpalQueryDoAction(21, m_ActionItem->MpalCode(), 0);
 
-		if (_ctx->pid == INVALID_PID_VALUE)
+		if (_ctx->pid == CORO_INVALID_PID_VALUE)
 			CORO_INVOKE_0(RMCharacter::Stop);
 		else {
 			bNeedToStop = false;	// Se facciamo la OnWhichDirection, almeno dopo non dobbiamo fare la Stop()
 			bMoving = false;
-			CORO_INVOKE_2(g_scheduler->waitForSingleObject, _ctx->pid, INFINITE); // @@@ Mettere un assert dopo 10 secondi
+			CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->pid, CORO_INFINITE); // @@@ Mettere un assert dopo 10 secondi
 		}
 	} else {
 		CORO_INVOKE_0(RMCharacter::Stop);
-- 
cgit v1.2.3


From a153f9a2e633c788edd00b1c71c75377a3319e66 Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Sat, 12 May 2012 10:34:52 +1000
Subject: TONY: Explicitly initialise fields of various objects in their
 constructors

This fixes a crash when the pop-up inventory was displayed.
---
 engines/tony/tonychar.cpp | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 6a5d80f51e..982949870c 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -59,6 +59,24 @@ namespace Tony {
 
 bool RMTony::m_bAction = false;
 
+RMTony::RMTony() {
+	m_bShow = false;
+	m_bShowOmbra = false;
+	m_bCorpoDavanti = false;
+	m_bActionPending = false;
+	m_ActionItem = NULL;
+	m_Action = 0;
+	m_ActionParm = 0;
+	m_bPastorella = false;
+	m_bIsStaticTalk = false;
+	m_bIsTalking = false;
+	m_nPatB4Talking = 0;
+	m_nTalkType = TALK_NORMAL;
+	m_TalkDirection = UP;
+	m_nTimeLastStep = 0;
+	hActionThread = CORO_INVALID_PID_VALUE;
+}
+
 void RMTony::WaitEndOfAction(CORO_PARAM, const void *param) {
 	CORO_BEGIN_CONTEXT;
 	CORO_END_CONTEXT(_ctx);
-- 
cgit v1.2.3


From 109e5f8226c1db18926e307d4ecb9c3c83fdd7bc Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Sat, 12 May 2012 20:49:36 +1000
Subject: TONY: Conversion of more methods to coroutines

---
 engines/tony/tonychar.cpp | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 982949870c..0e59779229 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -187,7 +187,12 @@ void RMTony::Hide(bool bShowOmbra) {
 }
 
 
-void RMTony::Draw(RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+void RMTony::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+	CORO_BEGIN_CONTEXT;
+	CORO_END_CONTEXT(_ctx);
+
+	CORO_BEGIN_CODE(_ctx);
+
 	// Richiama il Draw() della classe madre se tony è visibile
 	if (m_bShow && bDrawNow) {
 		if (m_bCorpoDavanti) {
@@ -195,7 +200,7 @@ void RMTony::Draw(RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 			prim->Dst().Offset(-44, -134);
 			if (m_bPastorella)
 				prim->Dst().Offset(1, 4);
-			RMCharacter::Draw(bigBuf, prim);
+			CORO_INVOKE_2(RMCharacter::Draw, bigBuf, prim);
 		}
 
 		if (m_bIsTalking || m_bIsStaticTalk) {
@@ -205,7 +210,7 @@ void RMTony::Draw(RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
     		prim->Dst().Offset(m_pos);
 			prim->Dst().Offset(-44, -134);
 			prim->Dst() += m_nBodyOffset;	
-			m_body.Draw(bigBuf, prim);
+			CORO_INVOKE_2(m_body.Draw, bigBuf, prim);
 		}
 
 		if (!m_bCorpoDavanti) {
@@ -213,9 +218,11 @@ void RMTony::Draw(RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 			prim->Dst().Offset(-44, -134);
 			if (m_bPastorella)
 				prim->Dst().Offset(0, 3);
-			RMCharacter::Draw(bigBuf, prim);
+			CORO_INVOKE_2(RMCharacter::Draw, bigBuf, prim);
 		}
 	}
+
+	CORO_END_CODE;
 }
 
 void RMTony::MoveAndDoAction(CORO_PARAM, RMPoint dst, RMItem *item, int nAction, int nActionParm) {
-- 
cgit v1.2.3


From 546f47ddcee07b5bd7ecad5f25f4bb022944e234 Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Sun, 13 May 2012 22:34:40 +1000
Subject: TONY: Beginnings of refactoring Globals into their own class

---
 engines/tony/tonychar.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 0e59779229..072e822c36 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -153,7 +153,7 @@ void RMTony::DoFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
 	if (!m_nInList && m_bShow)
 		bigBuf->AddPrim(new RMGfxPrimitive(this));
 	
-	SetSpeed(nCfgTonySpeed);	
+	SetSpeed(GLOBALS.nCfgTonySpeed);	
 
 	// Esegue il movimento normale del personaggio
 	_ctx->time = _vm->GetTime();
-- 
cgit v1.2.3


From b01482bddb6d8f0b0be4dd46ee7c9e4141908673 Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Sun, 13 May 2012 23:05:41 +1000
Subject: TONY: Further globals added to Globals class

---
 engines/tony/tonychar.cpp | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 072e822c36..7430ca89ae 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -59,6 +59,10 @@ namespace Tony {
 
 bool RMTony::m_bAction = false;
 
+void RMTony::InitStatics() {
+	m_bAction = false;
+}
+
 RMTony::RMTony() {
 	m_bShow = false;
 	m_bShowOmbra = false;
-- 
cgit v1.2.3


From 099fe1e9e62ada666a312e08d7dca5cd2083de0b Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Mon, 14 May 2012 07:43:50 +0200
Subject: TONY: Remove original header

---
 engines/tony/tonychar.cpp | 31 ++++++-------------------------
 1 file changed, 6 insertions(+), 25 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 7430ca89ae..df92cafebd 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -19,31 +19,12 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
  */
-/**************************************************************************
- *                                     ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ *
- *                                             Nayma Software srl         *
- *                    e                -= We create much MORE than ALL =- *
- *        u-        z$$$c        '.    ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ *
- *      .d"        d$$$$$b        "b.                                     *
- *   .z$*         d$$$$$$$L        ^*$c.                                  *
- *  #$$$.         $$$$$$$$$         .$$$" Project: Roasted Moths........  *
- *    ^*$b       4$$$$$$$$$F      .d$*"                                   *
- *      ^$$.     4$$$$$$$$$F     .$P"     Module:  TonyChar.CPP.........  *
- *        *$.    '$$$$$$$$$     4$P 4                                     *
- *     J   *$     "$$$$$$$"     $P   r    Author:  Giovanni Bajo........  *
- *    z$   '$$$P*4c.*$$$*.z@*R$$$    $.                                   *
- *   z$"    ""       #$F^      ""    '$c                                  *
- *  z$$beu     .ue="  $  "=e..    .zed$$c                                 *
- *      "#$e z$*"   .  `.   ^*Nc e$""                                     *
- *         "$$".  .r"   ^4.  .^$$"                                        *
- *          ^.@*"6L=\ebu^+C$"*b."                                         *
- *        "**$.  "c 4$$$  J"  J$P*"    OS:  [ ] DOS  [X] WIN95  [ ] PORT  *
- *            ^"--.^ 9$"  .--""      COMP:  [ ] WATCOM  [X] VISUAL C++    *
- *                    "                     [ ] EIFFEL  [ ] GCC/GXX/DJGPP *
- *                                                                        *
- * This source code is Copyright (C) Nayma Software.  ALL RIGHTS RESERVED *
- *                                                                        *
- **************************************************************************/
+
+/*
+ * This code is based on original Tony Tough source code
+ *
+ * Copyright (c) 1997-2003 Nayma Software
+ */
 
 #include "tony/mpal/memory.h"
 #include "tony/mpal/mpalutils.h"
-- 
cgit v1.2.3


From 88762667b52e4b904c56ecc94bf304c1a91e9feb Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Mon, 14 May 2012 21:29:27 +0200
Subject: TONY: Fix some formatting

---
 engines/tony/tonychar.cpp | 31 ++++++++++++++-----------------
 1 file changed, 14 insertions(+), 17 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index df92cafebd..c612ebbf77 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -334,14 +334,14 @@ void RMTony::Stop(CORO_PARAM) {
 
 	ExecuteAction(m_Action, m_ActionItem->MpalCode(), m_ActionParm);
 	
-	m_ActionItem=NULL;
+	m_ActionItem = NULL;
 
 	CORO_END_CODE;
 }
 
 
 int RMTony::GetCurPattern(void) {
-	int nPatt=RMCharacter::GetCurPattern();
+	int nPatt = RMCharacter::GetCurPattern();
 
 	if (!m_bPastorella)
 		return nPatt;
@@ -355,7 +355,6 @@ int RMTony::GetCurPattern(void) {
 		return PAT_STANDLEFT;
 	case PAT_PAST_STANDRIGHT:
 		return PAT_STANDRIGHT;
-
 	case PAT_PAST_WALKUP:
 		return PAT_WALKUP;
 	case PAT_PAST_WALKDOWN:
@@ -438,7 +437,6 @@ void RMTony::Take(int nWhere, int nPart) {
 			}
 			break;
 
-
 		case PAT_STANDLEFT:
 			switch (nWhere) {
 			case 0:
@@ -454,7 +452,7 @@ void RMTony::Take(int nWhere, int nPart) {
 			break;
 		}
 	} else if (nPart == 1) {
-		SetPattern(GetCurPattern()+1);
+		SetPattern(GetCurPattern() + 1);
 	} else if (nPart == 2) {
 		switch (GetCurPattern()) {
 		case PAT_TAKEUP_UP2:
@@ -514,7 +512,6 @@ void RMTony::Put(int nWhere, int nPart) {
 			}
 			break;
 
-
 		case PAT_STANDLEFT:
 			switch (nWhere) {
 			case 0:
@@ -530,7 +527,7 @@ void RMTony::Put(int nWhere, int nPart) {
 			break;
 		}
 	} else if (nPart == 1) {
-		SetPattern(GetCurPattern()+1);
+		SetPattern(GetCurPattern() + 1);
 	} else if (nPart == 2) {
 		switch (GetCurPattern()) {
 		case PAT_PUTUP_UP2:
@@ -567,7 +564,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 	if (!m_bIsStaticTalk) {
 		switch (m_nPatB4Talking) {
 		case PAT_STANDDOWN:
-			m_TalkDirection=DOWN;
+			m_TalkDirection = DOWN;
 			break;
 
 		case PAT_TAKELEFT_UP2:
@@ -575,7 +572,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case PAT_TAKELEFT_DOWN2:
 		case PAT_SIRIALZALEFT:
 		case PAT_STANDLEFT:
-			m_TalkDirection=LEFT;
+			m_TalkDirection = LEFT;
 			break;
 		
 		case PAT_TAKERIGHT_UP2:
@@ -583,14 +580,14 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case PAT_TAKERIGHT_DOWN2:
 		case PAT_SIRIALZARIGHT:
 		case PAT_STANDRIGHT:
-			m_TalkDirection=RIGHT;
+			m_TalkDirection = RIGHT;
 			break;
 
 		case PAT_TAKEUP_UP2:
 		case PAT_TAKEUP_MID2:
 		case PAT_TAKEUP_DOWN2:
 		case PAT_STANDUP:
-			m_TalkDirection=UP;
+			m_TalkDirection = UP;
 			break;
 		}
 
@@ -1220,9 +1217,9 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 
 	case TALK_RIDE:
 	case TALK_RIDE2:
-		if (m_TalkDirection==LEFT)
+		if (m_TalkDirection == LEFT)
 			headEndPat = PAT_RIDELEFT_END;
-		else if (m_TalkDirection==RIGHT)
+		else if (m_TalkDirection == RIGHT)
 			headEndPat = PAT_RIDERIGHT_END;
 			
 		bodyEndPat = 0;
@@ -1532,7 +1529,7 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 
 	switch (nPat) {
 	case PAT_STANDDOWN:
-		m_TalkDirection=DOWN;
+		m_TalkDirection = DOWN;
 		headPat = PAT_TESTA_RIGHT;
 		break;
 
@@ -1541,7 +1538,7 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 	case PAT_TAKELEFT_DOWN2:
 	case PAT_SIRIALZALEFT:
 	case PAT_STANDLEFT:
-		m_TalkDirection=LEFT;
+		m_TalkDirection = LEFT;
 		headPat = PAT_TESTA_LEFT;
 		break;
 		
@@ -1550,7 +1547,7 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 	case PAT_TAKERIGHT_DOWN2:
 	case PAT_SIRIALZARIGHT:
 	case PAT_STANDRIGHT:
-		m_TalkDirection=RIGHT;
+		m_TalkDirection = RIGHT;
 		headPat = PAT_TESTA_RIGHT;
 		break;
 
@@ -1558,7 +1555,7 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 	case PAT_TAKEUP_MID2:
 	case PAT_TAKEUP_DOWN2:
 	case PAT_STANDUP:
-		m_TalkDirection=UP;
+		m_TalkDirection = UP;
 		headPat = PAT_TESTA_LEFT;
 		break;
 	}
-- 
cgit v1.2.3


From 0450275c44c8c001d56cf37c78db6951ecaa4314 Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Sun, 20 May 2012 13:54:59 +1000
Subject: TONY: Converting Italian comments to English and formatting

---
 engines/tony/tonychar.cpp | 56 +++++++++++++++++++++++------------------------
 1 file changed, 27 insertions(+), 29 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index c612ebbf77..04b6193cd2 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -93,10 +93,10 @@ void RMTony::Init(void) {
 	RMRes body(9999);
 	RMDataStream ds;
 
-	// Mostra Tony di default
-	m_bShow=m_bShowOmbra = true;
+	// Tony is shown by default
+	m_bShow = m_bShowOmbra = true;
 
-	// Nessuna azione in attesa
+	// No action pending
 	m_bActionPending = false;
 	m_bAction = false;
 
@@ -104,18 +104,18 @@ void RMTony::Init(void) {
 	m_bIsTalking = false;
 	m_bIsStaticTalk = false;
 
-	// Apre il buffer
+	// Opens the buffer
 	ds.OpenBuffer(tony);
 
-	// Legge dallo stream l'oggetto corrente (cioè Tony)
-	ReadFromStream(ds, true);	// da OGX
+	// Reads his details from the stream
+	ReadFromStream(ds, true);
 	
-	// Chiude il buffer
+	// Closes the buffer
 	ds.Close();
 
-	// Legge il corpo di Tony
+	// Reads Tony's body
 	ds.OpenBuffer(body);
-	m_body.ReadFromStream(ds, true); // da OGX
+	m_body.ReadFromStream(ds, true);
 	ds.Close();
 	m_body.SetPattern(0);
 
@@ -124,7 +124,7 @@ void RMTony::Init(void) {
 
 
 void RMTony::Close(void) {
-	// Disalloca @@@ Manca la disallocazione di un item
+	// Disalloca @@@ Deallocation of missing item
 	m_ombra.Destroy();
 }
 
@@ -140,7 +140,7 @@ void RMTony::DoFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
 	
 	SetSpeed(GLOBALS.nCfgTonySpeed);	
 
-	// Esegue il movimento normale del personaggio
+	// Runs the normal character movement
 	_ctx->time = _vm->GetTime();
 
 	do {
@@ -149,9 +149,9 @@ void RMTony::DoFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
 
 	} while (_ctx->time > m_nTimeLastStep + (1000 / 40));
 
-	// Controlla se siamo alla fine del percorso
+	// Check if we are at the end of a path
 	if (EndOfPath() && m_bActionPending) {
-		// Bisogna eseguire l'azione sulla quale abbiamo clickato
+		// Must perform the action on which we clicked
 		m_bActionPending = false;	
 	}
 
@@ -239,17 +239,16 @@ void RMTony::MoveAndDoAction(CORO_PARAM, RMPoint dst, RMItem *item, int nAction,
 
 
 void RMTony::ExecuteAction(int nAction, int nActionItem, int nParm) {
-	// fixme: See if hThread can be converted to uint32
 	uint32 pid;
 	
 	if (nAction == TA_COMBINE) {
 		pid = mpalQueryDoAction(TA_COMBINE, nParm, nActionItem);
 		
-		// Se è fallito il combine, proviamo con il ReceiveCombine
+		// If you failed the combine, we have RECEIVECOMBINE as a fallback
 		if (pid == CORO_INVALID_PID_VALUE) {
 			pid = mpalQueryDoAction(TA_RECEIVECOMBINE, nActionItem, nParm); 
 			
-			// Se è fallito il receive, andiamo con quelli generici
+			// If you failed with that, go with the generic
 			// @@@ CombineGive!
 			if (pid == CORO_INVALID_PID_VALUE) {
 				pid = mpalQueryDoAction(TA_COMBINE, nParm, 0);
@@ -313,15 +312,15 @@ void RMTony::Stop(CORO_PARAM) {
 	CORO_BEGIN_CODE(_ctx);
 
 	if (m_ActionItem != NULL) {
-		// Richiama l'MPAL per scegliere la direzione
+		// Call MPAL to choose the direction
 		_ctx->pid = mpalQueryDoAction(21, m_ActionItem->MpalCode(), 0);
 
 		if (_ctx->pid == CORO_INVALID_PID_VALUE)
 			CORO_INVOKE_0(RMCharacter::Stop);
 		else {
-			bNeedToStop = false;	// Se facciamo la OnWhichDirection, almeno dopo non dobbiamo fare la Stop()
+			bNeedToStop = false;	// If we make the OnWhichDirection, we don't need at least after the Stop().
 			bMoving = false;
-			CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->pid, CORO_INFINITE); // @@@ Mettere un assert dopo 10 secondi
+			CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->pid, CORO_INFINITE); // @@@ Put an assert after 10 seconds
 		}
 	} else {
 		CORO_INVOKE_0(RMCharacter::Stop);
@@ -406,7 +405,7 @@ void RMTony::Take(int nWhere, int nPart) {
 	if (nPart == 0) {
 		switch (GetCurPattern()) {
 		case PAT_STANDDOWN:
-			assert(0);	// Non esiste il prende mentre sei in StandDown
+			assert(0);	// Not while you're doing a StandDown
 			break;
 
 		case PAT_STANDUP:
@@ -481,7 +480,7 @@ void RMTony::Put(int nWhere, int nPart) {
 	if (nPart == 0) {
 		switch (GetCurPattern()) {
 		case PAT_STANDDOWN:
-			//assert(0);	// Non esiste il prende mentre sei in StandDown
+			//assert(0);
 			break;
 
 		case PAT_STANDUP:
@@ -560,7 +559,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 	m_nPatB4Talking = GetCurPattern();
 	m_nTalkType = nTalkType;
 
-	// Setta la direzione di parlata SOLO se non siamo in una static animation (perché l'ha già fatto)
+	// Set the direction of speech ONLY if we are not in a static animation (since it would have already been done)
 	if (!m_bIsStaticTalk) {
 		switch (m_nPatB4Talking) {
 		case PAT_STANDDOWN:
@@ -591,12 +590,12 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 		}
 
-		// Mette davanti il corpo di default
+		// Puts the body in front by default
 		m_bCorpoDavanti = true;
 	}
 
 	if (m_bPastorella) {
-		// Da pastorella, c'è un solo parlato
+		// Talking whilst a shepherdess
 		MainFreeze();
 		switch (m_TalkDirection) {
 		case UP:
@@ -967,8 +966,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		}
 		break;
 
-	// La barba è l'unico caso in cui la testa è animata a parte
-	//  mentre il corpo è quello standard
+	// The beard is the only case in which the head is animated separately while the body is the standard
 	case TALK_CONBARBASTATIC:
 		switch (m_TalkDirection) {
 		case LEFT:
@@ -1127,7 +1125,7 @@ void RMTony::StartTalk(CORO_PARAM, TALKTYPE nTalkType) {
 			_ctx->headLoopPat, _ctx->bodyLoopPat))
 		return;
 
-	// Esegue il set dei pattern vero e proprio
+	// Perform the set pattern
 	if (_ctx->headStartPat != 0 || _ctx->bodyStartPat != 0) {
 		MainFreeze();
 		SetPattern(_ctx->headStartPat);
@@ -1446,7 +1444,7 @@ void RMTony::EndTalk(CORO_PARAM) {
 	if (!EndTalkCalculate(_ctx->headStandPat, _ctx->headEndPat, _ctx->bodyEndPat, _ctx->finalPat, _ctx->bStatic))
 		return;
 
-	// Gestisce la fine di una animazione static lasciando tutto invariato
+	// Handles the end of an animated and static, leaving everything unchanged
 	if (m_bIsStaticTalk) {
 		if (m_nTalkType == TALK_CONBARBASTATIC) {
 			MainFreeze();
@@ -1471,7 +1469,7 @@ void RMTony::EndTalk(CORO_PARAM) {
 		return;
 	}
 
-	// Set dei pattern
+	// Set the pattern
 	if (_ctx->headEndPat != 0 && _ctx->bodyEndPat != 0) {
 		MainFreeze();
 		SetPattern(_ctx->headEndPat);
-- 
cgit v1.2.3


From 8322da03c04d7994601973364599081447a7ccde Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Sun, 20 May 2012 16:03:09 +1000
Subject: TONY: Converting Italian comments to English

---
 engines/tony/tonychar.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 04b6193cd2..593a05d863 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -178,7 +178,7 @@ void RMTony::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 
 	CORO_BEGIN_CODE(_ctx);
 
-	// Richiama il Draw() della classe madre se tony è visibile
+	// Call the Draw() of the parent class if Tony is visible
 	if (m_bShow && bDrawNow) {
 		if (m_bCorpoDavanti) {
 			prim->Dst().SetEmpty();
@@ -189,7 +189,7 @@ void RMTony::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 		}
 
 		if (m_bIsTalking || m_bIsStaticTalk) {
-			// Offset inverso per lo scrolling
+			// Offest direction from scrolling
 			prim->Dst().SetEmpty();
 			prim->Dst().Offset(-m_curScroll);
     		prim->Dst().Offset(m_pos);
@@ -217,7 +217,7 @@ void RMTony::MoveAndDoAction(CORO_PARAM, RMPoint dst, RMItem *item, int nAction,
 
 	CORO_BEGIN_CODE(_ctx);
 
-	// Fa il movimento normale, ma si ricorda se deve poi eseguire un azione
+	// Makes normal movement, but remember if you must then perform an action
 	if (item == NULL) {
 		m_bActionPending = false;
 		m_ActionItem = NULL;
-- 
cgit v1.2.3


From 94d3c8ebb29699a6c7a76c08986b984523761d63 Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Mon, 21 May 2012 23:53:13 +0200
Subject: TONY: Some more code formatting

---
 engines/tony/tonychar.cpp | 167 +++++++++++++++++++++++-----------------------
 1 file changed, 84 insertions(+), 83 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 593a05d863..71f95f8133 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -79,7 +79,7 @@ void RMTony::WaitEndOfAction(CORO_PARAM, const void *param) {
 
 RMGfxSourceBuffer *RMTony::NewItemSpriteBuffer(int dimx, int dimy, bool bPreRLE) {
 	RMGfxSourceBuffer8RLE *spr;
-	
+
 	assert(m_cm == CM_256);
 	spr = new RMGfxSourceBuffer8RLEByteAA;
 	spr->SetAlphaBlendColor(1);
@@ -109,7 +109,7 @@ void RMTony::Init(void) {
 
 	// Reads his details from the stream
 	ReadFromStream(ds, true);
-	
+
 	// Closes the buffer
 	ds.Close();
 
@@ -130,15 +130,15 @@ void RMTony::Close(void) {
 
 void RMTony::DoFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
 	CORO_BEGIN_CONTEXT;
-		int time;
+	int time;
 	CORO_END_CONTEXT(_ctx);
 
 	CORO_BEGIN_CODE(_ctx);
 
 	if (!m_nInList && m_bShow)
 		bigBuf->AddPrim(new RMGfxPrimitive(this));
-	
-	SetSpeed(GLOBALS.nCfgTonySpeed);	
+
+	SetSpeed(GLOBALS.nCfgTonySpeed);
 
 	// Runs the normal character movement
 	_ctx->time = _vm->GetTime();
@@ -152,7 +152,7 @@ void RMTony::DoFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
 	// Check if we are at the end of a path
 	if (EndOfPath() && m_bActionPending) {
 		// Must perform the action on which we clicked
-		m_bActionPending = false;	
+		m_bActionPending = false;
 	}
 
 	if (m_bIsTalking || m_bIsStaticTalk)
@@ -192,9 +192,9 @@ void RMTony::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 			// Offest direction from scrolling
 			prim->Dst().SetEmpty();
 			prim->Dst().Offset(-m_curScroll);
-    		prim->Dst().Offset(m_pos);
+			prim->Dst().Offset(m_pos);
 			prim->Dst().Offset(-44, -134);
-			prim->Dst() += m_nBodyOffset;	
+			prim->Dst() += m_nBodyOffset;
 			CORO_INVOKE_2(m_body.Draw, bigBuf, prim);
 		}
 
@@ -212,7 +212,7 @@ void RMTony::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 
 void RMTony::MoveAndDoAction(CORO_PARAM, RMPoint dst, RMItem *item, int nAction, int nActionParm) {
 	CORO_BEGIN_CONTEXT;
-		bool result;
+	bool result;
 	CORO_END_CONTEXT(_ctx);
 
 	CORO_BEGIN_CODE(_ctx);
@@ -240,46 +240,46 @@ void RMTony::MoveAndDoAction(CORO_PARAM, RMPoint dst, RMItem *item, int nAction,
 
 void RMTony::ExecuteAction(int nAction, int nActionItem, int nParm) {
 	uint32 pid;
-	
+
 	if (nAction == TA_COMBINE) {
 		pid = mpalQueryDoAction(TA_COMBINE, nParm, nActionItem);
-		
+
 		// If you failed the combine, we have RECEIVECOMBINE as a fallback
 		if (pid == CORO_INVALID_PID_VALUE) {
-			pid = mpalQueryDoAction(TA_RECEIVECOMBINE, nActionItem, nParm); 
-			
+			pid = mpalQueryDoAction(TA_RECEIVECOMBINE, nActionItem, nParm);
+
 			// If you failed with that, go with the generic
 			// @@@ CombineGive!
 			if (pid == CORO_INVALID_PID_VALUE) {
 				pid = mpalQueryDoAction(TA_COMBINE, nParm, 0);
-				
-				if (pid == CORO_INVALID_PID_VALUE){
+
+				if (pid == CORO_INVALID_PID_VALUE) {
 					pid = mpalQueryDoAction(TA_RECEIVECOMBINE, nActionItem, 0);
 				}
 			}
 		}
 	} else {
 		// Perform the action
-		pid = mpalQueryDoAction(nAction, nActionItem, 0); 
+		pid = mpalQueryDoAction(nAction, nActionItem, 0);
 	}
-					
+
 	if (pid != CORO_INVALID_PID_VALUE) {
 		m_bAction = true;
 		CoroScheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
 		hActionThread = pid;
 	} else if (nAction != TA_GOTO) {
 		if (nAction == TA_TALK) {
-			pid = mpalQueryDoAction(6, 1, 0); 
+			pid = mpalQueryDoAction(6, 1, 0);
 			m_bAction = true;
 			CoroScheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
-  			hActionThread = pid;
+			hActionThread = pid;
 		} else if (nAction == TA_PALESATI) {
 			pid = mpalQueryDoAction(7, 1, 0);
-			m_bAction = true; 
+			m_bAction = true;
 			CoroScheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
-  			hActionThread = pid;
+			hActionThread = pid;
 		} else {
-			pid = mpalQueryDoAction(5, 1, 0); 
+			pid = mpalQueryDoAction(5, 1, 0);
 			m_bAction = true;
 			CoroScheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
 			hActionThread = pid;
@@ -306,7 +306,7 @@ void RMTony::StopNoAction(CORO_PARAM) {
 
 void RMTony::Stop(CORO_PARAM) {
 	CORO_BEGIN_CONTEXT;
-		uint32 pid;
+	uint32 pid;
 	CORO_END_CONTEXT(_ctx);
 
 	CORO_BEGIN_CODE(_ctx);
@@ -318,7 +318,7 @@ void RMTony::Stop(CORO_PARAM) {
 		if (_ctx->pid == CORO_INVALID_PID_VALUE)
 			CORO_INVOKE_0(RMCharacter::Stop);
 		else {
-			bNeedToStop = false;	// If we make the OnWhichDirection, we don't need at least after the Stop().
+			bNeedToStop = false;    // If we make the OnWhichDirection, we don't need at least after the Stop().
 			bMoving = false;
 			CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->pid, CORO_INFINITE); // @@@ Put an assert after 10 seconds
 		}
@@ -332,7 +332,7 @@ void RMTony::Stop(CORO_PARAM) {
 	m_bActionPending = false;
 
 	ExecuteAction(m_Action, m_ActionItem->MpalCode(), m_ActionParm);
-	
+
 	m_ActionItem = NULL;
 
 	CORO_END_CODE;
@@ -344,7 +344,7 @@ int RMTony::GetCurPattern(void) {
 
 	if (!m_bPastorella)
 		return nPatt;
-	
+
 	switch (nPatt) {
 	case PAT_PAST_STANDUP:
 		return PAT_STANDUP;
@@ -371,28 +371,28 @@ void RMTony::SetPattern(int nPatt, bool bPlayP0) {
 	if (m_bPastorella) {
 		switch (nPatt) {
 		case PAT_STANDUP:
-			nPatt=PAT_PAST_STANDUP;
+			nPatt = PAT_PAST_STANDUP;
 			break;
 		case PAT_STANDDOWN:
-			nPatt=PAT_PAST_STANDDOWN;
+			nPatt = PAT_PAST_STANDDOWN;
 			break;
 		case PAT_STANDLEFT:
-			nPatt=PAT_PAST_STANDLEFT;
+			nPatt = PAT_PAST_STANDLEFT;
 			break;
 		case PAT_STANDRIGHT:
-			nPatt=PAT_PAST_STANDRIGHT;
+			nPatt = PAT_PAST_STANDRIGHT;
 			break;
 		case PAT_WALKUP:
-			nPatt=PAT_PAST_WALKUP;
+			nPatt = PAT_PAST_WALKUP;
 			break;
 		case PAT_WALKDOWN:
-			nPatt=PAT_PAST_WALKDOWN;
+			nPatt = PAT_PAST_WALKDOWN;
 			break;
 		case PAT_WALKLEFT:
-			nPatt=PAT_PAST_WALKLEFT;
+			nPatt = PAT_PAST_WALKLEFT;
 			break;
 		case PAT_WALKRIGHT:
-			nPatt=PAT_PAST_WALKRIGHT;
+			nPatt = PAT_PAST_WALKRIGHT;
 			break;
 		}
 	}
@@ -405,7 +405,7 @@ void RMTony::Take(int nWhere, int nPart) {
 	if (nPart == 0) {
 		switch (GetCurPattern()) {
 		case PAT_STANDDOWN:
-			assert(0);	// Not while you're doing a StandDown
+			assert(0);  // Not while you're doing a StandDown
 			break;
 
 		case PAT_STANDUP:
@@ -552,7 +552,7 @@ void RMTony::Put(int nWhere, int nPart) {
 
 
 bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &bodyStartPat,
-								int &headLoopPat, int &bodyLoopPat) {
+                                int &headLoopPat, int &bodyLoopPat) {
 	assert(!m_bIsTalking);
 
 	m_bIsTalking = true;
@@ -573,7 +573,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case PAT_STANDLEFT:
 			m_TalkDirection = LEFT;
 			break;
-		
+
 		case PAT_TAKERIGHT_UP2:
 		case PAT_TAKERIGHT_MID2:
 		case PAT_TAKERIGHT_DOWN2:
@@ -605,7 +605,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case DOWN:
 			SetPattern(PAT_PAST_TALKDOWN);
 			break;
-			
+
 		case LEFT:
 			SetPattern(PAT_PAST_TALKLEFT);
 			break;
@@ -622,7 +622,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 	bodyLoopPat = 0;
 
 	switch (nTalkType) {
-	case TALK_NORMAL: 
+	case TALK_NORMAL:
 		m_bCorpoDavanti = false;
 		headStartPat = 0;
 		bodyStartPat = 0;
@@ -654,7 +654,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		}
 		break;
 
-	case TALK_FIANCHI:	
+	case TALK_FIANCHI:
 		m_bCorpoDavanti = false;
 		switch (m_TalkDirection) {
 		case UP:
@@ -760,7 +760,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			m_nBodyOffset.Set(5, 40);
 			headLoopPat = PAT_TALK_RIGHT;
 			bodyLoopPat = BPAT_SIINDICARIGHT;
-			break;					
+			break;
 		}
 		break;
 
@@ -966,7 +966,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		}
 		break;
 
-	// The beard is the only case in which the head is animated separately while the body is the standard
+		// The beard is the only case in which the head is animated separately while the body is the standard
 	case TALK_CONBARBASTATIC:
 		switch (m_TalkDirection) {
 		case LEFT:
@@ -984,7 +984,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 		}
 		break;
-	
+
 	case TALK_SCHIFATO:
 		switch (m_TalkDirection) {
 		case LEFT:
@@ -1112,8 +1112,8 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 void RMTony::StartTalk(CORO_PARAM, TALKTYPE nTalkType) {
 	CORO_BEGIN_CONTEXT;
-		int headStartPat, bodyStartPat;
-		int headLoopPat, bodyLoopPat;
+	int headStartPat, bodyStartPat;
+	int headLoopPat, bodyLoopPat;
 	CORO_END_CONTEXT(_ctx);
 
 	CORO_BEGIN_CODE(_ctx);
@@ -1122,7 +1122,7 @@ void RMTony::StartTalk(CORO_PARAM, TALKTYPE nTalkType) {
 	_ctx->headLoopPat = _ctx->bodyLoopPat = 0;
 
 	if (!StartTalkCalculate(nTalkType, _ctx->headStartPat, _ctx->bodyStartPat,
-			_ctx->headLoopPat, _ctx->bodyLoopPat))
+	                        _ctx->headLoopPat, _ctx->bodyLoopPat))
 		return;
 
 	// Perform the set pattern
@@ -1131,13 +1131,13 @@ void RMTony::StartTalk(CORO_PARAM, TALKTYPE nTalkType) {
 		SetPattern(_ctx->headStartPat);
 		m_body.SetPattern(_ctx->bodyStartPat);
 		MainUnfreeze();
-	
+
 		if (_ctx->bodyStartPat != 0)
 			CORO_INVOKE_0(m_body.WaitForEndPattern);
 		if (_ctx->headStartPat != 0)
 			CORO_INVOKE_0(WaitForEndPattern);
 	}
-	
+
 	MainFreeze();
 	SetPattern(_ctx->headLoopPat);
 	if (_ctx->bodyLoopPat)
@@ -1151,7 +1151,7 @@ void RMTony::StartTalk(CORO_PARAM, TALKTYPE nTalkType) {
 bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPat, int &finalPat, bool &bStatic) {
 	bodyEndPat = 0;
 	headEndPat = 0;
-	
+
 	switch (m_TalkDirection) {
 	case UP:
 		finalPat = PAT_STANDUP;
@@ -1178,7 +1178,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		MainFreeze();
 		SetPattern(finalPat);
 		MainUnfreeze();
-  		m_bIsTalking = false; 
+		m_bIsTalking = false;
 		return false;
 	}
 
@@ -1203,7 +1203,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 			bodyEndPat = BPAT_FIANCHILEFT_END;
 			break;
 
-		case RIGHT:	
+		case RIGHT:
 			bodyEndPat = BPAT_FIANCHIRIGHT_END;
 			break;
 		}
@@ -1219,12 +1219,12 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 			headEndPat = PAT_RIDELEFT_END;
 		else if (m_TalkDirection == RIGHT)
 			headEndPat = PAT_RIDERIGHT_END;
-			
+
 		bodyEndPat = 0;
 		break;
 
 	case TALK_SCHIFATO:
-		switch (m_TalkDirection) {	
+		switch (m_TalkDirection) {
 		case UP:
 		case LEFT:
 			headEndPat = PAT_SCHIFATOLEFT_END;
@@ -1235,12 +1235,12 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 			headEndPat = PAT_SCHIFATORIGHT_END;
 			break;
 		}
-			
+
 		bodyEndPat = 0;
 		break;
 
 	case TALK_NAAH:
-		switch (m_TalkDirection) {	
+		switch (m_TalkDirection) {
 		case UP:
 		case LEFT:
 			headEndPat = PAT_NAAHLEFT_END;
@@ -1251,7 +1251,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 			headEndPat = PAT_NAAHRIGHT_END;
 			break;
 		}
-			
+
 		bodyEndPat = 0;
 		break;
 
@@ -1259,7 +1259,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_SPAVENTATO:
-		switch (m_TalkDirection) {	
+		switch (m_TalkDirection) {
 		case UP:
 			bodyEndPat = BPAT_SPAVENTOUP_END;
 			break;
@@ -1282,7 +1282,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_SPAVENTATO2:
-		switch (m_TalkDirection) {	
+		switch (m_TalkDirection) {
 		case UP:
 			bodyEndPat = 0;
 			break;
@@ -1305,7 +1305,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_CONCONIGLIO:
-		switch (m_TalkDirection) {	
+		switch (m_TalkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
@@ -1321,7 +1321,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_CONRICETTA:
-		switch (m_TalkDirection) {	
+		switch (m_TalkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
@@ -1337,7 +1337,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_CONCARTE:
-		switch (m_TalkDirection) {	
+		switch (m_TalkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
@@ -1353,7 +1353,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_CONPUPAZZO:
-		switch (m_TalkDirection) {	
+		switch (m_TalkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
@@ -1396,7 +1396,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_SPAVENTATOSTATIC:
-		switch (m_TalkDirection) {	
+		switch (m_TalkDirection) {
 		case DOWN:
 			headStandPat = PAT_SPAVENTODOWN_STAND;
 			bodyEndPat = 0;
@@ -1427,9 +1427,9 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 
 void RMTony::EndTalk(CORO_PARAM) {
 	CORO_BEGIN_CONTEXT;
-		int headStandPat, headEndPat;
-		int bodyEndPat, finalPat;
-		bool bStatic;
+	int headStandPat, headEndPat;
+	int bodyEndPat, finalPat;
+	bool bStatic;
 	CORO_END_CONTEXT(_ctx);
 
 	CORO_BEGIN_CODE(_ctx);
@@ -1465,7 +1465,7 @@ void RMTony::EndTalk(CORO_PARAM) {
 			CORO_INVOKE_0(m_body.WaitForEndPattern);
 		}
 
-		m_bIsTalking = false;  
+		m_bIsTalking = false;
 		return;
 	}
 
@@ -1480,7 +1480,7 @@ void RMTony::EndTalk(CORO_PARAM) {
 		MainFreeze();
 		m_body.SetPattern(_ctx->bodyEndPat);
 		MainUnfreeze();
-		
+
 		CORO_INVOKE_0(WaitForEndPattern);
 		CORO_INVOKE_0(m_body.WaitForEndPattern);
 	} else if (_ctx->bodyEndPat != 0) {
@@ -1493,7 +1493,7 @@ void RMTony::EndTalk(CORO_PARAM) {
 		MainFreeze();
 		m_body.SetPattern(_ctx->bodyEndPat);
 		MainUnfreeze();
-		
+
 		CORO_INVOKE_0(m_body.WaitForEndPattern);
 	} else if (_ctx->headEndPat != 0) {
 		CORO_INVOKE_0(m_body.WaitForEndPattern);
@@ -1514,13 +1514,13 @@ void RMTony::EndTalk(CORO_PARAM) {
 		MainUnfreeze();
 	}
 
-	m_bIsTalking = false;  
+	m_bIsTalking = false;
 
 	CORO_END_CODE;
 }
 
 void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat,
-						  int &bodyStartPat, int &bodyLoopPat) {
+                                  int &bodyStartPat, int &bodyLoopPat) {
 	int nPat = GetCurPattern();
 
 	headLoopPat = -1;
@@ -1539,7 +1539,7 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		m_TalkDirection = LEFT;
 		headPat = PAT_TESTA_LEFT;
 		break;
-		
+
 	case PAT_TAKERIGHT_UP2:
 	case PAT_TAKERIGHT_MID2:
 	case PAT_TAKERIGHT_DOWN2:
@@ -1728,8 +1728,8 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 
 void RMTony::StartStatic(CORO_PARAM, TALKTYPE nTalk) {
 	CORO_BEGIN_CONTEXT;
-		int headPat, headLoopPat;
-		int bodyStartPat, bodyLoopPat;
+	int headPat, headLoopPat;
+	int bodyStartPat, bodyLoopPat;
 	CORO_END_CONTEXT(_ctx);
 
 	CORO_BEGIN_CODE(_ctx);
@@ -1745,7 +1745,7 @@ void RMTony::StartStatic(CORO_PARAM, TALKTYPE nTalk) {
 	m_body.SetPattern(_ctx->bodyStartPat);
 	MainUnfreeze();
 
-	CORO_INVOKE_0(m_body.WaitForEndPattern);	
+	CORO_INVOKE_0(m_body.WaitForEndPattern);
 	CORO_INVOKE_0(WaitForEndPattern);
 
 	MainFreeze();
@@ -1774,7 +1774,8 @@ void RMTony::EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 	switch (nTalk) {
 	case TALK_CONPUPAZZOSTATIC:
 		switch (m_TalkDirection) {
-		case UP: case LEFT:
+		case UP:
+		case LEFT:
 			bodyEndPat = BPAT_CONPUPAZZOLEFT_END;
 			break;
 
@@ -1812,7 +1813,7 @@ void RMTony::EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 			break;
 		}
 		break;
-	
+
 	case TALK_CONCARTESTATIC:
 		switch (m_TalkDirection) {
 		case UP:
@@ -1895,9 +1896,9 @@ void RMTony::EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 
 void RMTony::EndStatic(CORO_PARAM, TALKTYPE nTalk) {
 	CORO_BEGIN_CONTEXT;
-		int bodyEndPat;
-		int finalPat;
-		int headEndPat;
+	int bodyEndPat;
+	int finalPat;
+	int headEndPat;
 	CORO_END_CONTEXT(_ctx);
 
 	CORO_BEGIN_CODE(_ctx);
@@ -1913,21 +1914,21 @@ void RMTony::EndStatic(CORO_PARAM, TALKTYPE nTalk) {
 		SetPattern(_ctx->headEndPat);
 		MainUnfreeze();
 
-		CORO_INVOKE_0(WaitForEndPattern);	
+		CORO_INVOKE_0(WaitForEndPattern);
 	} else {
 		// Play please
 		MainFreeze();
 		m_body.SetPattern(_ctx->bodyEndPat);
 		MainUnfreeze();
 
-		CORO_INVOKE_0(m_body.WaitForEndPattern);	
+		CORO_INVOKE_0(m_body.WaitForEndPattern);
 	}
 
 	MainFreeze();
 	SetPattern(_ctx->finalPat);
 	m_body.SetPattern(0);
 	MainUnfreeze();
-	
+
 	m_bIsStaticTalk = false;
 
 	CORO_END_CODE;
-- 
cgit v1.2.3


From a1f6f8ceb19d65619dfd8e2477bffad773ba49ba Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Mon, 4 Jun 2012 23:45:36 +0200
Subject: TONY: Rename variables and functions in tony.h

---
 engines/tony/tonychar.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 71f95f8133..212899cde3 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -119,7 +119,7 @@ void RMTony::Init(void) {
 	ds.Close();
 	m_body.SetPattern(0);
 
-	m_nTimeLastStep = _vm->GetTime();
+	m_nTimeLastStep = _vm->getTime();
 }
 
 
@@ -141,7 +141,7 @@ void RMTony::DoFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
 	SetSpeed(GLOBALS.nCfgTonySpeed);
 
 	// Runs the normal character movement
-	_ctx->time = _vm->GetTime();
+	_ctx->time = _vm->getTime();
 
 	do {
 		m_nTimeLastStep += (1000 / 40);
-- 
cgit v1.2.3


From 93cba6d88049d73b965143130a1f7751e3dc79db Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Tue, 5 Jun 2012 01:15:25 +0200
Subject: TONY: Rename variables and functions in adv.h

---
 engines/tony/tonychar.cpp | 68 +++++++++++++++++++++++------------------------
 1 file changed, 34 insertions(+), 34 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 212899cde3..419f5a251f 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -596,7 +596,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 	if (m_bPastorella) {
 		// Talking whilst a shepherdess
-		MainFreeze();
+		mainFreeze();
 		switch (m_TalkDirection) {
 		case UP:
 			SetPattern(PAT_PAST_TALKUP);
@@ -614,7 +614,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			SetPattern(PAT_PAST_TALKRIGHT);
 			break;
 		}
-		MainUnfreeze();
+		mainUnfreeze();
 		return false;
 	}
 
@@ -1127,10 +1127,10 @@ void RMTony::StartTalk(CORO_PARAM, TALKTYPE nTalkType) {
 
 	// Perform the set pattern
 	if (_ctx->headStartPat != 0 || _ctx->bodyStartPat != 0) {
-		MainFreeze();
+		mainFreeze();
 		SetPattern(_ctx->headStartPat);
 		m_body.SetPattern(_ctx->bodyStartPat);
-		MainUnfreeze();
+		mainUnfreeze();
 
 		if (_ctx->bodyStartPat != 0)
 			CORO_INVOKE_0(m_body.WaitForEndPattern);
@@ -1138,11 +1138,11 @@ void RMTony::StartTalk(CORO_PARAM, TALKTYPE nTalkType) {
 			CORO_INVOKE_0(WaitForEndPattern);
 	}
 
-	MainFreeze();
+	mainFreeze();
 	SetPattern(_ctx->headLoopPat);
 	if (_ctx->bodyLoopPat)
 		m_body.SetPattern(_ctx->bodyLoopPat);
-	MainUnfreeze();
+	mainUnfreeze();
 
 	CORO_END_CODE;
 }
@@ -1175,9 +1175,9 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 	}
 
 	if (m_bPastorella) {
-		MainFreeze();
+		mainFreeze();
 		SetPattern(finalPat);
-		MainUnfreeze();
+		mainUnfreeze();
 		m_bIsTalking = false;
 		return false;
 	}
@@ -1447,7 +1447,7 @@ void RMTony::EndTalk(CORO_PARAM) {
 	// Handles the end of an animated and static, leaving everything unchanged
 	if (m_bIsStaticTalk) {
 		if (m_nTalkType == TALK_CONBARBASTATIC) {
-			MainFreeze();
+			mainFreeze();
 			SetPattern(0);
 			if (m_TalkDirection == UP || m_TalkDirection == LEFT) {
 				m_body.SetPattern(BPAT_CONBARBALEFT_STATIC);
@@ -1456,11 +1456,11 @@ void RMTony::EndTalk(CORO_PARAM) {
 				m_body.SetPattern(BPAT_CONBARBARIGHT_STATIC);
 				m_nBodyOffset.Set(-26, -14);
 			}
-			MainUnfreeze();
+			mainUnfreeze();
 		} else {
-			MainFreeze();
+			mainFreeze();
 			SetPattern(_ctx->headStandPat);
-			MainUnfreeze();
+			mainUnfreeze();
 
 			CORO_INVOKE_0(m_body.WaitForEndPattern);
 		}
@@ -1471,36 +1471,36 @@ void RMTony::EndTalk(CORO_PARAM) {
 
 	// Set the pattern
 	if (_ctx->headEndPat != 0 && _ctx->bodyEndPat != 0) {
-		MainFreeze();
+		mainFreeze();
 		SetPattern(_ctx->headEndPat);
-		MainUnfreeze();
+		mainUnfreeze();
 
 		CORO_INVOKE_0(m_body.WaitForEndPattern);
 
-		MainFreeze();
+		mainFreeze();
 		m_body.SetPattern(_ctx->bodyEndPat);
-		MainUnfreeze();
+		mainUnfreeze();
 
 		CORO_INVOKE_0(WaitForEndPattern);
 		CORO_INVOKE_0(m_body.WaitForEndPattern);
 	} else if (_ctx->bodyEndPat != 0) {
-		MainFreeze();
+		mainFreeze();
 		SetPattern(_ctx->headStandPat);
-		MainUnfreeze();
+		mainUnfreeze();
 
 		CORO_INVOKE_0(m_body.WaitForEndPattern);
 
-		MainFreeze();
+		mainFreeze();
 		m_body.SetPattern(_ctx->bodyEndPat);
-		MainUnfreeze();
+		mainUnfreeze();
 
 		CORO_INVOKE_0(m_body.WaitForEndPattern);
 	} else if (_ctx->headEndPat != 0) {
 		CORO_INVOKE_0(m_body.WaitForEndPattern);
 
-		MainFreeze();
+		mainFreeze();
 		SetPattern(_ctx->headEndPat);
-		MainUnfreeze();
+		mainUnfreeze();
 
 		CORO_INVOKE_0(WaitForEndPattern);
 	} else {
@@ -1508,10 +1508,10 @@ void RMTony::EndTalk(CORO_PARAM) {
 	}
 
 	if (_ctx->finalPat != 0) {
-		MainFreeze();
+		mainFreeze();
 		m_body.SetPattern(0);
 		SetPattern(_ctx->finalPat);
-		MainUnfreeze();
+		mainUnfreeze();
 	}
 
 	m_bIsTalking = false;
@@ -1740,19 +1740,19 @@ void RMTony::StartStatic(CORO_PARAM, TALKTYPE nTalk) {
 	// e vai con i pattern
 	m_bIsStaticTalk = true;
 
-	MainFreeze();
+	mainFreeze();
 	SetPattern(_ctx->headPat);
 	m_body.SetPattern(_ctx->bodyStartPat);
-	MainUnfreeze();
+	mainUnfreeze();
 
 	CORO_INVOKE_0(m_body.WaitForEndPattern);
 	CORO_INVOKE_0(WaitForEndPattern);
 
-	MainFreeze();
+	mainFreeze();
 	if (_ctx->headLoopPat != -1)
 		SetPattern(_ctx->headLoopPat);
 	m_body.SetPattern(_ctx->bodyLoopPat);
-	MainUnfreeze();
+	mainUnfreeze();
 
 	CORO_END_CODE;
 }
@@ -1910,24 +1910,24 @@ void RMTony::EndStatic(CORO_PARAM, TALKTYPE nTalk) {
 	EndStaticCalculate(nTalk, _ctx->bodyEndPat, _ctx->finalPat, _ctx->headEndPat);
 
 	if (_ctx->headEndPat != 0) {
-		MainFreeze();
+		mainFreeze();
 		SetPattern(_ctx->headEndPat);
-		MainUnfreeze();
+		mainUnfreeze();
 
 		CORO_INVOKE_0(WaitForEndPattern);
 	} else {
 		// Play please
-		MainFreeze();
+		mainFreeze();
 		m_body.SetPattern(_ctx->bodyEndPat);
-		MainUnfreeze();
+		mainUnfreeze();
 
 		CORO_INVOKE_0(m_body.WaitForEndPattern);
 	}
 
-	MainFreeze();
+	mainFreeze();
 	SetPattern(_ctx->finalPat);
 	m_body.SetPattern(0);
-	MainUnfreeze();
+	mainUnfreeze();
 
 	m_bIsStaticTalk = false;
 
-- 
cgit v1.2.3


From 23c95d7014ee9875bb1b55c696d0245d7f114ba8 Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Tue, 5 Jun 2012 08:39:55 +0200
Subject: TONY: Some more renaming

---
 engines/tony/tonychar.cpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 419f5a251f..f135cff7c3 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -40,7 +40,7 @@ namespace Tony {
 
 bool RMTony::m_bAction = false;
 
-void RMTony::InitStatics() {
+void RMTony::initStatics() {
 	m_bAction = false;
 }
 
@@ -82,13 +82,13 @@ RMGfxSourceBuffer *RMTony::NewItemSpriteBuffer(int dimx, int dimy, bool bPreRLE)
 
 	assert(m_cm == CM_256);
 	spr = new RMGfxSourceBuffer8RLEByteAA;
-	spr->SetAlphaBlendColor(1);
+	spr->setAlphaBlendColor(1);
 	if (bPreRLE)
-		spr->SetAlreadyCompressed();
+		spr->setAlreadyCompressed();
 	return spr;
 }
 
-void RMTony::Init(void) {
+void RMTony::init(void) {
 	RMRes tony(0);
 	RMRes body(9999);
 	RMDataStream ds;
@@ -125,7 +125,7 @@ void RMTony::Init(void) {
 
 void RMTony::Close(void) {
 	// Disalloca @@@ Deallocation of missing item
-	m_ombra.Destroy();
+	m_ombra.destroy();
 }
 
 void RMTony::DoFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
@@ -135,8 +135,8 @@ void RMTony::DoFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
 
 	CORO_BEGIN_CODE(_ctx);
 
-	if (!m_nInList && m_bShow)
-		bigBuf->AddPrim(new RMGfxPrimitive(this));
+	if (!_nInList && m_bShow)
+		bigBuf->addPrim(new RMGfxPrimitive(this));
 
 	SetSpeed(GLOBALS.nCfgTonySpeed);
 
@@ -172,7 +172,7 @@ void RMTony::Hide(bool bShowOmbra) {
 }
 
 
-void RMTony::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
+void RMTony::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 	CORO_BEGIN_CONTEXT;
 	CORO_END_CONTEXT(_ctx);
 
@@ -185,7 +185,7 @@ void RMTony::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 			prim->Dst().Offset(-44, -134);
 			if (m_bPastorella)
 				prim->Dst().Offset(1, 4);
-			CORO_INVOKE_2(RMCharacter::Draw, bigBuf, prim);
+			CORO_INVOKE_2(RMCharacter::draw, bigBuf, prim);
 		}
 
 		if (m_bIsTalking || m_bIsStaticTalk) {
@@ -195,7 +195,7 @@ void RMTony::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 			prim->Dst().Offset(m_pos);
 			prim->Dst().Offset(-44, -134);
 			prim->Dst() += m_nBodyOffset;
-			CORO_INVOKE_2(m_body.Draw, bigBuf, prim);
+			CORO_INVOKE_2(m_body.draw, bigBuf, prim);
 		}
 
 		if (!m_bCorpoDavanti) {
@@ -203,7 +203,7 @@ void RMTony::Draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 			prim->Dst().Offset(-44, -134);
 			if (m_bPastorella)
 				prim->Dst().Offset(0, 3);
-			CORO_INVOKE_2(RMCharacter::Draw, bigBuf, prim);
+			CORO_INVOKE_2(RMCharacter::draw, bigBuf, prim);
 		}
 	}
 
-- 
cgit v1.2.3


From 334dc91e279d01b264ae7454f39faa557a250428 Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Wed, 6 Jun 2012 01:37:06 +0200
Subject: TONY: Rename variables and functions in game.h

---
 engines/tony/tonychar.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index f135cff7c3..8bca6fe7f6 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -156,7 +156,7 @@ void RMTony::DoFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
 	}
 
 	if (m_bIsTalking || m_bIsStaticTalk)
-		m_body.DoFrame(bigBuf, false);
+		m_body.doFrame(bigBuf, false);
 
 	CORO_END_CODE;
 }
-- 
cgit v1.2.3


From 53bd99ce870ac5bd7f65d1e45641e13070f652d0 Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Thu, 7 Jun 2012 07:58:01 +0200
Subject: TONY: Rename variables and functions in loc.h and tonychar.h

---
 engines/tony/tonychar.cpp | 677 +++++++++++++++++++++++-----------------------
 1 file changed, 338 insertions(+), 339 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 8bca6fe7f6..dc771b08aa 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -38,31 +38,31 @@ namespace Tony {
 *       Metodi di RMTony
 \****************************************************************************/
 
-bool RMTony::m_bAction = false;
+bool RMTony::_bAction = false;
 
 void RMTony::initStatics() {
-	m_bAction = false;
+	_bAction = false;
 }
 
 RMTony::RMTony() {
-	m_bShow = false;
-	m_bShowOmbra = false;
-	m_bCorpoDavanti = false;
-	m_bActionPending = false;
-	m_ActionItem = NULL;
-	m_Action = 0;
-	m_ActionParm = 0;
-	m_bPastorella = false;
-	m_bIsStaticTalk = false;
-	m_bIsTalking = false;
-	m_nPatB4Talking = 0;
-	m_nTalkType = TALK_NORMAL;
-	m_TalkDirection = UP;
-	m_nTimeLastStep = 0;
+	_bShow = false;
+	_bShowOmbra = false;
+	_bCorpoDavanti = false;
+	_bActionPending = false;
+	_ActionItem = NULL;
+	_Action = 0;
+	_ActionParm = 0;
+	_bPastorella = false;
+	_bIsStaticTalk = false;
+	_bIsTalking = false;
+	_nPatB4Talking = 0;
+	_nTalkType = TALK_NORMAL;
+	_TalkDirection = UP;
+	_nTimeLastStep = 0;
 	hActionThread = CORO_INVALID_PID_VALUE;
 }
 
-void RMTony::WaitEndOfAction(CORO_PARAM, const void *param) {
+void RMTony::waitEndOfAction(CORO_PARAM, const void *param) {
 	CORO_BEGIN_CONTEXT;
 	CORO_END_CONTEXT(_ctx);
 
@@ -72,15 +72,15 @@ void RMTony::WaitEndOfAction(CORO_PARAM, const void *param) {
 
 	CORO_INVOKE_2(CoroScheduler.waitForSingleObject, pid, CORO_INFINITE);
 
-	m_bAction = false;
+	_bAction = false;
 
 	CORO_END_CODE;
 }
 
-RMGfxSourceBuffer *RMTony::NewItemSpriteBuffer(int dimx, int dimy, bool bPreRLE) {
+RMGfxSourceBuffer *RMTony::newItemSpriteBuffer(int dimx, int dimy, bool bPreRLE) {
 	RMGfxSourceBuffer8RLE *spr;
 
-	assert(m_cm == CM_256);
+	assert(_cm == CM_256);
 	spr = new RMGfxSourceBuffer8RLEByteAA;
 	spr->setAlphaBlendColor(1);
 	if (bPreRLE)
@@ -94,81 +94,80 @@ void RMTony::init(void) {
 	RMDataStream ds;
 
 	// Tony is shown by default
-	m_bShow = m_bShowOmbra = true;
+	_bShow = _bShowOmbra = true;
 
 	// No action pending
-	m_bActionPending = false;
-	m_bAction = false;
+	_bActionPending = false;
+	_bAction = false;
 
-	m_bPastorella = false;
-	m_bIsTalking = false;
-	m_bIsStaticTalk = false;
+	_bPastorella = false;
+	_bIsTalking = false;
+	_bIsStaticTalk = false;
 
 	// Opens the buffer
 	ds.OpenBuffer(tony);
 
 	// Reads his details from the stream
-	ReadFromStream(ds, true);
+	readFromStream(ds, true);
 
 	// Closes the buffer
 	ds.Close();
 
 	// Reads Tony's body
 	ds.OpenBuffer(body);
-	m_body.ReadFromStream(ds, true);
+	_body.readFromStream(ds, true);
 	ds.Close();
-	m_body.SetPattern(0);
+	_body.setPattern(0);
 
-	m_nTimeLastStep = _vm->getTime();
+	_nTimeLastStep = _vm->getTime();
 }
 
 
-void RMTony::Close(void) {
+void RMTony::close(void) {
 	// Disalloca @@@ Deallocation of missing item
-	m_ombra.destroy();
+	_ombra.destroy();
 }
 
-void RMTony::DoFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
+void RMTony::doFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
 	CORO_BEGIN_CONTEXT;
 	int time;
 	CORO_END_CONTEXT(_ctx);
 
 	CORO_BEGIN_CODE(_ctx);
 
-	if (!_nInList && m_bShow)
+	if (!_nInList && _bShow)
 		bigBuf->addPrim(new RMGfxPrimitive(this));
 
-	SetSpeed(GLOBALS.nCfgTonySpeed);
+	setSpeed(GLOBALS.nCfgTonySpeed);
 
 	// Runs the normal character movement
 	_ctx->time = _vm->getTime();
 
 	do {
-		m_nTimeLastStep += (1000 / 40);
-		CORO_INVOKE_2(RMCharacter::DoFrame, bigBuf, curLoc);
-
-	} while (_ctx->time > m_nTimeLastStep + (1000 / 40));
+		_nTimeLastStep += (1000 / 40);
+		CORO_INVOKE_2(RMCharacter::doFrame, bigBuf, curLoc);
+	} while (_ctx->time > _nTimeLastStep + (1000 / 40));
 
 	// Check if we are at the end of a path
-	if (EndOfPath() && m_bActionPending) {
+	if (endOfPath() && _bActionPending) {
 		// Must perform the action on which we clicked
-		m_bActionPending = false;
+		_bActionPending = false;
 	}
 
-	if (m_bIsTalking || m_bIsStaticTalk)
-		m_body.doFrame(bigBuf, false);
+	if (_bIsTalking || _bIsStaticTalk)
+		_body.doFrame(bigBuf, false);
 
 	CORO_END_CODE;
 }
 
-void RMTony::Show(void) {
-	m_bShow = true;
-	m_bShowOmbra = true;
+void RMTony::show(void) {
+	_bShow = true;
+	_bShowOmbra = true;
 }
 
-void RMTony::Hide(bool bShowOmbra) {
-	m_bShow = false;
-	m_bShowOmbra = bShowOmbra;
+void RMTony::hide(bool bShowOmbra) {
+	_bShow = false;
+	_bShowOmbra = bShowOmbra;
 }
 
 
@@ -179,29 +178,29 @@ void RMTony::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 	CORO_BEGIN_CODE(_ctx);
 
 	// Call the Draw() of the parent class if Tony is visible
-	if (m_bShow && bDrawNow) {
-		if (m_bCorpoDavanti) {
+	if (_bShow && bDrawNow) {
+		if (_bCorpoDavanti) {
 			prim->Dst().SetEmpty();
 			prim->Dst().Offset(-44, -134);
-			if (m_bPastorella)
+			if (_bPastorella)
 				prim->Dst().Offset(1, 4);
 			CORO_INVOKE_2(RMCharacter::draw, bigBuf, prim);
 		}
 
-		if (m_bIsTalking || m_bIsStaticTalk) {
+		if (_bIsTalking || _bIsStaticTalk) {
 			// Offest direction from scrolling
 			prim->Dst().SetEmpty();
-			prim->Dst().Offset(-m_curScroll);
-			prim->Dst().Offset(m_pos);
+			prim->Dst().Offset(-_curScroll);
+			prim->Dst().Offset(_pos);
 			prim->Dst().Offset(-44, -134);
-			prim->Dst() += m_nBodyOffset;
-			CORO_INVOKE_2(m_body.draw, bigBuf, prim);
+			prim->Dst() += _nBodyOffset;
+			CORO_INVOKE_2(_body.draw, bigBuf, prim);
 		}
 
-		if (!m_bCorpoDavanti) {
+		if (!_bCorpoDavanti) {
 			prim->Dst().SetEmpty();
 			prim->Dst().Offset(-44, -134);
-			if (m_bPastorella)
+			if (_bPastorella)
 				prim->Dst().Offset(0, 3);
 			CORO_INVOKE_2(RMCharacter::draw, bigBuf, prim);
 		}
@@ -210,7 +209,7 @@ void RMTony::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 	CORO_END_CODE;
 }
 
-void RMTony::MoveAndDoAction(CORO_PARAM, RMPoint dst, RMItem *item, int nAction, int nActionParm) {
+void RMTony::moveAndDoAction(CORO_PARAM, RMPoint dst, RMItem *item, int nAction, int nActionParm) {
 	CORO_BEGIN_CONTEXT;
 	bool result;
 	CORO_END_CONTEXT(_ctx);
@@ -219,26 +218,26 @@ void RMTony::MoveAndDoAction(CORO_PARAM, RMPoint dst, RMItem *item, int nAction,
 
 	// Makes normal movement, but remember if you must then perform an action
 	if (item == NULL) {
-		m_bActionPending = false;
-		m_ActionItem = NULL;
+		_bActionPending = false;
+		_ActionItem = NULL;
 	} else {
-		m_ActionItem = item;
-		m_Action = nAction;
-		m_ActionParm = nActionParm;
-		m_bActionPending = true;
+		_ActionItem = item;
+		_Action = nAction;
+		_ActionParm = nActionParm;
+		_bActionPending = true;
 	}
 
-	CORO_INVOKE_2(RMCharacter::Move, dst, &_ctx->result);
+	CORO_INVOKE_2(RMCharacter::move, dst, &_ctx->result);
 	if (!_ctx->result) {
-		m_bActionPending = false;
-		m_ActionItem = NULL;
+		_bActionPending = false;
+		_ActionItem = NULL;
 	}
 
 	CORO_END_CODE;
 }
 
 
-void RMTony::ExecuteAction(int nAction, int nActionItem, int nParm) {
+void RMTony::executeAction(int nAction, int nActionItem, int nParm) {
 	uint32 pid;
 
 	if (nAction == TA_COMBINE) {
@@ -264,85 +263,85 @@ void RMTony::ExecuteAction(int nAction, int nActionItem, int nParm) {
 	}
 
 	if (pid != CORO_INVALID_PID_VALUE) {
-		m_bAction = true;
-		CoroScheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
+		_bAction = true;
+		CoroScheduler.createProcess(waitEndOfAction, &pid, sizeof(uint32));
 		hActionThread = pid;
 	} else if (nAction != TA_GOTO) {
 		if (nAction == TA_TALK) {
 			pid = mpalQueryDoAction(6, 1, 0);
-			m_bAction = true;
-			CoroScheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
+			_bAction = true;
+			CoroScheduler.createProcess(waitEndOfAction, &pid, sizeof(uint32));
 			hActionThread = pid;
 		} else if (nAction == TA_PALESATI) {
 			pid = mpalQueryDoAction(7, 1, 0);
-			m_bAction = true;
-			CoroScheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
+			_bAction = true;
+			CoroScheduler.createProcess(waitEndOfAction, &pid, sizeof(uint32));
 			hActionThread = pid;
 		} else {
 			pid = mpalQueryDoAction(5, 1, 0);
-			m_bAction = true;
-			CoroScheduler.createProcess(WaitEndOfAction, &pid, sizeof(uint32));
+			_bAction = true;
+			CoroScheduler.createProcess(waitEndOfAction, &pid, sizeof(uint32));
 			hActionThread = pid;
 		}
 	}
 }
 
 
-void RMTony::StopNoAction(CORO_PARAM) {
+void RMTony::stopNoAction(CORO_PARAM) {
 	CORO_BEGIN_CONTEXT;
 	CORO_END_CONTEXT(_ctx);
 
 	CORO_BEGIN_CODE(_ctx);
 
-	if (m_bAction)
+	if (_bAction)
 		CORO_INVOKE_2(CoroScheduler.waitForSingleObject, hActionThread, CORO_INFINITE);
 
-	m_bActionPending = false;
-	m_ActionItem = NULL;
-	CORO_INVOKE_0(Stop);
+	_bActionPending = false;
+	_ActionItem = NULL;
+	CORO_INVOKE_0(stop);
 
 	CORO_END_CODE;
 }
 
-void RMTony::Stop(CORO_PARAM) {
+void RMTony::stop(CORO_PARAM) {
 	CORO_BEGIN_CONTEXT;
 	uint32 pid;
 	CORO_END_CONTEXT(_ctx);
 
 	CORO_BEGIN_CODE(_ctx);
 
-	if (m_ActionItem != NULL) {
+	if (_ActionItem != NULL) {
 		// Call MPAL to choose the direction
-		_ctx->pid = mpalQueryDoAction(21, m_ActionItem->MpalCode(), 0);
+		_ctx->pid = mpalQueryDoAction(21, _ActionItem->mpalCode(), 0);
 
 		if (_ctx->pid == CORO_INVALID_PID_VALUE)
-			CORO_INVOKE_0(RMCharacter::Stop);
+			CORO_INVOKE_0(RMCharacter::stop);
 		else {
 			bNeedToStop = false;    // If we make the OnWhichDirection, we don't need at least after the Stop().
 			bMoving = false;
 			CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->pid, CORO_INFINITE); // @@@ Put an assert after 10 seconds
 		}
 	} else {
-		CORO_INVOKE_0(RMCharacter::Stop);
+		CORO_INVOKE_0(RMCharacter::stop);
 	}
 
-	if (!m_bActionPending)
+	if (!_bActionPending)
 		return;
 
-	m_bActionPending = false;
+	_bActionPending = false;
 
-	ExecuteAction(m_Action, m_ActionItem->MpalCode(), m_ActionParm);
+	executeAction(_Action, _ActionItem->mpalCode(), _ActionParm);
 
-	m_ActionItem = NULL;
+	_ActionItem = NULL;
 
 	CORO_END_CODE;
 }
 
 
-int RMTony::GetCurPattern(void) {
-	int nPatt = RMCharacter::GetCurPattern();
+int RMTony::getCurPattern(void) {
+	int nPatt = RMCharacter::getCurPattern();
 
-	if (!m_bPastorella)
+	if (!_bPastorella)
 		return nPatt;
 
 	switch (nPatt) {
@@ -367,8 +366,8 @@ int RMTony::GetCurPattern(void) {
 	return nPatt;
 }
 
-void RMTony::SetPattern(int nPatt, bool bPlayP0) {
-	if (m_bPastorella) {
+void RMTony::setPattern(int nPatt, bool bPlayP0) {
+	if (_bPastorella) {
 		switch (nPatt) {
 		case PAT_STANDUP:
 			nPatt = PAT_PAST_STANDUP;
@@ -397,13 +396,13 @@ void RMTony::SetPattern(int nPatt, bool bPlayP0) {
 		}
 	}
 
-	RMCharacter::SetPattern(nPatt, bPlayP0);
+	RMCharacter::setPattern(nPatt, bPlayP0);
 }
 
 
-void RMTony::Take(int nWhere, int nPart) {
+void RMTony::take(int nWhere, int nPart) {
 	if (nPart == 0) {
-		switch (GetCurPattern()) {
+		switch (getCurPattern()) {
 		case PAT_STANDDOWN:
 			assert(0);  // Not while you're doing a StandDown
 			break;
@@ -411,13 +410,13 @@ void RMTony::Take(int nWhere, int nPart) {
 		case PAT_STANDUP:
 			switch (nWhere) {
 			case 0:
-				SetPattern(PAT_TAKEUP_UP1);
+				setPattern(PAT_TAKEUP_UP1);
 				break;
 			case 1:
-				SetPattern(PAT_TAKEUP_MID1);
+				setPattern(PAT_TAKEUP_MID1);
 				break;
 			case 2:
-				SetPattern(PAT_TAKEUP_DOWN1);
+				setPattern(PAT_TAKEUP_DOWN1);
 				break;
 			}
 			break;
@@ -425,13 +424,13 @@ void RMTony::Take(int nWhere, int nPart) {
 		case PAT_STANDRIGHT:
 			switch (nWhere) {
 			case 0:
-				SetPattern(PAT_TAKERIGHT_UP1);
+				setPattern(PAT_TAKERIGHT_UP1);
 				break;
 			case 1:
-				SetPattern(PAT_TAKERIGHT_MID1);
+				setPattern(PAT_TAKERIGHT_MID1);
 				break;
 			case 2:
-				SetPattern(PAT_TAKERIGHT_DOWN1);
+				setPattern(PAT_TAKERIGHT_DOWN1);
 				break;
 			}
 			break;
@@ -439,46 +438,46 @@ void RMTony::Take(int nWhere, int nPart) {
 		case PAT_STANDLEFT:
 			switch (nWhere) {
 			case 0:
-				SetPattern(PAT_TAKELEFT_UP1);
+				setPattern(PAT_TAKELEFT_UP1);
 				break;
 			case 1:
-				SetPattern(PAT_TAKELEFT_MID1);
+				setPattern(PAT_TAKELEFT_MID1);
 				break;
 			case 2:
-				SetPattern(PAT_TAKELEFT_DOWN1);
+				setPattern(PAT_TAKELEFT_DOWN1);
 				break;
 			}
 			break;
 		}
 	} else if (nPart == 1) {
-		SetPattern(GetCurPattern() + 1);
+		setPattern(getCurPattern() + 1);
 	} else if (nPart == 2) {
-		switch (GetCurPattern()) {
+		switch (getCurPattern()) {
 		case PAT_TAKEUP_UP2:
 		case PAT_TAKEUP_MID2:
 		case PAT_TAKEUP_DOWN2:
-			SetPattern(PAT_STANDUP);
+			setPattern(PAT_STANDUP);
 			break;
 
 		case PAT_TAKELEFT_UP2:
 		case PAT_TAKELEFT_MID2:
 		case PAT_TAKELEFT_DOWN2:
-			SetPattern(PAT_STANDLEFT);
+			setPattern(PAT_STANDLEFT);
 			break;
 
 		case PAT_TAKERIGHT_UP2:
 		case PAT_TAKERIGHT_MID2:
 		case PAT_TAKERIGHT_DOWN2:
-			SetPattern(PAT_STANDRIGHT);
+			setPattern(PAT_STANDRIGHT);
 			break;
 		}
 	}
 }
 
 
-void RMTony::Put(int nWhere, int nPart) {
+void RMTony::put(int nWhere, int nPart) {
 	if (nPart == 0) {
-		switch (GetCurPattern()) {
+		switch (getCurPattern()) {
 		case PAT_STANDDOWN:
 			//assert(0);
 			break;
@@ -486,13 +485,13 @@ void RMTony::Put(int nWhere, int nPart) {
 		case PAT_STANDUP:
 			switch (nWhere) {
 			case 0:
-				SetPattern(PAT_PUTUP_UP1);
+				setPattern(PAT_PUTUP_UP1);
 				break;
 			case 1:
-				SetPattern(PAT_PUTUP_MID1);
+				setPattern(PAT_PUTUP_MID1);
 				break;
 			case 2:
-				SetPattern(PAT_PUTUP_DOWN1);
+				setPattern(PAT_PUTUP_DOWN1);
 				break;
 			}
 			break;
@@ -500,13 +499,13 @@ void RMTony::Put(int nWhere, int nPart) {
 		case PAT_STANDRIGHT:
 			switch (nWhere) {
 			case 0:
-				SetPattern(PAT_PUTRIGHT_UP1);
+				setPattern(PAT_PUTRIGHT_UP1);
 				break;
 			case 1:
-				SetPattern(PAT_PUTRIGHT_MID1);
+				setPattern(PAT_PUTRIGHT_MID1);
 				break;
 			case 2:
-				SetPattern(PAT_PUTRIGHT_DOWN1);
+				setPattern(PAT_PUTRIGHT_DOWN1);
 				break;
 			}
 			break;
@@ -514,56 +513,56 @@ void RMTony::Put(int nWhere, int nPart) {
 		case PAT_STANDLEFT:
 			switch (nWhere) {
 			case 0:
-				SetPattern(PAT_PUTLEFT_UP1);
+				setPattern(PAT_PUTLEFT_UP1);
 				break;
 			case 1:
-				SetPattern(PAT_PUTLEFT_MID1);
+				setPattern(PAT_PUTLEFT_MID1);
 				break;
 			case 2:
-				SetPattern(PAT_PUTLEFT_DOWN1);
+				setPattern(PAT_PUTLEFT_DOWN1);
 				break;
 			}
 			break;
 		}
 	} else if (nPart == 1) {
-		SetPattern(GetCurPattern() + 1);
+		setPattern(getCurPattern() + 1);
 	} else if (nPart == 2) {
-		switch (GetCurPattern()) {
+		switch (getCurPattern()) {
 		case PAT_PUTUP_UP2:
 		case PAT_PUTUP_MID2:
 		case PAT_PUTUP_DOWN2:
-			SetPattern(PAT_STANDUP);
+			setPattern(PAT_STANDUP);
 			break;
 
 		case PAT_PUTLEFT_UP2:
 		case PAT_PUTLEFT_MID2:
 		case PAT_PUTLEFT_DOWN2:
-			SetPattern(PAT_STANDLEFT);
+			setPattern(PAT_STANDLEFT);
 			break;
 
 		case PAT_PUTRIGHT_UP2:
 		case PAT_PUTRIGHT_MID2:
 		case PAT_PUTRIGHT_DOWN2:
-			SetPattern(PAT_STANDRIGHT);
+			setPattern(PAT_STANDRIGHT);
 			break;
 		}
 	}
 }
 
 
-bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &bodyStartPat,
+bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &bodyStartPat,
                                 int &headLoopPat, int &bodyLoopPat) {
-	assert(!m_bIsTalking);
+	assert(!_bIsTalking);
 
-	m_bIsTalking = true;
-	m_nPatB4Talking = GetCurPattern();
-	m_nTalkType = nTalkType;
+	_bIsTalking = true;
+	_nPatB4Talking = getCurPattern();
+	_nTalkType = nTalkType;
 
 	// Set the direction of speech ONLY if we are not in a static animation (since it would have already been done)
-	if (!m_bIsStaticTalk) {
-		switch (m_nPatB4Talking) {
+	if (!_bIsStaticTalk) {
+		switch (_nPatB4Talking) {
 		case PAT_STANDDOWN:
-			m_TalkDirection = DOWN;
+			_TalkDirection = DOWN;
 			break;
 
 		case PAT_TAKELEFT_UP2:
@@ -571,7 +570,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case PAT_TAKELEFT_DOWN2:
 		case PAT_SIRIALZALEFT:
 		case PAT_STANDLEFT:
-			m_TalkDirection = LEFT;
+			_TalkDirection = LEFT;
 			break;
 
 		case PAT_TAKERIGHT_UP2:
@@ -579,39 +578,39 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case PAT_TAKERIGHT_DOWN2:
 		case PAT_SIRIALZARIGHT:
 		case PAT_STANDRIGHT:
-			m_TalkDirection = RIGHT;
+			_TalkDirection = RIGHT;
 			break;
 
 		case PAT_TAKEUP_UP2:
 		case PAT_TAKEUP_MID2:
 		case PAT_TAKEUP_DOWN2:
 		case PAT_STANDUP:
-			m_TalkDirection = UP;
+			_TalkDirection = UP;
 			break;
 		}
 
 		// Puts the body in front by default
-		m_bCorpoDavanti = true;
+		_bCorpoDavanti = true;
 	}
 
-	if (m_bPastorella) {
+	if (_bPastorella) {
 		// Talking whilst a shepherdess
 		mainFreeze();
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
-			SetPattern(PAT_PAST_TALKUP);
+			setPattern(PAT_PAST_TALKUP);
 			break;
 
 		case DOWN:
-			SetPattern(PAT_PAST_TALKDOWN);
+			setPattern(PAT_PAST_TALKDOWN);
 			break;
 
 		case LEFT:
-			SetPattern(PAT_PAST_TALKLEFT);
+			setPattern(PAT_PAST_TALKLEFT);
 			break;
 
 		case RIGHT:
-			SetPattern(PAT_PAST_TALKRIGHT);
+			setPattern(PAT_PAST_TALKRIGHT);
 			break;
 		}
 		mainUnfreeze();
@@ -623,42 +622,42 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 	switch (nTalkType) {
 	case TALK_NORMAL:
-		m_bCorpoDavanti = false;
+		_bCorpoDavanti = false;
 		headStartPat = 0;
 		bodyStartPat = 0;
 
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case DOWN:
 			headLoopPat = PAT_TALK_DOWN;
 			bodyLoopPat = BPAT_STANDDOWN;
-			m_nBodyOffset.Set(4, 53);
+			_nBodyOffset.Set(4, 53);
 			break;
 
 		case LEFT:
 			headLoopPat = PAT_TALK_LEFT;
 			bodyLoopPat = BPAT_STANDLEFT;
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 			break;
 
 		case RIGHT:
 			headLoopPat = PAT_TALK_RIGHT;
 			bodyLoopPat = BPAT_STANDRIGHT;
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 			break;
 
 		case UP:
 			headLoopPat = PAT_TALK_UP;
 			bodyLoopPat = BPAT_STANDUP;
-			m_nBodyOffset.Set(6, 53);
+			_nBodyOffset.Set(6, 53);
 			break;
 		}
 		break;
 
 	case TALK_FIANCHI:
-		m_bCorpoDavanti = false;
-		switch (m_TalkDirection) {
+		_bCorpoDavanti = false;
+		switch (_TalkDirection) {
 		case UP:
-			m_nBodyOffset.Set(2, 42);
+			_nBodyOffset.Set(2, 42);
 			headStartPat = PAT_TESTA_UP;
 			bodyStartPat = BPAT_FIANCHIUP_START;
 			headLoopPat = PAT_TALK_UP;
@@ -666,7 +665,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 
 		case DOWN:
-			m_nBodyOffset.Set(2, 48);
+			_nBodyOffset.Set(2, 48);
 			headStartPat = PAT_TESTA_DOWN;
 			bodyStartPat = BPAT_FIANCHIDOWN_START;
 			headLoopPat = PAT_TALK_DOWN;
@@ -674,7 +673,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 
 		case LEFT:
-			m_nBodyOffset.Set(-3, 53);
+			_nBodyOffset.Set(-3, 53);
 			headStartPat = PAT_TESTA_LEFT;
 			bodyStartPat = BPAT_FIANCHILEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
@@ -682,7 +681,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 
 		case RIGHT:
-			m_nBodyOffset.Set(2, 53);
+			_nBodyOffset.Set(2, 53);
 			headStartPat = PAT_TESTA_RIGHT;
 			bodyStartPat = BPAT_FIANCHIRIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
@@ -693,7 +692,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 
 	case TALK_CANTA:
-		m_nBodyOffset.Set(-10, 25);
+		_nBodyOffset.Set(-10, 25);
 		headStartPat = PAT_TESTA_LEFT;
 		bodyStartPat = BPAT_CANTALEFT_START;
 		headLoopPat = PAT_TALK_LEFT;
@@ -701,12 +700,12 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_RIDE:
-		m_bCorpoDavanti = false;
-		switch (m_TalkDirection) {
+		_bCorpoDavanti = false;
+		switch (_TalkDirection) {
 		case UP:
 		case DOWN:
 		case LEFT:
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 			headStartPat = PAT_RIDELEFT_START;
 			bodyStartPat = BPAT_STANDLEFT;
 			headLoopPat = PAT_RIDELEFT_LOOP;
@@ -714,7 +713,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 
 		case RIGHT:
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 			headStartPat = PAT_RIDERIGHT_START;
 			bodyStartPat = BPAT_STANDRIGHT;
 			headLoopPat = PAT_RIDERIGHT_LOOP;
@@ -724,19 +723,19 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_RIDE2:
-		m_bCorpoDavanti = false;
-		switch (m_TalkDirection) {
+		_bCorpoDavanti = false;
+		switch (_TalkDirection) {
 		case UP:
 		case DOWN:
 		case LEFT:
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 			headStartPat = PAT_RIDELEFT_START;
 			bodyStartPat = BPAT_STANDLEFT;
 			headLoopPat = PAT_RIDELEFT_LOOP;
 			break;
 
 		case RIGHT:
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 			headStartPat = PAT_RIDERIGHT_START;
 			bodyStartPat = BPAT_STANDRIGHT;
 			headLoopPat = PAT_RIDERIGHT_LOOP;
@@ -747,17 +746,17 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 
 	case TALK_SIINDICA:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case DOWN:
 		case LEFT:
-			m_nBodyOffset.Set(-4, 40);
+			_nBodyOffset.Set(-4, 40);
 			headLoopPat = PAT_TALK_LEFT;
 			bodyLoopPat = BPAT_SIINDICALEFT;
 			break;
 
 		case RIGHT:
-			m_nBodyOffset.Set(5, 40);
+			_nBodyOffset.Set(5, 40);
 			headLoopPat = PAT_TALK_RIGHT;
 			bodyLoopPat = BPAT_SIINDICARIGHT;
 			break;
@@ -765,9 +764,9 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_SPAVENTATO:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
-			m_nBodyOffset.Set(-4, -11);
+			_nBodyOffset.Set(-4, -11);
 			headStartPat = PAT_TESTA_UP;
 			bodyStartPat = BPAT_SPAVENTOUP_START;
 			headLoopPat = PAT_TALK_UP;
@@ -775,7 +774,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 
 		case DOWN:
-			m_nBodyOffset.Set(-5, 45);
+			_nBodyOffset.Set(-5, 45);
 			headStartPat = PAT_SPAVENTODOWN_START;
 			bodyStartPat = BPAT_SPAVENTODOWN_START;
 			headLoopPat = PAT_SPAVENTODOWN_LOOP;
@@ -783,7 +782,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 
 		case RIGHT:
-			m_nBodyOffset.Set(-4, 41);
+			_nBodyOffset.Set(-4, 41);
 			headStartPat = PAT_SPAVENTORIGHT_START;
 			bodyStartPat = BPAT_SPAVENTORIGHT_START;
 			headLoopPat = PAT_SPAVENTORIGHT_LOOP;
@@ -791,7 +790,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 
 		case LEFT:
-			m_nBodyOffset.Set(-10, 41);
+			_nBodyOffset.Set(-10, 41);
 			headStartPat = PAT_SPAVENTOLEFT_START;
 			bodyStartPat = BPAT_SPAVENTOLEFT_START;
 			headLoopPat = PAT_SPAVENTOLEFT_LOOP;
@@ -801,12 +800,12 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_SPAVENTATO2:
-		m_bCorpoDavanti = false;
-		switch (m_TalkDirection) {
+		_bCorpoDavanti = false;
+		switch (_TalkDirection) {
 		case UP:
 			bodyStartPat = BPAT_STANDUP;
 			bodyLoopPat = BPAT_STANDUP;
-			m_nBodyOffset.Set(6, 53);
+			_nBodyOffset.Set(6, 53);
 
 			headStartPat = PAT_TESTA_UP;
 			headLoopPat = PAT_TALK_UP;
@@ -815,7 +814,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case DOWN:
 			bodyStartPat = BPAT_STANDDOWN;
 			bodyLoopPat = BPAT_STANDDOWN;
-			m_nBodyOffset.Set(4, 53);
+			_nBodyOffset.Set(4, 53);
 
 			headStartPat = PAT_SPAVENTODOWN_START;
 			headLoopPat = PAT_SPAVENTODOWN_LOOP;
@@ -824,7 +823,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case RIGHT:
 			bodyStartPat = BPAT_STANDRIGHT;
 			bodyLoopPat = BPAT_STANDRIGHT;
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 
 			headStartPat = PAT_SPAVENTORIGHT_START;
 			headLoopPat = PAT_SPAVENTORIGHT_LOOP;
@@ -833,7 +832,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case LEFT:
 			bodyStartPat = BPAT_STANDLEFT;
 			bodyLoopPat = BPAT_STANDLEFT;
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 
 			headStartPat = PAT_SPAVENTOLEFT_START;
 			headLoopPat = PAT_SPAVENTOLEFT_LOOP;
@@ -842,36 +841,36 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_CONBICCHIERE:
-		m_nBodyOffset.Set(4, 53);
+		_nBodyOffset.Set(4, 53);
 		headLoopPat = PAT_TALK_DOWN;
 		bodyLoopPat = BPAT_BICCHIERE;
 		break;
 	case TALK_CONVERME:
-		m_nBodyOffset.Set(9, 56);
+		_nBodyOffset.Set(9, 56);
 		headLoopPat = PAT_TALK_RIGHT;
 		bodyLoopPat = BPAT_VERME;
 		break;
 	case TALK_CONMARTELLO:
-		m_nBodyOffset.Set(6, 56);
+		_nBodyOffset.Set(6, 56);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MARTELLO;
 		break;
 	case TALK_CONCORDA:
-		m_nBodyOffset.Set(-3, 38);
+		_nBodyOffset.Set(-3, 38);
 		headLoopPat = PAT_TALK_RIGHT;
 		bodyLoopPat = BPAT_CORDA;
 		break;
 	case TALK_CONSEGRETARIA:
-		m_nBodyOffset.Set(-17, 12);
+		_nBodyOffset.Set(-17, 12);
 		headLoopPat = PAT_TALK_RIGHT;
 		bodyLoopPat = BPAT_CONSEGRETARIA;
 		break;
 
 	case TALK_CONCONIGLIO:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case LEFT:
 		case UP:
-			m_nBodyOffset.Set(-21, -5);
+			_nBodyOffset.Set(-21, -5);
 			bodyStartPat = BPAT_CONCONIGLIOLEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
 			bodyLoopPat = BPAT_CONCONIGLIOLEFT_LOOP;
@@ -879,7 +878,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case DOWN:
 		case RIGHT:
-			m_nBodyOffset.Set(-4, -5);
+			_nBodyOffset.Set(-4, -5);
 			bodyStartPat = BPAT_CONCONIGLIORIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
 			bodyLoopPat = BPAT_CONCONIGLIORIGHT_LOOP;
@@ -888,10 +887,10 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_CONRICETTA:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case LEFT:
 		case UP:
-			m_nBodyOffset.Set(-61, -7);
+			_nBodyOffset.Set(-61, -7);
 			bodyStartPat = BPAT_CONRICETTALEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
 			bodyLoopPat = BPAT_CONRICETTALEFT_LOOP;
@@ -899,7 +898,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case DOWN:
 		case RIGHT:
-			m_nBodyOffset.Set(-5, -7);
+			_nBodyOffset.Set(-5, -7);
 			bodyStartPat = BPAT_CONRICETTARIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
 			bodyLoopPat = BPAT_CONRICETTARIGHT_LOOP;
@@ -908,10 +907,10 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_CONCARTE:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case LEFT:
 		case UP:
-			m_nBodyOffset.Set(-34, -2);
+			_nBodyOffset.Set(-34, -2);
 			bodyStartPat = BPAT_CONCARTELEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
 			bodyLoopPat = BPAT_CONCARTELEFT_LOOP;
@@ -919,7 +918,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case DOWN:
 		case RIGHT:
-			m_nBodyOffset.Set(-4, -2);
+			_nBodyOffset.Set(-4, -2);
 			bodyStartPat = BPAT_CONCARTERIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
 			bodyLoopPat = BPAT_CONCARTERIGHT_LOOP;
@@ -928,10 +927,10 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_CONPUPAZZO:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case LEFT:
 		case UP:
-			m_nBodyOffset.Set(-35, 2);
+			_nBodyOffset.Set(-35, 2);
 			bodyStartPat = BPAT_CONPUPAZZOLEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
 			bodyLoopPat = BPAT_CONPUPAZZOLEFT_LOOP;
@@ -939,7 +938,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case DOWN:
 		case RIGHT:
-			m_nBodyOffset.Set(-14, 2);
+			_nBodyOffset.Set(-14, 2);
 			bodyStartPat = BPAT_CONPUPAZZORIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
 			bodyLoopPat = BPAT_CONPUPAZZORIGHT_LOOP;
@@ -953,7 +952,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 	case TALK_CONCARTESTATIC:
 	case TALK_CONTACCUINOSTATIC:
 	case TALK_CONMEGAFONOSTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case LEFT:
 		case UP:
 			headLoopPat = PAT_TALK_LEFT;
@@ -968,28 +967,28 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		// The beard is the only case in which the head is animated separately while the body is the standard
 	case TALK_CONBARBASTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case LEFT:
 		case UP:
 			headLoopPat = PAT_TALKBARBA_LEFT;
 			bodyLoopPat = BPAT_STANDLEFT;
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 			break;
 
 		case DOWN:
 		case RIGHT:
 			headLoopPat = PAT_TALKBARBA_RIGHT;
 			bodyLoopPat = BPAT_STANDRIGHT;
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 			break;
 		}
 		break;
 
 	case TALK_SCHIFATO:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case LEFT:
 		case UP:
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 			headStartPat = PAT_SCHIFATOLEFT_START;
 			bodyStartPat = BPAT_STANDLEFT;
 			headLoopPat = PAT_SCHIFATOLEFT_LOOP;
@@ -997,7 +996,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case DOWN:
 		case RIGHT:
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 			headStartPat = PAT_SCHIFATORIGHT_START;
 			bodyStartPat = BPAT_STANDRIGHT;
 			headLoopPat = PAT_SCHIFATORIGHT_LOOP;
@@ -1006,10 +1005,10 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_NAAH:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case LEFT:
 		case UP:
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 			headStartPat = PAT_NAAHLEFT_START;
 			bodyStartPat = BPAT_STANDLEFT;
 			headLoopPat = PAT_NAAHLEFT_LOOP;
@@ -1017,7 +1016,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case DOWN:
 		case RIGHT:
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 			headStartPat = PAT_NAAHRIGHT_START;
 			bodyStartPat = BPAT_STANDRIGHT;
 			headLoopPat = PAT_NAAHRIGHT_LOOP;
@@ -1026,58 +1025,58 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_MACBETH1:
-		m_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.Set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH1;
 		break;
 	case TALK_MACBETH2:
-		m_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.Set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH2;
 		break;
 	case TALK_MACBETH3:
-		m_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.Set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH3;
 		break;
 	case TALK_MACBETH4:
-		m_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.Set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH4;
 		break;
 	case TALK_MACBETH5:
-		m_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.Set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH5;
 		break;
 	case TALK_MACBETH6:
-		m_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.Set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH6;
 		break;
 	case TALK_MACBETH7:
-		m_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.Set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH7;
 		break;
 	case TALK_MACBETH8:
-		m_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.Set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH8;
 		break;
 	case TALK_MACBETH9:
-		m_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.Set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH9;
 		break;
 
 	case TALK_SPAVENTATOSTATIC:
-		m_bCorpoDavanti = false;
-		switch (m_TalkDirection) {
+		_bCorpoDavanti = false;
+		switch (_TalkDirection) {
 		case DOWN:
 			bodyStartPat = BPAT_STANDDOWN;
 			bodyLoopPat = BPAT_STANDDOWN;
-			m_nBodyOffset.Set(4, 53);
+			_nBodyOffset.Set(4, 53);
 
 			headStartPat = PAT_SPAVENTODOWN_STAND;
 			headLoopPat = PAT_SPAVENTODOWN_LOOP;
@@ -1086,7 +1085,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case RIGHT:
 			bodyStartPat = BPAT_STANDRIGHT;
 			bodyLoopPat = BPAT_STANDRIGHT;
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 
 			headStartPat = PAT_SPAVENTORIGHT_STAND;
 			headLoopPat = PAT_SPAVENTORIGHT_LOOP;
@@ -1095,7 +1094,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case LEFT:
 			bodyStartPat = BPAT_STANDLEFT;
 			bodyLoopPat = BPAT_STANDLEFT;
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 
 			headStartPat = PAT_SPAVENTOLEFT_STAND;
 			headLoopPat = PAT_SPAVENTOLEFT_LOOP;
@@ -1110,7 +1109,7 @@ bool RMTony::StartTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 	return true;
 }
 
-void RMTony::StartTalk(CORO_PARAM, TALKTYPE nTalkType) {
+void RMTony::startTalk(CORO_PARAM, TALKTYPE nTalkType) {
 	CORO_BEGIN_CONTEXT;
 	int headStartPat, bodyStartPat;
 	int headLoopPat, bodyLoopPat;
@@ -1121,38 +1120,38 @@ void RMTony::StartTalk(CORO_PARAM, TALKTYPE nTalkType) {
 	_ctx->headStartPat = _ctx->bodyStartPat = 0;
 	_ctx->headLoopPat = _ctx->bodyLoopPat = 0;
 
-	if (!StartTalkCalculate(nTalkType, _ctx->headStartPat, _ctx->bodyStartPat,
+	if (!startTalkCalculate(nTalkType, _ctx->headStartPat, _ctx->bodyStartPat,
 	                        _ctx->headLoopPat, _ctx->bodyLoopPat))
 		return;
 
 	// Perform the set pattern
 	if (_ctx->headStartPat != 0 || _ctx->bodyStartPat != 0) {
 		mainFreeze();
-		SetPattern(_ctx->headStartPat);
-		m_body.SetPattern(_ctx->bodyStartPat);
+		setPattern(_ctx->headStartPat);
+		_body.setPattern(_ctx->bodyStartPat);
 		mainUnfreeze();
 
 		if (_ctx->bodyStartPat != 0)
-			CORO_INVOKE_0(m_body.WaitForEndPattern);
+			CORO_INVOKE_0(_body.waitForEndPattern);
 		if (_ctx->headStartPat != 0)
-			CORO_INVOKE_0(WaitForEndPattern);
+			CORO_INVOKE_0(waitForEndPattern);
 	}
 
 	mainFreeze();
-	SetPattern(_ctx->headLoopPat);
+	setPattern(_ctx->headLoopPat);
 	if (_ctx->bodyLoopPat)
-		m_body.SetPattern(_ctx->bodyLoopPat);
+		_body.setPattern(_ctx->bodyLoopPat);
 	mainUnfreeze();
 
 	CORO_END_CODE;
 }
 
 
-bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPat, int &finalPat, bool &bStatic) {
+bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPat, int &finalPat, bool &bStatic) {
 	bodyEndPat = 0;
 	headEndPat = 0;
 
-	switch (m_TalkDirection) {
+	switch (_TalkDirection) {
 	case UP:
 		finalPat = PAT_STANDUP;
 		headStandPat = PAT_TESTA_UP;
@@ -1174,23 +1173,23 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 	}
 
-	if (m_bPastorella) {
+	if (_bPastorella) {
 		mainFreeze();
-		SetPattern(finalPat);
+		setPattern(finalPat);
 		mainUnfreeze();
-		m_bIsTalking = false;
+		_bIsTalking = false;
 		return false;
 	}
 
 
 	bStatic = false;
-	switch (m_nTalkType) {
+	switch (_nTalkType) {
 	case TALK_NORMAL:
 		bodyEndPat = 0;
 		break;
 
 	case TALK_FIANCHI:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 			bodyEndPat = BPAT_FIANCHIUP_END;
 			break;
@@ -1215,16 +1214,16 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 
 	case TALK_RIDE:
 	case TALK_RIDE2:
-		if (m_TalkDirection == LEFT)
+		if (_TalkDirection == LEFT)
 			headEndPat = PAT_RIDELEFT_END;
-		else if (m_TalkDirection == RIGHT)
+		else if (_TalkDirection == RIGHT)
 			headEndPat = PAT_RIDERIGHT_END;
 
 		bodyEndPat = 0;
 		break;
 
 	case TALK_SCHIFATO:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
 			headEndPat = PAT_SCHIFATOLEFT_END;
@@ -1240,7 +1239,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_NAAH:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
 			headEndPat = PAT_NAAHLEFT_END;
@@ -1259,7 +1258,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_SPAVENTATO:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 			bodyEndPat = BPAT_SPAVENTOUP_END;
 			break;
@@ -1282,7 +1281,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_SPAVENTATO2:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 			bodyEndPat = 0;
 			break;
@@ -1305,7 +1304,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_CONCONIGLIO:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
@@ -1321,7 +1320,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_CONRICETTA:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
@@ -1337,7 +1336,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_CONCARTE:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
@@ -1353,7 +1352,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_CONPUPAZZO:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
@@ -1396,7 +1395,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_SPAVENTATOSTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case DOWN:
 			headStandPat = PAT_SPAVENTODOWN_STAND;
 			bodyEndPat = 0;
@@ -1425,7 +1424,7 @@ bool RMTony::EndTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 	return true;
 }
 
-void RMTony::EndTalk(CORO_PARAM) {
+void RMTony::endTalk(CORO_PARAM) {
 	CORO_BEGIN_CONTEXT;
 	int headStandPat, headEndPat;
 	int bodyEndPat, finalPat;
@@ -1441,93 +1440,93 @@ void RMTony::EndTalk(CORO_PARAM) {
 	_ctx->bodyEndPat = 0;
 	_ctx->headEndPat = 0;
 
-	if (!EndTalkCalculate(_ctx->headStandPat, _ctx->headEndPat, _ctx->bodyEndPat, _ctx->finalPat, _ctx->bStatic))
+	if (!endTalkCalculate(_ctx->headStandPat, _ctx->headEndPat, _ctx->bodyEndPat, _ctx->finalPat, _ctx->bStatic))
 		return;
 
 	// Handles the end of an animated and static, leaving everything unchanged
-	if (m_bIsStaticTalk) {
-		if (m_nTalkType == TALK_CONBARBASTATIC) {
+	if (_bIsStaticTalk) {
+		if (_nTalkType == TALK_CONBARBASTATIC) {
 			mainFreeze();
-			SetPattern(0);
-			if (m_TalkDirection == UP || m_TalkDirection == LEFT) {
-				m_body.SetPattern(BPAT_CONBARBALEFT_STATIC);
-				m_nBodyOffset.Set(-41, -14);
-			} else if (m_TalkDirection == DOWN || m_TalkDirection == RIGHT) {
-				m_body.SetPattern(BPAT_CONBARBARIGHT_STATIC);
-				m_nBodyOffset.Set(-26, -14);
+			setPattern(0);
+			if (_TalkDirection == UP || _TalkDirection == LEFT) {
+				_body.setPattern(BPAT_CONBARBALEFT_STATIC);
+				_nBodyOffset.Set(-41, -14);
+			} else if (_TalkDirection == DOWN || _TalkDirection == RIGHT) {
+				_body.setPattern(BPAT_CONBARBARIGHT_STATIC);
+				_nBodyOffset.Set(-26, -14);
 			}
 			mainUnfreeze();
 		} else {
 			mainFreeze();
-			SetPattern(_ctx->headStandPat);
+			setPattern(_ctx->headStandPat);
 			mainUnfreeze();
 
-			CORO_INVOKE_0(m_body.WaitForEndPattern);
+			CORO_INVOKE_0(_body.waitForEndPattern);
 		}
 
-		m_bIsTalking = false;
+		_bIsTalking = false;
 		return;
 	}
 
 	// Set the pattern
 	if (_ctx->headEndPat != 0 && _ctx->bodyEndPat != 0) {
 		mainFreeze();
-		SetPattern(_ctx->headEndPat);
+		setPattern(_ctx->headEndPat);
 		mainUnfreeze();
 
-		CORO_INVOKE_0(m_body.WaitForEndPattern);
+		CORO_INVOKE_0(_body.waitForEndPattern);
 
 		mainFreeze();
-		m_body.SetPattern(_ctx->bodyEndPat);
+		_body.setPattern(_ctx->bodyEndPat);
 		mainUnfreeze();
 
-		CORO_INVOKE_0(WaitForEndPattern);
-		CORO_INVOKE_0(m_body.WaitForEndPattern);
+		CORO_INVOKE_0(waitForEndPattern);
+		CORO_INVOKE_0(_body.waitForEndPattern);
 	} else if (_ctx->bodyEndPat != 0) {
 		mainFreeze();
-		SetPattern(_ctx->headStandPat);
+		setPattern(_ctx->headStandPat);
 		mainUnfreeze();
 
-		CORO_INVOKE_0(m_body.WaitForEndPattern);
+		CORO_INVOKE_0(_body.waitForEndPattern);
 
 		mainFreeze();
-		m_body.SetPattern(_ctx->bodyEndPat);
+		_body.setPattern(_ctx->bodyEndPat);
 		mainUnfreeze();
 
-		CORO_INVOKE_0(m_body.WaitForEndPattern);
+		CORO_INVOKE_0(_body.waitForEndPattern);
 	} else if (_ctx->headEndPat != 0) {
-		CORO_INVOKE_0(m_body.WaitForEndPattern);
+		CORO_INVOKE_0(_body.waitForEndPattern);
 
 		mainFreeze();
-		SetPattern(_ctx->headEndPat);
+		setPattern(_ctx->headEndPat);
 		mainUnfreeze();
 
-		CORO_INVOKE_0(WaitForEndPattern);
+		CORO_INVOKE_0(waitForEndPattern);
 	} else {
-		CORO_INVOKE_0(m_body.WaitForEndPattern);
+		CORO_INVOKE_0(_body.waitForEndPattern);
 	}
 
 	if (_ctx->finalPat != 0) {
 		mainFreeze();
-		m_body.SetPattern(0);
-		SetPattern(_ctx->finalPat);
+		_body.setPattern(0);
+		setPattern(_ctx->finalPat);
 		mainUnfreeze();
 	}
 
-	m_bIsTalking = false;
+	_bIsTalking = false;
 
 	CORO_END_CODE;
 }
 
-void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat,
+void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat,
                                   int &bodyStartPat, int &bodyLoopPat) {
-	int nPat = GetCurPattern();
+	int nPat = getCurPattern();
 
 	headLoopPat = -1;
 
 	switch (nPat) {
 	case PAT_STANDDOWN:
-		m_TalkDirection = DOWN;
+		_TalkDirection = DOWN;
 		headPat = PAT_TESTA_RIGHT;
 		break;
 
@@ -1536,7 +1535,7 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 	case PAT_TAKELEFT_DOWN2:
 	case PAT_SIRIALZALEFT:
 	case PAT_STANDLEFT:
-		m_TalkDirection = LEFT;
+		_TalkDirection = LEFT;
 		headPat = PAT_TESTA_LEFT;
 		break;
 
@@ -1545,7 +1544,7 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 	case PAT_TAKERIGHT_DOWN2:
 	case PAT_SIRIALZARIGHT:
 	case PAT_STANDRIGHT:
-		m_TalkDirection = RIGHT;
+		_TalkDirection = RIGHT;
 		headPat = PAT_TESTA_RIGHT;
 		break;
 
@@ -1553,26 +1552,26 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 	case PAT_TAKEUP_MID2:
 	case PAT_TAKEUP_DOWN2:
 	case PAT_STANDUP:
-		m_TalkDirection = UP;
+		_TalkDirection = UP;
 		headPat = PAT_TESTA_LEFT;
 		break;
 	}
 
-	m_bCorpoDavanti = true;
+	_bCorpoDavanti = true;
 
 	switch (nTalk) {
 	case TALK_CONCONIGLIOSTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-			m_nBodyOffset.Set(-21, -5);
+			_nBodyOffset.Set(-21, -5);
 			bodyStartPat = BPAT_CONCONIGLIOLEFT_START;
 			bodyLoopPat = BPAT_CONCONIGLIOLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			m_nBodyOffset.Set(-4, -5);
+			_nBodyOffset.Set(-4, -5);
 			bodyStartPat = BPAT_CONCONIGLIORIGHT_START;
 			bodyLoopPat = BPAT_CONCONIGLIORIGHT_LOOP;
 			break;
@@ -1580,17 +1579,17 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		break;
 
 	case TALK_CONCARTESTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-			m_nBodyOffset.Set(-34, -2);
+			_nBodyOffset.Set(-34, -2);
 			bodyStartPat = BPAT_CONCARTELEFT_START;
 			bodyLoopPat = BPAT_CONCARTELEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			m_nBodyOffset.Set(-4, -2);
+			_nBodyOffset.Set(-4, -2);
 			bodyStartPat = BPAT_CONCARTERIGHT_START;
 			bodyLoopPat = BPAT_CONCARTERIGHT_LOOP;
 			break;
@@ -1598,17 +1597,17 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		break;
 
 	case TALK_CONRICETTASTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-			m_nBodyOffset.Set(-61, -7);
+			_nBodyOffset.Set(-61, -7);
 			bodyStartPat = BPAT_CONRICETTALEFT_START;
 			bodyLoopPat = BPAT_CONRICETTALEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			m_nBodyOffset.Set(-5, -7);
+			_nBodyOffset.Set(-5, -7);
 			bodyStartPat = BPAT_CONRICETTARIGHT_START;
 			bodyLoopPat = BPAT_CONRICETTARIGHT_LOOP;
 			break;
@@ -1616,17 +1615,17 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		break;
 
 	case TALK_CONPUPAZZOSTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-			m_nBodyOffset.Set(-35, 2);
+			_nBodyOffset.Set(-35, 2);
 			bodyStartPat = BPAT_CONPUPAZZOLEFT_START;
 			bodyLoopPat = BPAT_CONPUPAZZOLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			m_nBodyOffset.Set(-14, 2);
+			_nBodyOffset.Set(-14, 2);
 			bodyStartPat = BPAT_CONPUPAZZORIGHT_START;
 			bodyLoopPat = BPAT_CONPUPAZZORIGHT_LOOP;
 			break;
@@ -1634,17 +1633,17 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		break;
 
 	case TALK_CONTACCUINOSTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-			m_nBodyOffset.Set(-16, -9);
+			_nBodyOffset.Set(-16, -9);
 			bodyStartPat = BPAT_CONTACCUINOLEFT_START;
 			bodyLoopPat = BPAT_CONTACCUINOLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			m_nBodyOffset.Set(-6, -9);
+			_nBodyOffset.Set(-6, -9);
 			bodyStartPat = BPAT_CONTACCUINORIGHT_START;
 			bodyLoopPat = BPAT_CONTACCUINORIGHT_LOOP;
 			break;
@@ -1652,17 +1651,17 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		break;
 
 	case TALK_CONMEGAFONOSTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-			m_nBodyOffset.Set(-41, -8);
+			_nBodyOffset.Set(-41, -8);
 			bodyStartPat = BPAT_CONMEGAFONOLEFT_START;
 			bodyLoopPat = BPAT_CONMEGAFONOLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			m_nBodyOffset.Set(-14, -8);
+			_nBodyOffset.Set(-14, -8);
 			bodyStartPat = BPAT_CONMEGAFONORIGHT_START;
 			bodyLoopPat = BPAT_CONMEGAFONORIGHT_LOOP;
 			break;
@@ -1670,10 +1669,10 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		break;
 
 	case TALK_CONBARBASTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-			m_nBodyOffset.Set(-41, -14);
+			_nBodyOffset.Set(-41, -14);
 			bodyStartPat = BPAT_CONBARBALEFT_START;
 			bodyLoopPat = BPAT_STANDLEFT;
 			headLoopPat = PAT_TALKBARBA_LEFT;
@@ -1682,7 +1681,7 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 
 		case DOWN:
 		case RIGHT:
-			m_nBodyOffset.Set(-26, -14);
+			_nBodyOffset.Set(-26, -14);
 			bodyStartPat = BPAT_CONBARBARIGHT_START;
 			bodyLoopPat = BPAT_STANDRIGHT;
 			headLoopPat = PAT_TALKBARBA_RIGHT;
@@ -1692,13 +1691,13 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		break;
 
 	case TALK_SPAVENTATOSTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case DOWN:
 			headPat = PAT_SPAVENTODOWN_START;
 			bodyLoopPat = BPAT_STANDDOWN;
 			bodyStartPat = BPAT_STANDDOWN;
 			headLoopPat = PAT_SPAVENTODOWN_STAND;
-			m_nBodyOffset.Set(4, 53);
+			_nBodyOffset.Set(4, 53);
 			break;
 
 		case LEFT:
@@ -1706,7 +1705,7 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 			bodyLoopPat = BPAT_STANDLEFT;
 			bodyStartPat = BPAT_STANDLEFT;
 			headLoopPat = PAT_SPAVENTOLEFT_STAND;
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 			break;
 
 		case RIGHT:
@@ -1714,7 +1713,7 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 			bodyLoopPat = BPAT_STANDRIGHT;
 			bodyStartPat = BPAT_STANDRIGHT;
 			headLoopPat = PAT_SPAVENTORIGHT_STAND;
-			m_nBodyOffset.Set(6, 56);
+			_nBodyOffset.Set(6, 56);
 			break;
 
 		default:
@@ -1726,7 +1725,7 @@ void RMTony::StartStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 	}
 }
 
-void RMTony::StartStatic(CORO_PARAM, TALKTYPE nTalk) {
+void RMTony::startStatic(CORO_PARAM, TALKTYPE nTalk) {
 	CORO_BEGIN_CONTEXT;
 	int headPat, headLoopPat;
 	int bodyStartPat, bodyLoopPat;
@@ -1738,28 +1737,28 @@ void RMTony::StartStatic(CORO_PARAM, TALKTYPE nTalk) {
 	_ctx->bodyStartPat = _ctx->bodyLoopPat = 0;
 
 	// e vai con i pattern
-	m_bIsStaticTalk = true;
+	_bIsStaticTalk = true;
 
 	mainFreeze();
-	SetPattern(_ctx->headPat);
-	m_body.SetPattern(_ctx->bodyStartPat);
+	setPattern(_ctx->headPat);
+	_body.setPattern(_ctx->bodyStartPat);
 	mainUnfreeze();
 
-	CORO_INVOKE_0(m_body.WaitForEndPattern);
-	CORO_INVOKE_0(WaitForEndPattern);
+	CORO_INVOKE_0(_body.waitForEndPattern);
+	CORO_INVOKE_0(waitForEndPattern);
 
 	mainFreeze();
 	if (_ctx->headLoopPat != -1)
-		SetPattern(_ctx->headLoopPat);
-	m_body.SetPattern(_ctx->bodyLoopPat);
+		setPattern(_ctx->headLoopPat);
+	_body.setPattern(_ctx->bodyLoopPat);
 	mainUnfreeze();
 
 	CORO_END_CODE;
 }
 
 
-void RMTony::EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat, int &headEndPat) {
-	switch (m_TalkDirection) {
+void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat, int &headEndPat) {
+	switch (_TalkDirection) {
 	case UP:
 	case LEFT:
 		finalPat = PAT_STANDLEFT;
@@ -1773,7 +1772,7 @@ void RMTony::EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 
 	switch (nTalk) {
 	case TALK_CONPUPAZZOSTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
 			bodyEndPat = BPAT_CONPUPAZZOLEFT_END;
@@ -1787,7 +1786,7 @@ void RMTony::EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		break;
 
 	case TALK_CONRICETTASTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
 			bodyEndPat = BPAT_CONRICETTALEFT_END;
@@ -1801,7 +1800,7 @@ void RMTony::EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		break;
 
 	case TALK_CONCONIGLIOSTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
 			bodyEndPat = BPAT_CONCONIGLIOLEFT_END;
@@ -1815,7 +1814,7 @@ void RMTony::EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		break;
 
 	case TALK_CONCARTESTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
 			bodyEndPat = BPAT_CONCARTELEFT_END;
@@ -1829,7 +1828,7 @@ void RMTony::EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		break;
 
 	case TALK_CONTACCUINOSTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
 			bodyEndPat = BPAT_CONTACCUINOLEFT_END;
@@ -1843,7 +1842,7 @@ void RMTony::EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		break;
 
 	case TALK_CONMEGAFONOSTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
 			bodyEndPat = BPAT_CONMEGAFONOLEFT_END;
@@ -1857,7 +1856,7 @@ void RMTony::EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		break;
 
 	case TALK_CONBARBASTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
 			bodyEndPat = BPAT_CONBARBALEFT_END;
@@ -1871,7 +1870,7 @@ void RMTony::EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		break;
 
 	case TALK_SPAVENTATOSTATIC:
-		switch (m_TalkDirection) {
+		switch (_TalkDirection) {
 		case LEFT:
 			headEndPat = PAT_SPAVENTOLEFT_END;
 			break;
@@ -1894,7 +1893,7 @@ void RMTony::EndStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 	}
 }
 
-void RMTony::EndStatic(CORO_PARAM, TALKTYPE nTalk) {
+void RMTony::endStatic(CORO_PARAM, TALKTYPE nTalk) {
 	CORO_BEGIN_CONTEXT;
 	int bodyEndPat;
 	int finalPat;
@@ -1907,29 +1906,29 @@ void RMTony::EndStatic(CORO_PARAM, TALKTYPE nTalk) {
 	_ctx->finalPat = 0;
 	_ctx->headEndPat = 0;
 
-	EndStaticCalculate(nTalk, _ctx->bodyEndPat, _ctx->finalPat, _ctx->headEndPat);
+	endStaticCalculate(nTalk, _ctx->bodyEndPat, _ctx->finalPat, _ctx->headEndPat);
 
 	if (_ctx->headEndPat != 0) {
 		mainFreeze();
-		SetPattern(_ctx->headEndPat);
+		setPattern(_ctx->headEndPat);
 		mainUnfreeze();
 
-		CORO_INVOKE_0(WaitForEndPattern);
+		CORO_INVOKE_0(waitForEndPattern);
 	} else {
 		// Play please
 		mainFreeze();
-		m_body.SetPattern(_ctx->bodyEndPat);
+		_body.setPattern(_ctx->bodyEndPat);
 		mainUnfreeze();
 
-		CORO_INVOKE_0(m_body.WaitForEndPattern);
+		CORO_INVOKE_0(_body.waitForEndPattern);
 	}
 
 	mainFreeze();
-	SetPattern(_ctx->finalPat);
-	m_body.SetPattern(0);
+	setPattern(_ctx->finalPat);
+	_body.setPattern(0);
 	mainUnfreeze();
 
-	m_bIsStaticTalk = false;
+	_bIsStaticTalk = false;
 
 	CORO_END_CODE;
 }
-- 
cgit v1.2.3


From f12ab3e521b01ed2b40e7d517753dd14bc6e6f0f Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Thu, 7 Jun 2012 08:42:35 +0200
Subject: TONY: Rename variables and functions in utils.h

---
 engines/tony/tonychar.cpp | 174 +++++++++++++++++++++++-----------------------
 1 file changed, 87 insertions(+), 87 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index dc771b08aa..fb53d68615 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -105,18 +105,18 @@ void RMTony::init(void) {
 	_bIsStaticTalk = false;
 
 	// Opens the buffer
-	ds.OpenBuffer(tony);
+	ds.openBuffer(tony);
 
 	// Reads his details from the stream
 	readFromStream(ds, true);
 
 	// Closes the buffer
-	ds.Close();
+	ds.close();
 
 	// Reads Tony's body
-	ds.OpenBuffer(body);
+	ds.openBuffer(body);
 	_body.readFromStream(ds, true);
-	ds.Close();
+	ds.close();
 	_body.setPattern(0);
 
 	_nTimeLastStep = _vm->getTime();
@@ -180,28 +180,28 @@ void RMTony::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 	// Call the Draw() of the parent class if Tony is visible
 	if (_bShow && bDrawNow) {
 		if (_bCorpoDavanti) {
-			prim->Dst().SetEmpty();
-			prim->Dst().Offset(-44, -134);
+			prim->Dst().setEmpty();
+			prim->Dst().offset(-44, -134);
 			if (_bPastorella)
-				prim->Dst().Offset(1, 4);
+				prim->Dst().offset(1, 4);
 			CORO_INVOKE_2(RMCharacter::draw, bigBuf, prim);
 		}
 
 		if (_bIsTalking || _bIsStaticTalk) {
 			// Offest direction from scrolling
-			prim->Dst().SetEmpty();
-			prim->Dst().Offset(-_curScroll);
-			prim->Dst().Offset(_pos);
-			prim->Dst().Offset(-44, -134);
+			prim->Dst().setEmpty();
+			prim->Dst().offset(-_curScroll);
+			prim->Dst().offset(_pos);
+			prim->Dst().offset(-44, -134);
 			prim->Dst() += _nBodyOffset;
 			CORO_INVOKE_2(_body.draw, bigBuf, prim);
 		}
 
 		if (!_bCorpoDavanti) {
-			prim->Dst().SetEmpty();
-			prim->Dst().Offset(-44, -134);
+			prim->Dst().setEmpty();
+			prim->Dst().offset(-44, -134);
 			if (_bPastorella)
-				prim->Dst().Offset(0, 3);
+				prim->Dst().offset(0, 3);
 			CORO_INVOKE_2(RMCharacter::draw, bigBuf, prim);
 		}
 	}
@@ -630,25 +630,25 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case DOWN:
 			headLoopPat = PAT_TALK_DOWN;
 			bodyLoopPat = BPAT_STANDDOWN;
-			_nBodyOffset.Set(4, 53);
+			_nBodyOffset.set(4, 53);
 			break;
 
 		case LEFT:
 			headLoopPat = PAT_TALK_LEFT;
 			bodyLoopPat = BPAT_STANDLEFT;
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 			break;
 
 		case RIGHT:
 			headLoopPat = PAT_TALK_RIGHT;
 			bodyLoopPat = BPAT_STANDRIGHT;
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 			break;
 
 		case UP:
 			headLoopPat = PAT_TALK_UP;
 			bodyLoopPat = BPAT_STANDUP;
-			_nBodyOffset.Set(6, 53);
+			_nBodyOffset.set(6, 53);
 			break;
 		}
 		break;
@@ -657,7 +657,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		_bCorpoDavanti = false;
 		switch (_TalkDirection) {
 		case UP:
-			_nBodyOffset.Set(2, 42);
+			_nBodyOffset.set(2, 42);
 			headStartPat = PAT_TESTA_UP;
 			bodyStartPat = BPAT_FIANCHIUP_START;
 			headLoopPat = PAT_TALK_UP;
@@ -665,7 +665,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 
 		case DOWN:
-			_nBodyOffset.Set(2, 48);
+			_nBodyOffset.set(2, 48);
 			headStartPat = PAT_TESTA_DOWN;
 			bodyStartPat = BPAT_FIANCHIDOWN_START;
 			headLoopPat = PAT_TALK_DOWN;
@@ -673,7 +673,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 
 		case LEFT:
-			_nBodyOffset.Set(-3, 53);
+			_nBodyOffset.set(-3, 53);
 			headStartPat = PAT_TESTA_LEFT;
 			bodyStartPat = BPAT_FIANCHILEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
@@ -681,7 +681,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 
 		case RIGHT:
-			_nBodyOffset.Set(2, 53);
+			_nBodyOffset.set(2, 53);
 			headStartPat = PAT_TESTA_RIGHT;
 			bodyStartPat = BPAT_FIANCHIRIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
@@ -692,7 +692,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 
 	case TALK_CANTA:
-		_nBodyOffset.Set(-10, 25);
+		_nBodyOffset.set(-10, 25);
 		headStartPat = PAT_TESTA_LEFT;
 		bodyStartPat = BPAT_CANTALEFT_START;
 		headLoopPat = PAT_TALK_LEFT;
@@ -705,7 +705,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case UP:
 		case DOWN:
 		case LEFT:
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 			headStartPat = PAT_RIDELEFT_START;
 			bodyStartPat = BPAT_STANDLEFT;
 			headLoopPat = PAT_RIDELEFT_LOOP;
@@ -713,7 +713,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 
 		case RIGHT:
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 			headStartPat = PAT_RIDERIGHT_START;
 			bodyStartPat = BPAT_STANDRIGHT;
 			headLoopPat = PAT_RIDERIGHT_LOOP;
@@ -728,14 +728,14 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case UP:
 		case DOWN:
 		case LEFT:
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 			headStartPat = PAT_RIDELEFT_START;
 			bodyStartPat = BPAT_STANDLEFT;
 			headLoopPat = PAT_RIDELEFT_LOOP;
 			break;
 
 		case RIGHT:
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 			headStartPat = PAT_RIDERIGHT_START;
 			bodyStartPat = BPAT_STANDRIGHT;
 			headLoopPat = PAT_RIDERIGHT_LOOP;
@@ -750,13 +750,13 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case UP:
 		case DOWN:
 		case LEFT:
-			_nBodyOffset.Set(-4, 40);
+			_nBodyOffset.set(-4, 40);
 			headLoopPat = PAT_TALK_LEFT;
 			bodyLoopPat = BPAT_SIINDICALEFT;
 			break;
 
 		case RIGHT:
-			_nBodyOffset.Set(5, 40);
+			_nBodyOffset.set(5, 40);
 			headLoopPat = PAT_TALK_RIGHT;
 			bodyLoopPat = BPAT_SIINDICARIGHT;
 			break;
@@ -766,7 +766,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 	case TALK_SPAVENTATO:
 		switch (_TalkDirection) {
 		case UP:
-			_nBodyOffset.Set(-4, -11);
+			_nBodyOffset.set(-4, -11);
 			headStartPat = PAT_TESTA_UP;
 			bodyStartPat = BPAT_SPAVENTOUP_START;
 			headLoopPat = PAT_TALK_UP;
@@ -774,7 +774,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 
 		case DOWN:
-			_nBodyOffset.Set(-5, 45);
+			_nBodyOffset.set(-5, 45);
 			headStartPat = PAT_SPAVENTODOWN_START;
 			bodyStartPat = BPAT_SPAVENTODOWN_START;
 			headLoopPat = PAT_SPAVENTODOWN_LOOP;
@@ -782,7 +782,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 
 		case RIGHT:
-			_nBodyOffset.Set(-4, 41);
+			_nBodyOffset.set(-4, 41);
 			headStartPat = PAT_SPAVENTORIGHT_START;
 			bodyStartPat = BPAT_SPAVENTORIGHT_START;
 			headLoopPat = PAT_SPAVENTORIGHT_LOOP;
@@ -790,7 +790,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			break;
 
 		case LEFT:
-			_nBodyOffset.Set(-10, 41);
+			_nBodyOffset.set(-10, 41);
 			headStartPat = PAT_SPAVENTOLEFT_START;
 			bodyStartPat = BPAT_SPAVENTOLEFT_START;
 			headLoopPat = PAT_SPAVENTOLEFT_LOOP;
@@ -805,7 +805,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case UP:
 			bodyStartPat = BPAT_STANDUP;
 			bodyLoopPat = BPAT_STANDUP;
-			_nBodyOffset.Set(6, 53);
+			_nBodyOffset.set(6, 53);
 
 			headStartPat = PAT_TESTA_UP;
 			headLoopPat = PAT_TALK_UP;
@@ -814,7 +814,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case DOWN:
 			bodyStartPat = BPAT_STANDDOWN;
 			bodyLoopPat = BPAT_STANDDOWN;
-			_nBodyOffset.Set(4, 53);
+			_nBodyOffset.set(4, 53);
 
 			headStartPat = PAT_SPAVENTODOWN_START;
 			headLoopPat = PAT_SPAVENTODOWN_LOOP;
@@ -823,7 +823,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case RIGHT:
 			bodyStartPat = BPAT_STANDRIGHT;
 			bodyLoopPat = BPAT_STANDRIGHT;
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 
 			headStartPat = PAT_SPAVENTORIGHT_START;
 			headLoopPat = PAT_SPAVENTORIGHT_LOOP;
@@ -832,7 +832,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case LEFT:
 			bodyStartPat = BPAT_STANDLEFT;
 			bodyLoopPat = BPAT_STANDLEFT;
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 
 			headStartPat = PAT_SPAVENTOLEFT_START;
 			headLoopPat = PAT_SPAVENTOLEFT_LOOP;
@@ -841,27 +841,27 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_CONBICCHIERE:
-		_nBodyOffset.Set(4, 53);
+		_nBodyOffset.set(4, 53);
 		headLoopPat = PAT_TALK_DOWN;
 		bodyLoopPat = BPAT_BICCHIERE;
 		break;
 	case TALK_CONVERME:
-		_nBodyOffset.Set(9, 56);
+		_nBodyOffset.set(9, 56);
 		headLoopPat = PAT_TALK_RIGHT;
 		bodyLoopPat = BPAT_VERME;
 		break;
 	case TALK_CONMARTELLO:
-		_nBodyOffset.Set(6, 56);
+		_nBodyOffset.set(6, 56);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MARTELLO;
 		break;
 	case TALK_CONCORDA:
-		_nBodyOffset.Set(-3, 38);
+		_nBodyOffset.set(-3, 38);
 		headLoopPat = PAT_TALK_RIGHT;
 		bodyLoopPat = BPAT_CORDA;
 		break;
 	case TALK_CONSEGRETARIA:
-		_nBodyOffset.Set(-17, 12);
+		_nBodyOffset.set(-17, 12);
 		headLoopPat = PAT_TALK_RIGHT;
 		bodyLoopPat = BPAT_CONSEGRETARIA;
 		break;
@@ -870,7 +870,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		switch (_TalkDirection) {
 		case LEFT:
 		case UP:
-			_nBodyOffset.Set(-21, -5);
+			_nBodyOffset.set(-21, -5);
 			bodyStartPat = BPAT_CONCONIGLIOLEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
 			bodyLoopPat = BPAT_CONCONIGLIOLEFT_LOOP;
@@ -878,7 +878,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case DOWN:
 		case RIGHT:
-			_nBodyOffset.Set(-4, -5);
+			_nBodyOffset.set(-4, -5);
 			bodyStartPat = BPAT_CONCONIGLIORIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
 			bodyLoopPat = BPAT_CONCONIGLIORIGHT_LOOP;
@@ -890,7 +890,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		switch (_TalkDirection) {
 		case LEFT:
 		case UP:
-			_nBodyOffset.Set(-61, -7);
+			_nBodyOffset.set(-61, -7);
 			bodyStartPat = BPAT_CONRICETTALEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
 			bodyLoopPat = BPAT_CONRICETTALEFT_LOOP;
@@ -898,7 +898,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case DOWN:
 		case RIGHT:
-			_nBodyOffset.Set(-5, -7);
+			_nBodyOffset.set(-5, -7);
 			bodyStartPat = BPAT_CONRICETTARIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
 			bodyLoopPat = BPAT_CONRICETTARIGHT_LOOP;
@@ -910,7 +910,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		switch (_TalkDirection) {
 		case LEFT:
 		case UP:
-			_nBodyOffset.Set(-34, -2);
+			_nBodyOffset.set(-34, -2);
 			bodyStartPat = BPAT_CONCARTELEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
 			bodyLoopPat = BPAT_CONCARTELEFT_LOOP;
@@ -918,7 +918,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case DOWN:
 		case RIGHT:
-			_nBodyOffset.Set(-4, -2);
+			_nBodyOffset.set(-4, -2);
 			bodyStartPat = BPAT_CONCARTERIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
 			bodyLoopPat = BPAT_CONCARTERIGHT_LOOP;
@@ -930,7 +930,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		switch (_TalkDirection) {
 		case LEFT:
 		case UP:
-			_nBodyOffset.Set(-35, 2);
+			_nBodyOffset.set(-35, 2);
 			bodyStartPat = BPAT_CONPUPAZZOLEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
 			bodyLoopPat = BPAT_CONPUPAZZOLEFT_LOOP;
@@ -938,7 +938,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case DOWN:
 		case RIGHT:
-			_nBodyOffset.Set(-14, 2);
+			_nBodyOffset.set(-14, 2);
 			bodyStartPat = BPAT_CONPUPAZZORIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
 			bodyLoopPat = BPAT_CONPUPAZZORIGHT_LOOP;
@@ -972,14 +972,14 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case UP:
 			headLoopPat = PAT_TALKBARBA_LEFT;
 			bodyLoopPat = BPAT_STANDLEFT;
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 			break;
 
 		case DOWN:
 		case RIGHT:
 			headLoopPat = PAT_TALKBARBA_RIGHT;
 			bodyLoopPat = BPAT_STANDRIGHT;
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 			break;
 		}
 		break;
@@ -988,7 +988,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		switch (_TalkDirection) {
 		case LEFT:
 		case UP:
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 			headStartPat = PAT_SCHIFATOLEFT_START;
 			bodyStartPat = BPAT_STANDLEFT;
 			headLoopPat = PAT_SCHIFATOLEFT_LOOP;
@@ -996,7 +996,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case DOWN:
 		case RIGHT:
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 			headStartPat = PAT_SCHIFATORIGHT_START;
 			bodyStartPat = BPAT_STANDRIGHT;
 			headLoopPat = PAT_SCHIFATORIGHT_LOOP;
@@ -1008,7 +1008,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		switch (_TalkDirection) {
 		case LEFT:
 		case UP:
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 			headStartPat = PAT_NAAHLEFT_START;
 			bodyStartPat = BPAT_STANDLEFT;
 			headLoopPat = PAT_NAAHLEFT_LOOP;
@@ -1016,7 +1016,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case DOWN:
 		case RIGHT:
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 			headStartPat = PAT_NAAHRIGHT_START;
 			bodyStartPat = BPAT_STANDRIGHT;
 			headLoopPat = PAT_NAAHRIGHT_LOOP;
@@ -1025,47 +1025,47 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_MACBETH1:
-		_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH1;
 		break;
 	case TALK_MACBETH2:
-		_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH2;
 		break;
 	case TALK_MACBETH3:
-		_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH3;
 		break;
 	case TALK_MACBETH4:
-		_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH4;
 		break;
 	case TALK_MACBETH5:
-		_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH5;
 		break;
 	case TALK_MACBETH6:
-		_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH6;
 		break;
 	case TALK_MACBETH7:
-		_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH7;
 		break;
 	case TALK_MACBETH8:
-		_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH8;
 		break;
 	case TALK_MACBETH9:
-		_nBodyOffset.Set(-33, -1);
+		_nBodyOffset.set(-33, -1);
 		headLoopPat = PAT_TALK_LEFT;
 		bodyLoopPat = BPAT_MACBETH9;
 		break;
@@ -1076,7 +1076,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case DOWN:
 			bodyStartPat = BPAT_STANDDOWN;
 			bodyLoopPat = BPAT_STANDDOWN;
-			_nBodyOffset.Set(4, 53);
+			_nBodyOffset.set(4, 53);
 
 			headStartPat = PAT_SPAVENTODOWN_STAND;
 			headLoopPat = PAT_SPAVENTODOWN_LOOP;
@@ -1085,7 +1085,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case RIGHT:
 			bodyStartPat = BPAT_STANDRIGHT;
 			bodyLoopPat = BPAT_STANDRIGHT;
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 
 			headStartPat = PAT_SPAVENTORIGHT_STAND;
 			headLoopPat = PAT_SPAVENTORIGHT_LOOP;
@@ -1094,7 +1094,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case LEFT:
 			bodyStartPat = BPAT_STANDLEFT;
 			bodyLoopPat = BPAT_STANDLEFT;
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 
 			headStartPat = PAT_SPAVENTOLEFT_STAND;
 			headLoopPat = PAT_SPAVENTOLEFT_LOOP;
@@ -1450,10 +1450,10 @@ void RMTony::endTalk(CORO_PARAM) {
 			setPattern(0);
 			if (_TalkDirection == UP || _TalkDirection == LEFT) {
 				_body.setPattern(BPAT_CONBARBALEFT_STATIC);
-				_nBodyOffset.Set(-41, -14);
+				_nBodyOffset.set(-41, -14);
 			} else if (_TalkDirection == DOWN || _TalkDirection == RIGHT) {
 				_body.setPattern(BPAT_CONBARBARIGHT_STATIC);
-				_nBodyOffset.Set(-26, -14);
+				_nBodyOffset.set(-26, -14);
 			}
 			mainUnfreeze();
 		} else {
@@ -1564,14 +1564,14 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-			_nBodyOffset.Set(-21, -5);
+			_nBodyOffset.set(-21, -5);
 			bodyStartPat = BPAT_CONCONIGLIOLEFT_START;
 			bodyLoopPat = BPAT_CONCONIGLIOLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			_nBodyOffset.Set(-4, -5);
+			_nBodyOffset.set(-4, -5);
 			bodyStartPat = BPAT_CONCONIGLIORIGHT_START;
 			bodyLoopPat = BPAT_CONCONIGLIORIGHT_LOOP;
 			break;
@@ -1582,14 +1582,14 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-			_nBodyOffset.Set(-34, -2);
+			_nBodyOffset.set(-34, -2);
 			bodyStartPat = BPAT_CONCARTELEFT_START;
 			bodyLoopPat = BPAT_CONCARTELEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			_nBodyOffset.Set(-4, -2);
+			_nBodyOffset.set(-4, -2);
 			bodyStartPat = BPAT_CONCARTERIGHT_START;
 			bodyLoopPat = BPAT_CONCARTERIGHT_LOOP;
 			break;
@@ -1600,14 +1600,14 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-			_nBodyOffset.Set(-61, -7);
+			_nBodyOffset.set(-61, -7);
 			bodyStartPat = BPAT_CONRICETTALEFT_START;
 			bodyLoopPat = BPAT_CONRICETTALEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			_nBodyOffset.Set(-5, -7);
+			_nBodyOffset.set(-5, -7);
 			bodyStartPat = BPAT_CONRICETTARIGHT_START;
 			bodyLoopPat = BPAT_CONRICETTARIGHT_LOOP;
 			break;
@@ -1618,14 +1618,14 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-			_nBodyOffset.Set(-35, 2);
+			_nBodyOffset.set(-35, 2);
 			bodyStartPat = BPAT_CONPUPAZZOLEFT_START;
 			bodyLoopPat = BPAT_CONPUPAZZOLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			_nBodyOffset.Set(-14, 2);
+			_nBodyOffset.set(-14, 2);
 			bodyStartPat = BPAT_CONPUPAZZORIGHT_START;
 			bodyLoopPat = BPAT_CONPUPAZZORIGHT_LOOP;
 			break;
@@ -1636,14 +1636,14 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-			_nBodyOffset.Set(-16, -9);
+			_nBodyOffset.set(-16, -9);
 			bodyStartPat = BPAT_CONTACCUINOLEFT_START;
 			bodyLoopPat = BPAT_CONTACCUINOLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			_nBodyOffset.Set(-6, -9);
+			_nBodyOffset.set(-6, -9);
 			bodyStartPat = BPAT_CONTACCUINORIGHT_START;
 			bodyLoopPat = BPAT_CONTACCUINORIGHT_LOOP;
 			break;
@@ -1654,14 +1654,14 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-			_nBodyOffset.Set(-41, -8);
+			_nBodyOffset.set(-41, -8);
 			bodyStartPat = BPAT_CONMEGAFONOLEFT_START;
 			bodyLoopPat = BPAT_CONMEGAFONOLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			_nBodyOffset.Set(-14, -8);
+			_nBodyOffset.set(-14, -8);
 			bodyStartPat = BPAT_CONMEGAFONORIGHT_START;
 			bodyLoopPat = BPAT_CONMEGAFONORIGHT_LOOP;
 			break;
@@ -1672,7 +1672,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-			_nBodyOffset.Set(-41, -14);
+			_nBodyOffset.set(-41, -14);
 			bodyStartPat = BPAT_CONBARBALEFT_START;
 			bodyLoopPat = BPAT_STANDLEFT;
 			headLoopPat = PAT_TALKBARBA_LEFT;
@@ -1681,7 +1681,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 
 		case DOWN:
 		case RIGHT:
-			_nBodyOffset.Set(-26, -14);
+			_nBodyOffset.set(-26, -14);
 			bodyStartPat = BPAT_CONBARBARIGHT_START;
 			bodyLoopPat = BPAT_STANDRIGHT;
 			headLoopPat = PAT_TALKBARBA_RIGHT;
@@ -1697,7 +1697,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 			bodyLoopPat = BPAT_STANDDOWN;
 			bodyStartPat = BPAT_STANDDOWN;
 			headLoopPat = PAT_SPAVENTODOWN_STAND;
-			_nBodyOffset.Set(4, 53);
+			_nBodyOffset.set(4, 53);
 			break;
 
 		case LEFT:
@@ -1705,7 +1705,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 			bodyLoopPat = BPAT_STANDLEFT;
 			bodyStartPat = BPAT_STANDLEFT;
 			headLoopPat = PAT_SPAVENTOLEFT_STAND;
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 			break;
 
 		case RIGHT:
@@ -1713,7 +1713,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 			bodyLoopPat = BPAT_STANDRIGHT;
 			bodyStartPat = BPAT_STANDRIGHT;
 			headLoopPat = PAT_SPAVENTORIGHT_STAND;
-			_nBodyOffset.Set(6, 56);
+			_nBodyOffset.set(6, 56);
 			break;
 
 		default:
-- 
cgit v1.2.3


From cd15e483ed64274049142a2e6838962d794c3ff5 Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Thu, 7 Jun 2012 21:14:59 +0200
Subject: TONY: Some more renaming

---
 engines/tony/tonychar.cpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index fb53d68615..9f34276c41 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -180,28 +180,28 @@ void RMTony::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 	// Call the Draw() of the parent class if Tony is visible
 	if (_bShow && bDrawNow) {
 		if (_bCorpoDavanti) {
-			prim->Dst().setEmpty();
-			prim->Dst().offset(-44, -134);
+			prim->getDst().setEmpty();
+			prim->getDst().offset(-44, -134);
 			if (_bPastorella)
-				prim->Dst().offset(1, 4);
+				prim->getDst().offset(1, 4);
 			CORO_INVOKE_2(RMCharacter::draw, bigBuf, prim);
 		}
 
 		if (_bIsTalking || _bIsStaticTalk) {
 			// Offest direction from scrolling
-			prim->Dst().setEmpty();
-			prim->Dst().offset(-_curScroll);
-			prim->Dst().offset(_pos);
-			prim->Dst().offset(-44, -134);
-			prim->Dst() += _nBodyOffset;
+			prim->getDst().setEmpty();
+			prim->getDst().offset(-_curScroll);
+			prim->getDst().offset(_pos);
+			prim->getDst().offset(-44, -134);
+			prim->getDst() += _nBodyOffset;
 			CORO_INVOKE_2(_body.draw, bigBuf, prim);
 		}
 
 		if (!_bCorpoDavanti) {
-			prim->Dst().setEmpty();
-			prim->Dst().offset(-44, -134);
+			prim->getDst().setEmpty();
+			prim->getDst().offset(-44, -134);
 			if (_bPastorella)
-				prim->Dst().offset(0, 3);
+				prim->getDst().offset(0, 3);
 			CORO_INVOKE_2(RMCharacter::draw, bigBuf, prim);
 		}
 	}
-- 
cgit v1.2.3


From c52aca5ac407c498eb0a287697199a97f7c18bae Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Sat, 9 Jun 2012 00:52:38 +0200
Subject: TONY: Rename more globals

---
 engines/tony/tonychar.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 9f34276c41..a63d2d69c3 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -138,7 +138,7 @@ void RMTony::doFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
 	if (!_nInList && _bShow)
 		bigBuf->addPrim(new RMGfxPrimitive(this));
 
-	setSpeed(GLOBALS.nCfgTonySpeed);
+	setSpeed(GLOBALS._nCfgTonySpeed);
 
 	// Runs the normal character movement
 	_ctx->time = _vm->getTime();
-- 
cgit v1.2.3


From f64700b27fa8f083697a16459e8237bf6c48f1dc Mon Sep 17 00:00:00 2001
From: Paul Gilbert
Date: Mon, 11 Jun 2012 00:24:52 +1000
Subject: TONY: Fixed display of static animations, and some variable renaming

---
 engines/tony/tonychar.cpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index a63d2d69c3..f0357ad15d 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -950,7 +950,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 	case TALK_CONRICETTASTATIC:
 	case TALK_CONCONIGLIOSTATIC:
 	case TALK_CONCARTESTATIC:
-	case TALK_CONTACCUINOSTATIC:
+	case TALK_WITH_NOTEBOOK:
 	case TALK_CONMEGAFONOSTATIC:
 		switch (_TalkDirection) {
 		case LEFT:
@@ -1632,7 +1632,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		}
 		break;
 
-	case TALK_CONTACCUINOSTATIC:
+	case TALK_WITH_NOTEBOOK:
 		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
@@ -1736,6 +1736,9 @@ void RMTony::startStatic(CORO_PARAM, TALKTYPE nTalk) {
 	_ctx->headPat = _ctx->headLoopPat = 0;
 	_ctx->bodyStartPat = _ctx->bodyLoopPat = 0;
 
+	startStaticCalculate(nTalk, _ctx->headPat, _ctx->headLoopPat,
+		_ctx->bodyStartPat, _ctx->bodyLoopPat);
+
 	// e vai con i pattern
 	_bIsStaticTalk = true;
 
@@ -1827,7 +1830,7 @@ void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		}
 		break;
 
-	case TALK_CONTACCUINOSTATIC:
+	case TALK_WITH_NOTEBOOK:
 		switch (_TalkDirection) {
 		case UP:
 		case LEFT:
-- 
cgit v1.2.3


From 44ee26e6c99383dd9cec1392afae958faaf87b12 Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Sun, 10 Jun 2012 23:56:37 +0200
Subject: TONY: Rename variables in loc.h and mpal.h

---
 engines/tony/tonychar.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index f0357ad15d..6852369c64 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -178,7 +178,7 @@ void RMTony::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 	CORO_BEGIN_CODE(_ctx);
 
 	// Call the Draw() of the parent class if Tony is visible
-	if (_bShow && bDrawNow) {
+	if (_bShow && _bDrawNow) {
 		if (_bCorpoDavanti) {
 			prim->getDst().setEmpty();
 			prim->getDst().offset(-44, -134);
@@ -317,8 +317,8 @@ void RMTony::stop(CORO_PARAM) {
 		if (_ctx->pid == CORO_INVALID_PID_VALUE)
 			CORO_INVOKE_0(RMCharacter::stop);
 		else {
-			bNeedToStop = false;    // If we make the OnWhichDirection, we don't need at least after the Stop().
-			bMoving = false;
+			_bNeedToStop = false;    // If we make the OnWhichDirection, we don't need at least after the Stop().
+			_bMoving = false;
 			CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _ctx->pid, CORO_INFINITE); // @@@ Put an assert after 10 seconds
 		}
 	} else {
-- 
cgit v1.2.3


From 5de8b7aa74ad01daea0d41eebd24ad6f63edccd4 Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Mon, 11 Jun 2012 21:43:04 +0200
Subject: TONY: Rename variables in tonychar.h

---
 engines/tony/tonychar.cpp | 154 +++++++++++++++++++++++-----------------------
 1 file changed, 77 insertions(+), 77 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 6852369c64..5d2c4d37bc 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -49,17 +49,17 @@ RMTony::RMTony() {
 	_bShowOmbra = false;
 	_bCorpoDavanti = false;
 	_bActionPending = false;
-	_ActionItem = NULL;
-	_Action = 0;
-	_ActionParm = 0;
+	_actionItem = NULL;
+	_action = 0;
+	_actionParm = 0;
 	_bPastorella = false;
 	_bIsStaticTalk = false;
 	_bIsTalking = false;
 	_nPatB4Talking = 0;
 	_nTalkType = TALK_NORMAL;
-	_TalkDirection = UP;
+	_talkDirection = UP;
 	_nTimeLastStep = 0;
-	hActionThread = CORO_INVALID_PID_VALUE;
+	_hActionThread = CORO_INVALID_PID_VALUE;
 }
 
 void RMTony::waitEndOfAction(CORO_PARAM, const void *param) {
@@ -219,18 +219,18 @@ void RMTony::moveAndDoAction(CORO_PARAM, RMPoint dst, RMItem *item, int nAction,
 	// Makes normal movement, but remember if you must then perform an action
 	if (item == NULL) {
 		_bActionPending = false;
-		_ActionItem = NULL;
+		_actionItem = NULL;
 	} else {
-		_ActionItem = item;
-		_Action = nAction;
-		_ActionParm = nActionParm;
+		_actionItem = item;
+		_action = nAction;
+		_actionParm = nActionParm;
 		_bActionPending = true;
 	}
 
 	CORO_INVOKE_2(RMCharacter::move, dst, &_ctx->result);
 	if (!_ctx->result) {
 		_bActionPending = false;
-		_ActionItem = NULL;
+		_actionItem = NULL;
 	}
 
 	CORO_END_CODE;
@@ -265,23 +265,23 @@ void RMTony::executeAction(int nAction, int nActionItem, int nParm) {
 	if (pid != CORO_INVALID_PID_VALUE) {
 		_bAction = true;
 		CoroScheduler.createProcess(waitEndOfAction, &pid, sizeof(uint32));
-		hActionThread = pid;
+		_hActionThread = pid;
 	} else if (nAction != TA_GOTO) {
 		if (nAction == TA_TALK) {
 			pid = mpalQueryDoAction(6, 1, 0);
 			_bAction = true;
 			CoroScheduler.createProcess(waitEndOfAction, &pid, sizeof(uint32));
-			hActionThread = pid;
+			_hActionThread = pid;
 		} else if (nAction == TA_PALESATI) {
 			pid = mpalQueryDoAction(7, 1, 0);
 			_bAction = true;
 			CoroScheduler.createProcess(waitEndOfAction, &pid, sizeof(uint32));
-			hActionThread = pid;
+			_hActionThread = pid;
 		} else {
 			pid = mpalQueryDoAction(5, 1, 0);
 			_bAction = true;
 			CoroScheduler.createProcess(waitEndOfAction, &pid, sizeof(uint32));
-			hActionThread = pid;
+			_hActionThread = pid;
 		}
 	}
 }
@@ -294,10 +294,10 @@ void RMTony::stopNoAction(CORO_PARAM) {
 	CORO_BEGIN_CODE(_ctx);
 
 	if (_bAction)
-		CORO_INVOKE_2(CoroScheduler.waitForSingleObject, hActionThread, CORO_INFINITE);
+		CORO_INVOKE_2(CoroScheduler.waitForSingleObject, _hActionThread, CORO_INFINITE);
 
 	_bActionPending = false;
-	_ActionItem = NULL;
+	_actionItem = NULL;
 	CORO_INVOKE_0(stop);
 
 	CORO_END_CODE;
@@ -310,9 +310,9 @@ void RMTony::stop(CORO_PARAM) {
 
 	CORO_BEGIN_CODE(_ctx);
 
-	if (_ActionItem != NULL) {
+	if (_actionItem != NULL) {
 		// Call MPAL to choose the direction
-		_ctx->pid = mpalQueryDoAction(21, _ActionItem->mpalCode(), 0);
+		_ctx->pid = mpalQueryDoAction(21, _actionItem->mpalCode(), 0);
 
 		if (_ctx->pid == CORO_INVALID_PID_VALUE)
 			CORO_INVOKE_0(RMCharacter::stop);
@@ -330,9 +330,9 @@ void RMTony::stop(CORO_PARAM) {
 
 	_bActionPending = false;
 
-	executeAction(_Action, _ActionItem->mpalCode(), _ActionParm);
+	executeAction(_action, _actionItem->mpalCode(), _actionParm);
 
-	_ActionItem = NULL;
+	_actionItem = NULL;
 
 	CORO_END_CODE;
 }
@@ -562,7 +562,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 	if (!_bIsStaticTalk) {
 		switch (_nPatB4Talking) {
 		case PAT_STANDDOWN:
-			_TalkDirection = DOWN;
+			_talkDirection = DOWN;
 			break;
 
 		case PAT_TAKELEFT_UP2:
@@ -570,7 +570,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case PAT_TAKELEFT_DOWN2:
 		case PAT_SIRIALZALEFT:
 		case PAT_STANDLEFT:
-			_TalkDirection = LEFT;
+			_talkDirection = LEFT;
 			break;
 
 		case PAT_TAKERIGHT_UP2:
@@ -578,14 +578,14 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case PAT_TAKERIGHT_DOWN2:
 		case PAT_SIRIALZARIGHT:
 		case PAT_STANDRIGHT:
-			_TalkDirection = RIGHT;
+			_talkDirection = RIGHT;
 			break;
 
 		case PAT_TAKEUP_UP2:
 		case PAT_TAKEUP_MID2:
 		case PAT_TAKEUP_DOWN2:
 		case PAT_STANDUP:
-			_TalkDirection = UP;
+			_talkDirection = UP;
 			break;
 		}
 
@@ -596,7 +596,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 	if (_bPastorella) {
 		// Talking whilst a shepherdess
 		mainFreeze();
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 			setPattern(PAT_PAST_TALKUP);
 			break;
@@ -626,7 +626,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		headStartPat = 0;
 		bodyStartPat = 0;
 
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case DOWN:
 			headLoopPat = PAT_TALK_DOWN;
 			bodyLoopPat = BPAT_STANDDOWN;
@@ -655,7 +655,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 	case TALK_FIANCHI:
 		_bCorpoDavanti = false;
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 			_nBodyOffset.set(2, 42);
 			headStartPat = PAT_TESTA_UP;
@@ -701,7 +701,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 	case TALK_RIDE:
 		_bCorpoDavanti = false;
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case DOWN:
 		case LEFT:
@@ -724,7 +724,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 	case TALK_RIDE2:
 		_bCorpoDavanti = false;
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case DOWN:
 		case LEFT:
@@ -746,7 +746,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 
 	case TALK_SIINDICA:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case DOWN:
 		case LEFT:
@@ -764,7 +764,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_SPAVENTATO:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 			_nBodyOffset.set(-4, -11);
 			headStartPat = PAT_TESTA_UP;
@@ -801,7 +801,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 	case TALK_SPAVENTATO2:
 		_bCorpoDavanti = false;
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 			bodyStartPat = BPAT_STANDUP;
 			bodyLoopPat = BPAT_STANDUP;
@@ -867,7 +867,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_CONCONIGLIO:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case LEFT:
 		case UP:
 			_nBodyOffset.set(-21, -5);
@@ -887,7 +887,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_CONRICETTA:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case LEFT:
 		case UP:
 			_nBodyOffset.set(-61, -7);
@@ -907,7 +907,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_CONCARTE:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case LEFT:
 		case UP:
 			_nBodyOffset.set(-34, -2);
@@ -927,7 +927,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_CONPUPAZZO:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case LEFT:
 		case UP:
 			_nBodyOffset.set(-35, 2);
@@ -952,7 +952,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 	case TALK_CONCARTESTATIC:
 	case TALK_WITH_NOTEBOOK:
 	case TALK_CONMEGAFONOSTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case LEFT:
 		case UP:
 			headLoopPat = PAT_TALK_LEFT;
@@ -967,7 +967,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		// The beard is the only case in which the head is animated separately while the body is the standard
 	case TALK_CONBARBASTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case LEFT:
 		case UP:
 			headLoopPat = PAT_TALKBARBA_LEFT;
@@ -985,7 +985,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_SCHIFATO:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case LEFT:
 		case UP:
 			_nBodyOffset.set(6, 56);
@@ -1005,7 +1005,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_NAAH:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case LEFT:
 		case UP:
 			_nBodyOffset.set(6, 56);
@@ -1072,7 +1072,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 	case TALK_SPAVENTATOSTATIC:
 		_bCorpoDavanti = false;
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case DOWN:
 			bodyStartPat = BPAT_STANDDOWN;
 			bodyLoopPat = BPAT_STANDDOWN;
@@ -1151,7 +1151,7 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 	bodyEndPat = 0;
 	headEndPat = 0;
 
-	switch (_TalkDirection) {
+	switch (_talkDirection) {
 	case UP:
 		finalPat = PAT_STANDUP;
 		headStandPat = PAT_TESTA_UP;
@@ -1189,7 +1189,7 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_FIANCHI:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 			bodyEndPat = BPAT_FIANCHIUP_END;
 			break;
@@ -1214,16 +1214,16 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 
 	case TALK_RIDE:
 	case TALK_RIDE2:
-		if (_TalkDirection == LEFT)
+		if (_talkDirection == LEFT)
 			headEndPat = PAT_RIDELEFT_END;
-		else if (_TalkDirection == RIGHT)
+		else if (_talkDirection == RIGHT)
 			headEndPat = PAT_RIDERIGHT_END;
 
 		bodyEndPat = 0;
 		break;
 
 	case TALK_SCHIFATO:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			headEndPat = PAT_SCHIFATOLEFT_END;
@@ -1239,7 +1239,7 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_NAAH:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			headEndPat = PAT_NAAHLEFT_END;
@@ -1258,7 +1258,7 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_SPAVENTATO:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 			bodyEndPat = BPAT_SPAVENTOUP_END;
 			break;
@@ -1281,7 +1281,7 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_SPAVENTATO2:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 			bodyEndPat = 0;
 			break;
@@ -1304,7 +1304,7 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_CONCONIGLIO:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
@@ -1320,7 +1320,7 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_CONRICETTA:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
@@ -1336,7 +1336,7 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_CONCARTE:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
@@ -1352,7 +1352,7 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_CONPUPAZZO:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
@@ -1395,7 +1395,7 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		break;
 
 	case TALK_SPAVENTATOSTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case DOWN:
 			headStandPat = PAT_SPAVENTODOWN_STAND;
 			bodyEndPat = 0;
@@ -1448,10 +1448,10 @@ void RMTony::endTalk(CORO_PARAM) {
 		if (_nTalkType == TALK_CONBARBASTATIC) {
 			mainFreeze();
 			setPattern(0);
-			if (_TalkDirection == UP || _TalkDirection == LEFT) {
+			if (_talkDirection == UP || _talkDirection == LEFT) {
 				_body.setPattern(BPAT_CONBARBALEFT_STATIC);
 				_nBodyOffset.set(-41, -14);
-			} else if (_TalkDirection == DOWN || _TalkDirection == RIGHT) {
+			} else if (_talkDirection == DOWN || _talkDirection == RIGHT) {
 				_body.setPattern(BPAT_CONBARBARIGHT_STATIC);
 				_nBodyOffset.set(-26, -14);
 			}
@@ -1526,7 +1526,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 
 	switch (nPat) {
 	case PAT_STANDDOWN:
-		_TalkDirection = DOWN;
+		_talkDirection = DOWN;
 		headPat = PAT_TESTA_RIGHT;
 		break;
 
@@ -1535,7 +1535,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 	case PAT_TAKELEFT_DOWN2:
 	case PAT_SIRIALZALEFT:
 	case PAT_STANDLEFT:
-		_TalkDirection = LEFT;
+		_talkDirection = LEFT;
 		headPat = PAT_TESTA_LEFT;
 		break;
 
@@ -1544,7 +1544,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 	case PAT_TAKERIGHT_DOWN2:
 	case PAT_SIRIALZARIGHT:
 	case PAT_STANDRIGHT:
-		_TalkDirection = RIGHT;
+		_talkDirection = RIGHT;
 		headPat = PAT_TESTA_RIGHT;
 		break;
 
@@ -1552,7 +1552,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 	case PAT_TAKEUP_MID2:
 	case PAT_TAKEUP_DOWN2:
 	case PAT_STANDUP:
-		_TalkDirection = UP;
+		_talkDirection = UP;
 		headPat = PAT_TESTA_LEFT;
 		break;
 	}
@@ -1561,7 +1561,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 
 	switch (nTalk) {
 	case TALK_CONCONIGLIOSTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			_nBodyOffset.set(-21, -5);
@@ -1579,7 +1579,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		break;
 
 	case TALK_CONCARTESTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			_nBodyOffset.set(-34, -2);
@@ -1597,7 +1597,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		break;
 
 	case TALK_CONRICETTASTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			_nBodyOffset.set(-61, -7);
@@ -1615,7 +1615,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		break;
 
 	case TALK_CONPUPAZZOSTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			_nBodyOffset.set(-35, 2);
@@ -1633,7 +1633,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		break;
 
 	case TALK_WITH_NOTEBOOK:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			_nBodyOffset.set(-16, -9);
@@ -1651,7 +1651,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		break;
 
 	case TALK_CONMEGAFONOSTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			_nBodyOffset.set(-41, -8);
@@ -1669,7 +1669,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		break;
 
 	case TALK_CONBARBASTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			_nBodyOffset.set(-41, -14);
@@ -1691,7 +1691,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		break;
 
 	case TALK_SPAVENTATOSTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case DOWN:
 			headPat = PAT_SPAVENTODOWN_START;
 			bodyLoopPat = BPAT_STANDDOWN;
@@ -1761,7 +1761,7 @@ void RMTony::startStatic(CORO_PARAM, TALKTYPE nTalk) {
 
 
 void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat, int &headEndPat) {
-	switch (_TalkDirection) {
+	switch (_talkDirection) {
 	case UP:
 	case LEFT:
 		finalPat = PAT_STANDLEFT;
@@ -1775,7 +1775,7 @@ void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 
 	switch (nTalk) {
 	case TALK_CONPUPAZZOSTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			bodyEndPat = BPAT_CONPUPAZZOLEFT_END;
@@ -1789,7 +1789,7 @@ void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		break;
 
 	case TALK_CONRICETTASTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			bodyEndPat = BPAT_CONRICETTALEFT_END;
@@ -1803,7 +1803,7 @@ void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		break;
 
 	case TALK_CONCONIGLIOSTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			bodyEndPat = BPAT_CONCONIGLIOLEFT_END;
@@ -1817,7 +1817,7 @@ void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		break;
 
 	case TALK_CONCARTESTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			bodyEndPat = BPAT_CONCARTELEFT_END;
@@ -1831,7 +1831,7 @@ void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		break;
 
 	case TALK_WITH_NOTEBOOK:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			bodyEndPat = BPAT_CONTACCUINOLEFT_END;
@@ -1845,7 +1845,7 @@ void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		break;
 
 	case TALK_CONMEGAFONOSTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			bodyEndPat = BPAT_CONMEGAFONOLEFT_END;
@@ -1859,7 +1859,7 @@ void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		break;
 
 	case TALK_CONBARBASTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			bodyEndPat = BPAT_CONBARBALEFT_END;
@@ -1873,7 +1873,7 @@ void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		break;
 
 	case TALK_SPAVENTATOSTATIC:
-		switch (_TalkDirection) {
+		switch (_talkDirection) {
 		case LEFT:
 			headEndPat = PAT_SPAVENTOLEFT_END;
 			break;
-- 
cgit v1.2.3


From 985602a72d52acdb99599eaddbed7f7b9fce01ce Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Tue, 12 Jun 2012 00:07:50 +0200
Subject: TONY: Rename some Italian into English

---
 engines/tony/tonychar.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 5d2c4d37bc..e384dfe794 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -272,7 +272,7 @@ void RMTony::executeAction(int nAction, int nActionItem, int nParm) {
 			_bAction = true;
 			CoroScheduler.createProcess(waitEndOfAction, &pid, sizeof(uint32));
 			_hActionThread = pid;
-		} else if (nAction == TA_PALESATI) {
+		} else if (nAction == TA_PERORATE) {
 			pid = mpalQueryDoAction(7, 1, 0);
 			_bAction = true;
 			CoroScheduler.createProcess(waitEndOfAction, &pid, sizeof(uint32));
-- 
cgit v1.2.3


From 876d47e17d84912dbcf3e2f29339b2a792d92e95 Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Tue, 12 Jun 2012 21:42:46 +0200
Subject: TONY: Translate Italian enums

---
 engines/tony/tonychar.cpp | 346 +++++++++++++++++++++++-----------------------
 1 file changed, 173 insertions(+), 173 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index e384dfe794..f232f56cb2 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -763,43 +763,43 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		}
 		break;
 
-	case TALK_SPAVENTATO:
+	case TALK_SCARED:
 		switch (_talkDirection) {
 		case UP:
 			_nBodyOffset.set(-4, -11);
 			headStartPat = PAT_TESTA_UP;
-			bodyStartPat = BPAT_SPAVENTOUP_START;
+			bodyStartPat = BPAT_SCAREDUP_START;
 			headLoopPat = PAT_TALK_UP;
-			bodyLoopPat = BPAT_SPAVENTOUP_LOOP;
+			bodyLoopPat = BPAT_SCAREDUP_LOOP;
 			break;
 
 		case DOWN:
 			_nBodyOffset.set(-5, 45);
-			headStartPat = PAT_SPAVENTODOWN_START;
-			bodyStartPat = BPAT_SPAVENTODOWN_START;
-			headLoopPat = PAT_SPAVENTODOWN_LOOP;
-			bodyLoopPat = BPAT_SPAVENTODOWN_LOOP;
+			headStartPat = PAT_SCAREDDOWN_START;
+			bodyStartPat = BPAT_SCAREDDOWN_START;
+			headLoopPat = PAT_SCAREDDOWN_LOOP;
+			bodyLoopPat = BPAT_SCAREDDOWN_LOOP;
 			break;
 
 		case RIGHT:
 			_nBodyOffset.set(-4, 41);
-			headStartPat = PAT_SPAVENTORIGHT_START;
-			bodyStartPat = BPAT_SPAVENTORIGHT_START;
-			headLoopPat = PAT_SPAVENTORIGHT_LOOP;
-			bodyLoopPat = BPAT_SPAVENTORIGHT_LOOP;
+			headStartPat = PAT_SCAREDRIGHT_START;
+			bodyStartPat = BPAT_SCAREDRIGHT_START;
+			headLoopPat = PAT_SCAREDRIGHT_LOOP;
+			bodyLoopPat = BPAT_SCAREDRIGHT_LOOP;
 			break;
 
 		case LEFT:
 			_nBodyOffset.set(-10, 41);
-			headStartPat = PAT_SPAVENTOLEFT_START;
-			bodyStartPat = BPAT_SPAVENTOLEFT_START;
-			headLoopPat = PAT_SPAVENTOLEFT_LOOP;
-			bodyLoopPat = BPAT_SPAVENTOLEFT_LOOP;
+			headStartPat = PAT_SCAREDLEFT_START;
+			bodyStartPat = BPAT_SCAREDLEFT_START;
+			headLoopPat = PAT_SCAREDLEFT_LOOP;
+			bodyLoopPat = BPAT_SCAREDLEFT_LOOP;
 			break;
 		}
 		break;
 
-	case TALK_SPAVENTATO2:
+	case TALK_SCARED2:
 		_bCorpoDavanti = false;
 		switch (_talkDirection) {
 		case UP:
@@ -816,8 +816,8 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			bodyLoopPat = BPAT_STANDDOWN;
 			_nBodyOffset.set(4, 53);
 
-			headStartPat = PAT_SPAVENTODOWN_START;
-			headLoopPat = PAT_SPAVENTODOWN_LOOP;
+			headStartPat = PAT_SCAREDDOWN_START;
+			headLoopPat = PAT_SCAREDDOWN_LOOP;
 			break;
 
 		case RIGHT:
@@ -825,8 +825,8 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			bodyLoopPat = BPAT_STANDRIGHT;
 			_nBodyOffset.set(6, 56);
 
-			headStartPat = PAT_SPAVENTORIGHT_START;
-			headLoopPat = PAT_SPAVENTORIGHT_LOOP;
+			headStartPat = PAT_SCAREDRIGHT_START;
+			headLoopPat = PAT_SCAREDRIGHT_LOOP;
 			break;
 
 		case LEFT:
@@ -834,124 +834,124 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			bodyLoopPat = BPAT_STANDLEFT;
 			_nBodyOffset.set(6, 56);
 
-			headStartPat = PAT_SPAVENTOLEFT_START;
-			headLoopPat = PAT_SPAVENTOLEFT_LOOP;
+			headStartPat = PAT_SCAREDLEFT_START;
+			headLoopPat = PAT_SCAREDLEFT_LOOP;
 			break;
 		}
 		break;
 
-	case TALK_CONBICCHIERE:
+	case TALK_WITHGLASSES:
 		_nBodyOffset.set(4, 53);
 		headLoopPat = PAT_TALK_DOWN;
-		bodyLoopPat = BPAT_BICCHIERE;
+		bodyLoopPat = BPAT_GLASS;
 		break;
-	case TALK_CONVERME:
+	case TALK_WITHWORM:
 		_nBodyOffset.set(9, 56);
 		headLoopPat = PAT_TALK_RIGHT;
-		bodyLoopPat = BPAT_VERME;
+		bodyLoopPat = BPAT_WORM;
 		break;
-	case TALK_CONMARTELLO:
+	case TALK_WITHHAMMER:
 		_nBodyOffset.set(6, 56);
 		headLoopPat = PAT_TALK_LEFT;
-		bodyLoopPat = BPAT_MARTELLO;
+		bodyLoopPat = BPAT_HAMMER;
 		break;
-	case TALK_CONCORDA:
+	case TALK_WITHROPE:
 		_nBodyOffset.set(-3, 38);
 		headLoopPat = PAT_TALK_RIGHT;
-		bodyLoopPat = BPAT_CORDA;
+		bodyLoopPat = BPAT_ROPE;
 		break;
-	case TALK_CONSEGRETARIA:
+	case TALK_WITHSECRETARY:
 		_nBodyOffset.set(-17, 12);
 		headLoopPat = PAT_TALK_RIGHT;
-		bodyLoopPat = BPAT_CONSEGRETARIA;
+		bodyLoopPat = BPAT_WITHSECRETARY;
 		break;
 
-	case TALK_CONCONIGLIO:
+	case TALK_WITHRABBIT:
 		switch (_talkDirection) {
 		case LEFT:
 		case UP:
 			_nBodyOffset.set(-21, -5);
-			bodyStartPat = BPAT_CONCONIGLIOLEFT_START;
+			bodyStartPat = BPAT_WITHRABBITLEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
-			bodyLoopPat = BPAT_CONCONIGLIOLEFT_LOOP;
+			bodyLoopPat = BPAT_WITHRABBITLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
 			_nBodyOffset.set(-4, -5);
-			bodyStartPat = BPAT_CONCONIGLIORIGHT_START;
+			bodyStartPat = BPAT_WITHRABBITRIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
-			bodyLoopPat = BPAT_CONCONIGLIORIGHT_LOOP;
+			bodyLoopPat = BPAT_WITHRABBITRIGHT_LOOP;
 			break;
 		}
 		break;
 
-	case TALK_CONRICETTA:
+	case TALK_WITHRECIPE:
 		switch (_talkDirection) {
 		case LEFT:
 		case UP:
 			_nBodyOffset.set(-61, -7);
-			bodyStartPat = BPAT_CONRICETTALEFT_START;
+			bodyStartPat = BPAT_WITHRECIPELEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
-			bodyLoopPat = BPAT_CONRICETTALEFT_LOOP;
+			bodyLoopPat = BPAT_WITHRECIPELEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
 			_nBodyOffset.set(-5, -7);
-			bodyStartPat = BPAT_CONRICETTARIGHT_START;
+			bodyStartPat = BPAT_WITHRECIPERIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
-			bodyLoopPat = BPAT_CONRICETTARIGHT_LOOP;
+			bodyLoopPat = BPAT_WITHRECIPERIGHT_LOOP;
 			break;
 		}
 		break;
 
-	case TALK_CONCARTE:
+	case TALK_WITHCARDS:
 		switch (_talkDirection) {
 		case LEFT:
 		case UP:
 			_nBodyOffset.set(-34, -2);
-			bodyStartPat = BPAT_CONCARTELEFT_START;
+			bodyStartPat = BPAT_WITHCARDSLEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
-			bodyLoopPat = BPAT_CONCARTELEFT_LOOP;
+			bodyLoopPat = BPAT_WITHCARDSLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
 			_nBodyOffset.set(-4, -2);
-			bodyStartPat = BPAT_CONCARTERIGHT_START;
+			bodyStartPat = BPAT_WITHCARDSRIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
-			bodyLoopPat = BPAT_CONCARTERIGHT_LOOP;
+			bodyLoopPat = BPAT_WITHCARDSRIGHT_LOOP;
 			break;
 		}
 		break;
 
-	case TALK_CONPUPAZZO:
+	case TALK_WITHSNOWMAN:
 		switch (_talkDirection) {
 		case LEFT:
 		case UP:
 			_nBodyOffset.set(-35, 2);
-			bodyStartPat = BPAT_CONPUPAZZOLEFT_START;
+			bodyStartPat = BPAT_WITHSNOWMANLEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
-			bodyLoopPat = BPAT_CONPUPAZZOLEFT_LOOP;
+			bodyLoopPat = BPAT_WITHSNOWMANLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
 			_nBodyOffset.set(-14, 2);
-			bodyStartPat = BPAT_CONPUPAZZORIGHT_START;
+			bodyStartPat = BPAT_WITHSNOWMANRIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
-			bodyLoopPat = BPAT_CONPUPAZZORIGHT_LOOP;
+			bodyLoopPat = BPAT_WITHSNOWMANRIGHT_LOOP;
 			break;
 		}
 		break;
 
-	case TALK_CONPUPAZZOSTATIC:
-	case TALK_CONRICETTASTATIC:
-	case TALK_CONCONIGLIOSTATIC:
-	case TALK_CONCARTESTATIC:
+	case TALK_WITHSNOWMANSTATIC:
+	case TALK_WITHRECIPESTATIC:
+	case TALK_WITHRABBITSTATIC:
+	case TALK_WITHCARDSSTATIC:
 	case TALK_WITH_NOTEBOOK:
-	case TALK_CONMEGAFONOSTATIC:
+	case TALK_WITHMEGAPHONESTATIC:
 		switch (_talkDirection) {
 		case LEFT:
 		case UP:
@@ -966,18 +966,18 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 		// The beard is the only case in which the head is animated separately while the body is the standard
-	case TALK_CONBARBASTATIC:
+	case TALK_WITHBEARDSTATIC:
 		switch (_talkDirection) {
 		case LEFT:
 		case UP:
-			headLoopPat = PAT_TALKBARBA_LEFT;
+			headLoopPat = PAT_TALKBEARD_LEFT;
 			bodyLoopPat = BPAT_STANDLEFT;
 			_nBodyOffset.set(6, 56);
 			break;
 
 		case DOWN:
 		case RIGHT:
-			headLoopPat = PAT_TALKBARBA_RIGHT;
+			headLoopPat = PAT_TALKBEARD_RIGHT;
 			bodyLoopPat = BPAT_STANDRIGHT;
 			_nBodyOffset.set(6, 56);
 			break;
@@ -1070,7 +1070,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		bodyLoopPat = BPAT_MACBETH9;
 		break;
 
-	case TALK_SPAVENTATOSTATIC:
+	case TALK_SCAREDSTATIC:
 		_bCorpoDavanti = false;
 		switch (_talkDirection) {
 		case DOWN:
@@ -1078,8 +1078,8 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			bodyLoopPat = BPAT_STANDDOWN;
 			_nBodyOffset.set(4, 53);
 
-			headStartPat = PAT_SPAVENTODOWN_STAND;
-			headLoopPat = PAT_SPAVENTODOWN_LOOP;
+			headStartPat = PAT_SCAREDDOWN_STAND;
+			headLoopPat = PAT_SCAREDDOWN_LOOP;
 			break;
 
 		case RIGHT:
@@ -1087,8 +1087,8 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			bodyLoopPat = BPAT_STANDRIGHT;
 			_nBodyOffset.set(6, 56);
 
-			headStartPat = PAT_SPAVENTORIGHT_STAND;
-			headLoopPat = PAT_SPAVENTORIGHT_LOOP;
+			headStartPat = PAT_SCAREDRIGHT_STAND;
+			headLoopPat = PAT_SCAREDRIGHT_LOOP;
 			break;
 
 		case LEFT:
@@ -1096,8 +1096,8 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 			bodyLoopPat = BPAT_STANDLEFT;
 			_nBodyOffset.set(6, 56);
 
-			headStartPat = PAT_SPAVENTOLEFT_STAND;
-			headLoopPat = PAT_SPAVENTOLEFT_LOOP;
+			headStartPat = PAT_SCAREDLEFT_STAND;
+			headLoopPat = PAT_SCAREDLEFT_LOOP;
 			break;
 
 		default:
@@ -1257,130 +1257,130 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 	case TALK_SIINDICA:
 		break;
 
-	case TALK_SPAVENTATO:
+	case TALK_SCARED:
 		switch (_talkDirection) {
 		case UP:
-			bodyEndPat = BPAT_SPAVENTOUP_END;
+			bodyEndPat = BPAT_SCAREDUP_END;
 			break;
 
 		case DOWN:
-			headEndPat = PAT_SPAVENTODOWN_END;
-			bodyEndPat = BPAT_SPAVENTODOWN_END;
+			headEndPat = PAT_SCAREDDOWN_END;
+			bodyEndPat = BPAT_SCAREDDOWN_END;
 			break;
 
 		case RIGHT:
-			headEndPat = PAT_SPAVENTORIGHT_END;
-			bodyEndPat = BPAT_SPAVENTORIGHT_END;
+			headEndPat = PAT_SCAREDRIGHT_END;
+			bodyEndPat = BPAT_SCAREDRIGHT_END;
 			break;
 
 		case LEFT:
-			headEndPat = PAT_SPAVENTOLEFT_END;
-			bodyEndPat = BPAT_SPAVENTOLEFT_END;
+			headEndPat = PAT_SCAREDLEFT_END;
+			bodyEndPat = BPAT_SCAREDLEFT_END;
 			break;
 		}
 		break;
 
-	case TALK_SPAVENTATO2:
+	case TALK_SCARED2:
 		switch (_talkDirection) {
 		case UP:
 			bodyEndPat = 0;
 			break;
 
 		case DOWN:
-			headEndPat = PAT_SPAVENTODOWN_END;
+			headEndPat = PAT_SCAREDDOWN_END;
 			bodyEndPat = 0;
 			break;
 
 		case RIGHT:
-			headEndPat = PAT_SPAVENTORIGHT_END;
+			headEndPat = PAT_SCAREDRIGHT_END;
 			bodyEndPat = 0;
 			break;
 
 		case LEFT:
-			headEndPat = PAT_SPAVENTOLEFT_END;
+			headEndPat = PAT_SCAREDLEFT_END;
 			bodyEndPat = 0;
 			break;
 		}
 		break;
 
-	case TALK_CONCONIGLIO:
+	case TALK_WITHRABBIT:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
-			bodyEndPat = BPAT_CONCONIGLIOLEFT_END;
+			bodyEndPat = BPAT_WITHRABBITLEFT_END;
 			break;
 
 		case RIGHT:
 		case DOWN:
 			finalPat = PAT_STANDRIGHT;
-			bodyEndPat = BPAT_CONCONIGLIORIGHT_END;
+			bodyEndPat = BPAT_WITHRABBITRIGHT_END;
 			break;
 		}
 		break;
 
-	case TALK_CONRICETTA:
+	case TALK_WITHRECIPE:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
-			bodyEndPat = BPAT_CONRICETTALEFT_END;
+			bodyEndPat = BPAT_WITHRECIPELEFT_END;
 			break;
 
 		case RIGHT:
 		case DOWN:
 			finalPat = PAT_STANDRIGHT;
-			bodyEndPat = BPAT_CONRICETTARIGHT_END;
+			bodyEndPat = BPAT_WITHRECIPERIGHT_END;
 			break;
 		}
 		break;
 
-	case TALK_CONCARTE:
+	case TALK_WITHCARDS:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
-			bodyEndPat = BPAT_CONCARTELEFT_END;
+			bodyEndPat = BPAT_WITHCARDSLEFT_END;
 			break;
 
 		case RIGHT:
 		case DOWN:
 			finalPat = PAT_STANDRIGHT;
-			bodyEndPat = BPAT_CONCARTERIGHT_END;
+			bodyEndPat = BPAT_WITHCARDSRIGHT_END;
 			break;
 		}
 		break;
 
-	case TALK_CONPUPAZZO:
+	case TALK_WITHSNOWMAN:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			finalPat = PAT_STANDLEFT;
-			bodyEndPat = BPAT_CONPUPAZZOLEFT_END;
+			bodyEndPat = BPAT_WITHSNOWMANLEFT_END;
 			break;
 
 		case RIGHT:
 		case DOWN:
 			finalPat = PAT_STANDRIGHT;
-			bodyEndPat = BPAT_CONPUPAZZORIGHT_END;
+			bodyEndPat = BPAT_WITHSNOWMANRIGHT_END;
 			break;
 		}
 		break;
 
-	case TALK_CONVERME:
-		finalPat = PAT_CONVERME;
+	case TALK_WITHWORM:
+		finalPat = PAT_WITHWORM;
 		break;
-	case TALK_CONCORDA:
-		finalPat = PAT_CONCORDA;
+	case TALK_WITHROPE:
+		finalPat = PAT_WITHROPE;
 		break;
-	case TALK_CONSEGRETARIA:
-		finalPat = PAT_CONSEGRETARIA;
+	case TALK_WITHSECRETARY:
+		finalPat = PAT_WITHSECRETARY;
 		break;
-	case TALK_CONMARTELLO:
-		finalPat = PAT_CONMARTELLO;
+	case TALK_WITHHAMMER:
+		finalPat = PAT_WITHHAMMER;
 		break;
-	case TALK_CONBICCHIERE:
-		finalPat = PAT_CONBICCHIERE;
+	case TALK_WITHGLASSES:
+		finalPat = PAT_WITHGLASSES;
 		break;
 
 	case TALK_MACBETH1:
@@ -1394,20 +1394,20 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		finalPat = 0;
 		break;
 
-	case TALK_SPAVENTATOSTATIC:
+	case TALK_SCAREDSTATIC:
 		switch (_talkDirection) {
 		case DOWN:
-			headStandPat = PAT_SPAVENTODOWN_STAND;
+			headStandPat = PAT_SCAREDDOWN_STAND;
 			bodyEndPat = 0;
 			break;
 
 		case RIGHT:
-			headStandPat = PAT_SPAVENTORIGHT_STAND;
+			headStandPat = PAT_SCAREDRIGHT_STAND;
 			bodyEndPat = 0;
 			break;
 
 		case LEFT:
-			headStandPat = PAT_SPAVENTOLEFT_STAND;
+			headStandPat = PAT_SCAREDLEFT_STAND;
 			bodyEndPat = 0;
 			break;
 
@@ -1445,14 +1445,14 @@ void RMTony::endTalk(CORO_PARAM) {
 
 	// Handles the end of an animated and static, leaving everything unchanged
 	if (_bIsStaticTalk) {
-		if (_nTalkType == TALK_CONBARBASTATIC) {
+		if (_nTalkType == TALK_WITHBEARDSTATIC) {
 			mainFreeze();
 			setPattern(0);
 			if (_talkDirection == UP || _talkDirection == LEFT) {
-				_body.setPattern(BPAT_CONBARBALEFT_STATIC);
+				_body.setPattern(BPAT_WITHBEARDLEFT_STATIC);
 				_nBodyOffset.set(-41, -14);
 			} else if (_talkDirection == DOWN || _talkDirection == RIGHT) {
-				_body.setPattern(BPAT_CONBARBARIGHT_STATIC);
+				_body.setPattern(BPAT_WITHBEARDRIGHT_STATIC);
 				_nBodyOffset.set(-26, -14);
 			}
 			mainUnfreeze();
@@ -1560,74 +1560,74 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 	_bCorpoDavanti = true;
 
 	switch (nTalk) {
-	case TALK_CONCONIGLIOSTATIC:
+	case TALK_WITHRABBITSTATIC:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			_nBodyOffset.set(-21, -5);
-			bodyStartPat = BPAT_CONCONIGLIOLEFT_START;
-			bodyLoopPat = BPAT_CONCONIGLIOLEFT_LOOP;
+			bodyStartPat = BPAT_WITHRABBITLEFT_START;
+			bodyLoopPat = BPAT_WITHRABBITLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
 			_nBodyOffset.set(-4, -5);
-			bodyStartPat = BPAT_CONCONIGLIORIGHT_START;
-			bodyLoopPat = BPAT_CONCONIGLIORIGHT_LOOP;
+			bodyStartPat = BPAT_WITHRABBITRIGHT_START;
+			bodyLoopPat = BPAT_WITHRABBITRIGHT_LOOP;
 			break;
 		}
 		break;
 
-	case TALK_CONCARTESTATIC:
+	case TALK_WITHCARDSSTATIC:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			_nBodyOffset.set(-34, -2);
-			bodyStartPat = BPAT_CONCARTELEFT_START;
-			bodyLoopPat = BPAT_CONCARTELEFT_LOOP;
+			bodyStartPat = BPAT_WITHCARDSLEFT_START;
+			bodyLoopPat = BPAT_WITHCARDSLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
 			_nBodyOffset.set(-4, -2);
-			bodyStartPat = BPAT_CONCARTERIGHT_START;
-			bodyLoopPat = BPAT_CONCARTERIGHT_LOOP;
+			bodyStartPat = BPAT_WITHCARDSRIGHT_START;
+			bodyLoopPat = BPAT_WITHCARDSRIGHT_LOOP;
 			break;
 		}
 		break;
 
-	case TALK_CONRICETTASTATIC:
+	case TALK_WITHRECIPESTATIC:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			_nBodyOffset.set(-61, -7);
-			bodyStartPat = BPAT_CONRICETTALEFT_START;
-			bodyLoopPat = BPAT_CONRICETTALEFT_LOOP;
+			bodyStartPat = BPAT_WITHRECIPELEFT_START;
+			bodyLoopPat = BPAT_WITHRECIPELEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
 			_nBodyOffset.set(-5, -7);
-			bodyStartPat = BPAT_CONRICETTARIGHT_START;
-			bodyLoopPat = BPAT_CONRICETTARIGHT_LOOP;
+			bodyStartPat = BPAT_WITHRECIPERIGHT_START;
+			bodyLoopPat = BPAT_WITHRECIPERIGHT_LOOP;
 			break;
 		}
 		break;
 
-	case TALK_CONPUPAZZOSTATIC:
+	case TALK_WITHSNOWMANSTATIC:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			_nBodyOffset.set(-35, 2);
-			bodyStartPat = BPAT_CONPUPAZZOLEFT_START;
-			bodyLoopPat = BPAT_CONPUPAZZOLEFT_LOOP;
+			bodyStartPat = BPAT_WITHSNOWMANLEFT_START;
+			bodyLoopPat = BPAT_WITHSNOWMANLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
 			_nBodyOffset.set(-14, 2);
-			bodyStartPat = BPAT_CONPUPAZZORIGHT_START;
-			bodyLoopPat = BPAT_CONPUPAZZORIGHT_LOOP;
+			bodyStartPat = BPAT_WITHSNOWMANRIGHT_START;
+			bodyLoopPat = BPAT_WITHSNOWMANRIGHT_LOOP;
 			break;
 		}
 		break;
@@ -1637,82 +1637,82 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 		case UP:
 		case LEFT:
 			_nBodyOffset.set(-16, -9);
-			bodyStartPat = BPAT_CONTACCUINOLEFT_START;
-			bodyLoopPat = BPAT_CONTACCUINOLEFT_LOOP;
+			bodyStartPat = BPAT_WITHNOTEBOOKLEFT_START;
+			bodyLoopPat = BPAT_WITHNOTEBOOKLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
 			_nBodyOffset.set(-6, -9);
-			bodyStartPat = BPAT_CONTACCUINORIGHT_START;
-			bodyLoopPat = BPAT_CONTACCUINORIGHT_LOOP;
+			bodyStartPat = BPAT_WITHNOTEBOOKRIGHT_START;
+			bodyLoopPat = BPAT_WITHNOTEBOOKRIGHT_LOOP;
 			break;
 		}
 		break;
 
-	case TALK_CONMEGAFONOSTATIC:
+	case TALK_WITHMEGAPHONESTATIC:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			_nBodyOffset.set(-41, -8);
-			bodyStartPat = BPAT_CONMEGAFONOLEFT_START;
-			bodyLoopPat = BPAT_CONMEGAFONOLEFT_LOOP;
+			bodyStartPat = BPAT_WITHMEGAPHONELEFT_START;
+			bodyLoopPat = BPAT_WITHMEGAPHONELEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
 			_nBodyOffset.set(-14, -8);
-			bodyStartPat = BPAT_CONMEGAFONORIGHT_START;
-			bodyLoopPat = BPAT_CONMEGAFONORIGHT_LOOP;
+			bodyStartPat = BPAT_WITHMEGAPHONERIGHT_START;
+			bodyLoopPat = BPAT_WITHMEGAPHONERIGHT_LOOP;
 			break;
 		}
 		break;
 
-	case TALK_CONBARBASTATIC:
+	case TALK_WITHBEARDSTATIC:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
 			_nBodyOffset.set(-41, -14);
-			bodyStartPat = BPAT_CONBARBALEFT_START;
+			bodyStartPat = BPAT_WITHBEARDLEFT_START;
 			bodyLoopPat = BPAT_STANDLEFT;
-			headLoopPat = PAT_TALKBARBA_LEFT;
+			headLoopPat = PAT_TALKBEARD_LEFT;
 			headPat = 0;
 			break;
 
 		case DOWN:
 		case RIGHT:
 			_nBodyOffset.set(-26, -14);
-			bodyStartPat = BPAT_CONBARBARIGHT_START;
+			bodyStartPat = BPAT_WITHBEARDRIGHT_START;
 			bodyLoopPat = BPAT_STANDRIGHT;
-			headLoopPat = PAT_TALKBARBA_RIGHT;
+			headLoopPat = PAT_TALKBEARD_RIGHT;
 			headPat = 0;
 			break;
 		}
 		break;
 
-	case TALK_SPAVENTATOSTATIC:
+	case TALK_SCAREDSTATIC:
 		switch (_talkDirection) {
 		case DOWN:
-			headPat = PAT_SPAVENTODOWN_START;
+			headPat = PAT_SCAREDDOWN_START;
 			bodyLoopPat = BPAT_STANDDOWN;
 			bodyStartPat = BPAT_STANDDOWN;
-			headLoopPat = PAT_SPAVENTODOWN_STAND;
+			headLoopPat = PAT_SCAREDDOWN_STAND;
 			_nBodyOffset.set(4, 53);
 			break;
 
 		case LEFT:
-			headPat = PAT_SPAVENTOLEFT_START;
+			headPat = PAT_SCAREDLEFT_START;
 			bodyLoopPat = BPAT_STANDLEFT;
 			bodyStartPat = BPAT_STANDLEFT;
-			headLoopPat = PAT_SPAVENTOLEFT_STAND;
+			headLoopPat = PAT_SCAREDLEFT_STAND;
 			_nBodyOffset.set(6, 56);
 			break;
 
 		case RIGHT:
-			headPat = PAT_SPAVENTORIGHT_START;
+			headPat = PAT_SCAREDRIGHT_START;
 			bodyLoopPat = BPAT_STANDRIGHT;
 			bodyStartPat = BPAT_STANDRIGHT;
-			headLoopPat = PAT_SPAVENTORIGHT_STAND;
+			headLoopPat = PAT_SCAREDRIGHT_STAND;
 			_nBodyOffset.set(6, 56);
 			break;
 
@@ -1774,58 +1774,58 @@ void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 	}
 
 	switch (nTalk) {
-	case TALK_CONPUPAZZOSTATIC:
+	case TALK_WITHSNOWMANSTATIC:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
-			bodyEndPat = BPAT_CONPUPAZZOLEFT_END;
+			bodyEndPat = BPAT_WITHSNOWMANLEFT_END;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			bodyEndPat = BPAT_CONPUPAZZORIGHT_END;
+			bodyEndPat = BPAT_WITHSNOWMANRIGHT_END;
 			break;
 		}
 		break;
 
-	case TALK_CONRICETTASTATIC:
+	case TALK_WITHRECIPESTATIC:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
-			bodyEndPat = BPAT_CONRICETTALEFT_END;
+			bodyEndPat = BPAT_WITHRECIPELEFT_END;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			bodyEndPat = BPAT_CONRICETTARIGHT_END;
+			bodyEndPat = BPAT_WITHRECIPERIGHT_END;
 			break;
 		}
 		break;
 
-	case TALK_CONCONIGLIOSTATIC:
+	case TALK_WITHRABBITSTATIC:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
-			bodyEndPat = BPAT_CONCONIGLIOLEFT_END;
+			bodyEndPat = BPAT_WITHRABBITLEFT_END;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			bodyEndPat = BPAT_CONCONIGLIORIGHT_END;
+			bodyEndPat = BPAT_WITHRABBITRIGHT_END;
 			break;
 		}
 		break;
 
-	case TALK_CONCARTESTATIC:
+	case TALK_WITHCARDSSTATIC:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
-			bodyEndPat = BPAT_CONCARTELEFT_END;
+			bodyEndPat = BPAT_WITHCARDSLEFT_END;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			bodyEndPat = BPAT_CONCARTERIGHT_END;
+			bodyEndPat = BPAT_WITHCARDSRIGHT_END;
 			break;
 		}
 		break;
@@ -1834,56 +1834,56 @@ void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
-			bodyEndPat = BPAT_CONTACCUINOLEFT_END;
+			bodyEndPat = BPAT_WITHNOTEBOOKLEFT_END;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			bodyEndPat = BPAT_CONTACCUINORIGHT_END;
+			bodyEndPat = BPAT_WITHNOTEBOOKRIGHT_END;
 			break;
 		}
 		break;
 
-	case TALK_CONMEGAFONOSTATIC:
+	case TALK_WITHMEGAPHONESTATIC:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
-			bodyEndPat = BPAT_CONMEGAFONOLEFT_END;
+			bodyEndPat = BPAT_WITHMEGAPHONELEFT_END;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			bodyEndPat = BPAT_CONMEGAFONORIGHT_END;
+			bodyEndPat = BPAT_WITHMEGAPHONERIGHT_END;
 			break;
 		}
 		break;
 
-	case TALK_CONBARBASTATIC:
+	case TALK_WITHBEARDSTATIC:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
-			bodyEndPat = BPAT_CONBARBALEFT_END;
+			bodyEndPat = BPAT_WITHBEARDLEFT_END;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			bodyEndPat = BPAT_CONBARBARIGHT_END;
+			bodyEndPat = BPAT_WITHBEARDRIGHT_END;
 			break;
 		}
 		break;
 
-	case TALK_SPAVENTATOSTATIC:
+	case TALK_SCAREDSTATIC:
 		switch (_talkDirection) {
 		case LEFT:
-			headEndPat = PAT_SPAVENTOLEFT_END;
+			headEndPat = PAT_SCAREDLEFT_END;
 			break;
 
 		case DOWN:
-			headEndPat = PAT_SPAVENTODOWN_END;
+			headEndPat = PAT_SCAREDDOWN_END;
 			break;
 
 		case RIGHT:
-			headEndPat = PAT_SPAVENTORIGHT_END;
+			headEndPat = PAT_SCAREDRIGHT_END;
 			break;
 
 		default:
-- 
cgit v1.2.3


From 5bafab9ad629595a1d270b60b2a91bd04dc1b7b9 Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Wed, 13 Jun 2012 08:00:37 +0200
Subject: TONY: Translate some more Italian

---
 engines/tony/tonychar.cpp | 122 +++++++++++++++++++++++-----------------------
 1 file changed, 61 insertions(+), 61 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index f232f56cb2..0f16bc45c3 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -46,13 +46,13 @@ void RMTony::initStatics() {
 
 RMTony::RMTony() {
 	_bShow = false;
-	_bShowOmbra = false;
-	_bCorpoDavanti = false;
+	_bShowShadow = false;
+	_bBodyFront = false;
 	_bActionPending = false;
 	_actionItem = NULL;
 	_action = 0;
 	_actionParm = 0;
-	_bPastorella = false;
+	_bShepherdess = false;
 	_bIsStaticTalk = false;
 	_bIsTalking = false;
 	_nPatB4Talking = 0;
@@ -94,13 +94,13 @@ void RMTony::init(void) {
 	RMDataStream ds;
 
 	// Tony is shown by default
-	_bShow = _bShowOmbra = true;
+	_bShow = _bShowShadow = true;
 
 	// No action pending
 	_bActionPending = false;
 	_bAction = false;
 
-	_bPastorella = false;
+	_bShepherdess = false;
 	_bIsTalking = false;
 	_bIsStaticTalk = false;
 
@@ -125,7 +125,7 @@ void RMTony::init(void) {
 
 void RMTony::close(void) {
 	// Disalloca @@@ Deallocation of missing item
-	_ombra.destroy();
+//	_shadow.destroy();
 }
 
 void RMTony::doFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
@@ -162,12 +162,12 @@ void RMTony::doFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
 
 void RMTony::show(void) {
 	_bShow = true;
-	_bShowOmbra = true;
+	_bShowShadow = true;
 }
 
-void RMTony::hide(bool bShowOmbra) {
+void RMTony::hide(bool bShowShadow) {
 	_bShow = false;
-	_bShowOmbra = bShowOmbra;
+	_bShowShadow = bShowShadow;
 }
 
 
@@ -179,10 +179,10 @@ void RMTony::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 
 	// Call the Draw() of the parent class if Tony is visible
 	if (_bShow && _bDrawNow) {
-		if (_bCorpoDavanti) {
+		if (_bBodyFront) {
 			prim->getDst().setEmpty();
 			prim->getDst().offset(-44, -134);
-			if (_bPastorella)
+			if (_bShepherdess)
 				prim->getDst().offset(1, 4);
 			CORO_INVOKE_2(RMCharacter::draw, bigBuf, prim);
 		}
@@ -197,10 +197,10 @@ void RMTony::draw(CORO_PARAM, RMGfxTargetBuffer &bigBuf, RMGfxPrimitive *prim) {
 			CORO_INVOKE_2(_body.draw, bigBuf, prim);
 		}
 
-		if (!_bCorpoDavanti) {
+		if (!_bBodyFront) {
 			prim->getDst().setEmpty();
 			prim->getDst().offset(-44, -134);
-			if (_bPastorella)
+			if (_bShepherdess)
 				prim->getDst().offset(0, 3);
 			CORO_INVOKE_2(RMCharacter::draw, bigBuf, prim);
 		}
@@ -341,7 +341,7 @@ void RMTony::stop(CORO_PARAM) {
 int RMTony::getCurPattern(void) {
 	int nPatt = RMCharacter::getCurPattern();
 
-	if (!_bPastorella)
+	if (!_bShepherdess)
 		return nPatt;
 
 	switch (nPatt) {
@@ -367,7 +367,7 @@ int RMTony::getCurPattern(void) {
 }
 
 void RMTony::setPattern(int nPatt, bool bPlayP0) {
-	if (_bPastorella) {
+	if (_bShepherdess) {
 		switch (nPatt) {
 		case PAT_STANDUP:
 			nPatt = PAT_PAST_STANDUP;
@@ -568,7 +568,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case PAT_TAKELEFT_UP2:
 		case PAT_TAKELEFT_MID2:
 		case PAT_TAKELEFT_DOWN2:
-		case PAT_SIRIALZALEFT:
+		case PAT_GETUPLEFT:
 		case PAT_STANDLEFT:
 			_talkDirection = LEFT;
 			break;
@@ -576,7 +576,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		case PAT_TAKERIGHT_UP2:
 		case PAT_TAKERIGHT_MID2:
 		case PAT_TAKERIGHT_DOWN2:
-		case PAT_SIRIALZARIGHT:
+		case PAT_GETUPRIGHT:
 		case PAT_STANDRIGHT:
 			_talkDirection = RIGHT;
 			break;
@@ -590,10 +590,10 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		}
 
 		// Puts the body in front by default
-		_bCorpoDavanti = true;
+		_bBodyFront = true;
 	}
 
-	if (_bPastorella) {
+	if (_bShepherdess) {
 		// Talking whilst a shepherdess
 		mainFreeze();
 		switch (_talkDirection) {
@@ -622,7 +622,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 	switch (nTalkType) {
 	case TALK_NORMAL:
-		_bCorpoDavanti = false;
+		_bBodyFront = false;
 		headStartPat = 0;
 		bodyStartPat = 0;
 
@@ -654,11 +654,11 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_FIANCHI:
-		_bCorpoDavanti = false;
+		_bBodyFront = false;
 		switch (_talkDirection) {
 		case UP:
 			_nBodyOffset.set(2, 42);
-			headStartPat = PAT_TESTA_UP;
+			headStartPat = PAT_HEAD_UP;
 			bodyStartPat = BPAT_FIANCHIUP_START;
 			headLoopPat = PAT_TALK_UP;
 			bodyLoopPat = BPAT_FIANCHIUP_LOOP;
@@ -666,7 +666,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case DOWN:
 			_nBodyOffset.set(2, 48);
-			headStartPat = PAT_TESTA_DOWN;
+			headStartPat = PAT_HEAD_DOWN;
 			bodyStartPat = BPAT_FIANCHIDOWN_START;
 			headLoopPat = PAT_TALK_DOWN;
 			bodyLoopPat = BPAT_FIANCHIDOWN_LOOP;
@@ -674,7 +674,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case LEFT:
 			_nBodyOffset.set(-3, 53);
-			headStartPat = PAT_TESTA_LEFT;
+			headStartPat = PAT_HEAD_LEFT;
 			bodyStartPat = BPAT_FIANCHILEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
 			bodyLoopPat = BPAT_FIANCHILEFT_LOOP;
@@ -682,7 +682,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 
 		case RIGHT:
 			_nBodyOffset.set(2, 53);
-			headStartPat = PAT_TESTA_RIGHT;
+			headStartPat = PAT_HEAD_RIGHT;
 			bodyStartPat = BPAT_FIANCHIRIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
 			bodyLoopPat = BPAT_FIANCHIRIGHT_LOOP;
@@ -691,16 +691,16 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 
-	case TALK_CANTA:
+	case TALK_SING:
 		_nBodyOffset.set(-10, 25);
-		headStartPat = PAT_TESTA_LEFT;
-		bodyStartPat = BPAT_CANTALEFT_START;
+		headStartPat = PAT_HEAD_LEFT;
+		bodyStartPat = BPAT_SINGLEFT_START;
 		headLoopPat = PAT_TALK_LEFT;
-		bodyLoopPat = BPAT_CANTALEFT_LOOP;
+		bodyLoopPat = BPAT_SINGLEFT_LOOP;
 		break;
 
 	case TALK_RIDE:
-		_bCorpoDavanti = false;
+		_bBodyFront = false;
 		switch (_talkDirection) {
 		case UP:
 		case DOWN:
@@ -723,7 +723,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_RIDE2:
-		_bCorpoDavanti = false;
+		_bBodyFront = false;
 		switch (_talkDirection) {
 		case UP:
 		case DOWN:
@@ -745,20 +745,20 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 
-	case TALK_SIINDICA:
+	case TALK_INDICATE:
 		switch (_talkDirection) {
 		case UP:
 		case DOWN:
 		case LEFT:
 			_nBodyOffset.set(-4, 40);
 			headLoopPat = PAT_TALK_LEFT;
-			bodyLoopPat = BPAT_SIINDICALEFT;
+			bodyLoopPat = BPAT_INDICATELEFT;
 			break;
 
 		case RIGHT:
 			_nBodyOffset.set(5, 40);
 			headLoopPat = PAT_TALK_RIGHT;
-			bodyLoopPat = BPAT_SIINDICARIGHT;
+			bodyLoopPat = BPAT_INDICATERIGHT;
 			break;
 		}
 		break;
@@ -767,7 +767,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		switch (_talkDirection) {
 		case UP:
 			_nBodyOffset.set(-4, -11);
-			headStartPat = PAT_TESTA_UP;
+			headStartPat = PAT_HEAD_UP;
 			bodyStartPat = BPAT_SCAREDUP_START;
 			headLoopPat = PAT_TALK_UP;
 			bodyLoopPat = BPAT_SCAREDUP_LOOP;
@@ -800,14 +800,14 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_SCARED2:
-		_bCorpoDavanti = false;
+		_bBodyFront = false;
 		switch (_talkDirection) {
 		case UP:
 			bodyStartPat = BPAT_STANDUP;
 			bodyLoopPat = BPAT_STANDUP;
 			_nBodyOffset.set(6, 53);
 
-			headStartPat = PAT_TESTA_UP;
+			headStartPat = PAT_HEAD_UP;
 			headLoopPat = PAT_TALK_UP;
 			break;
 
@@ -984,22 +984,22 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		}
 		break;
 
-	case TALK_SCHIFATO:
+	case TALK_DISGUSTED:
 		switch (_talkDirection) {
 		case LEFT:
 		case UP:
 			_nBodyOffset.set(6, 56);
-			headStartPat = PAT_SCHIFATOLEFT_START;
+			headStartPat = PAT_DISGUSTEDLEFT_START;
 			bodyStartPat = BPAT_STANDLEFT;
-			headLoopPat = PAT_SCHIFATOLEFT_LOOP;
+			headLoopPat = PAT_DISGUSTEDLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
 			_nBodyOffset.set(6, 56);
-			headStartPat = PAT_SCHIFATORIGHT_START;
+			headStartPat = PAT_DISGUSTEDRIGHT_START;
 			bodyStartPat = BPAT_STANDRIGHT;
-			headLoopPat = PAT_SCHIFATORIGHT_LOOP;
+			headLoopPat = PAT_DISGUSTEDRIGHT_LOOP;
 			break;
 		}
 		break;
@@ -1071,7 +1071,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 		break;
 
 	case TALK_SCAREDSTATIC:
-		_bCorpoDavanti = false;
+		_bBodyFront = false;
 		switch (_talkDirection) {
 		case DOWN:
 			bodyStartPat = BPAT_STANDDOWN;
@@ -1154,26 +1154,26 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 	switch (_talkDirection) {
 	case UP:
 		finalPat = PAT_STANDUP;
-		headStandPat = PAT_TESTA_UP;
+		headStandPat = PAT_HEAD_UP;
 		break;
 
 	case DOWN:
 		finalPat = PAT_STANDDOWN;
-		headStandPat = PAT_TESTA_DOWN;
+		headStandPat = PAT_HEAD_DOWN;
 		break;
 
 	case LEFT:
 		finalPat = PAT_STANDLEFT;
-		headStandPat = PAT_TESTA_LEFT;
+		headStandPat = PAT_HEAD_LEFT;
 		break;
 
 	case RIGHT:
 		finalPat = PAT_STANDRIGHT;
-		headStandPat = PAT_TESTA_RIGHT;
+		headStandPat = PAT_HEAD_RIGHT;
 		break;
 	}
 
-	if (_bPastorella) {
+	if (_bShepherdess) {
 		mainFreeze();
 		setPattern(finalPat);
 		mainUnfreeze();
@@ -1208,8 +1208,8 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		}
 		break;
 
-	case TALK_CANTA:
-		bodyEndPat = BPAT_CANTALEFT_END;
+	case TALK_SING:
+		bodyEndPat = BPAT_SINGLEFT_END;
 		break;
 
 	case TALK_RIDE:
@@ -1222,16 +1222,16 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		bodyEndPat = 0;
 		break;
 
-	case TALK_SCHIFATO:
+	case TALK_DISGUSTED:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
-			headEndPat = PAT_SCHIFATOLEFT_END;
+			headEndPat = PAT_DISGUSTEDLEFT_END;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			headEndPat = PAT_SCHIFATORIGHT_END;
+			headEndPat = PAT_DISGUSTEDRIGHT_END;
 			break;
 		}
 
@@ -1254,7 +1254,7 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		bodyEndPat = 0;
 		break;
 
-	case TALK_SIINDICA:
+	case TALK_INDICATE:
 		break;
 
 	case TALK_SCARED:
@@ -1527,25 +1527,25 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 	switch (nPat) {
 	case PAT_STANDDOWN:
 		_talkDirection = DOWN;
-		headPat = PAT_TESTA_RIGHT;
+		headPat = PAT_HEAD_RIGHT;
 		break;
 
 	case PAT_TAKELEFT_UP2:
 	case PAT_TAKELEFT_MID2:
 	case PAT_TAKELEFT_DOWN2:
-	case PAT_SIRIALZALEFT:
+	case PAT_GETUPLEFT:
 	case PAT_STANDLEFT:
 		_talkDirection = LEFT;
-		headPat = PAT_TESTA_LEFT;
+		headPat = PAT_HEAD_LEFT;
 		break;
 
 	case PAT_TAKERIGHT_UP2:
 	case PAT_TAKERIGHT_MID2:
 	case PAT_TAKERIGHT_DOWN2:
-	case PAT_SIRIALZARIGHT:
+	case PAT_GETUPRIGHT:
 	case PAT_STANDRIGHT:
 		_talkDirection = RIGHT;
-		headPat = PAT_TESTA_RIGHT;
+		headPat = PAT_HEAD_RIGHT;
 		break;
 
 	case PAT_TAKEUP_UP2:
@@ -1553,11 +1553,11 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 	case PAT_TAKEUP_DOWN2:
 	case PAT_STANDUP:
 		_talkDirection = UP;
-		headPat = PAT_TESTA_LEFT;
+		headPat = PAT_HEAD_LEFT;
 		break;
 	}
 
-	_bCorpoDavanti = true;
+	_bBodyFront = true;
 
 	switch (nTalk) {
 	case TALK_WITHRABBITSTATIC:
-- 
cgit v1.2.3


From 638b06660141677421aa7a342a606b0e4e593389 Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Sat, 16 Jun 2012 11:09:08 +0200
Subject: TONY: Translate some Italian terms, rename enums

---
 engines/tony/tonychar.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 0f16bc45c3..17f046fb92 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -550,7 +550,7 @@ void RMTony::put(int nWhere, int nPart) {
 }
 
 
-bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &bodyStartPat,
+bool RMTony::startTalkCalculate(CharacterTalkType nTalkType, int &headStartPat, int &bodyStartPat,
                                 int &headLoopPat, int &bodyLoopPat) {
 	assert(!_bIsTalking);
 
@@ -1109,7 +1109,7 @@ bool RMTony::startTalkCalculate(TALKTYPE nTalkType, int &headStartPat, int &body
 	return true;
 }
 
-void RMTony::startTalk(CORO_PARAM, TALKTYPE nTalkType) {
+void RMTony::startTalk(CORO_PARAM, CharacterTalkType nTalkType) {
 	CORO_BEGIN_CONTEXT;
 	int headStartPat, bodyStartPat;
 	int headLoopPat, bodyLoopPat;
@@ -1518,7 +1518,7 @@ void RMTony::endTalk(CORO_PARAM) {
 	CORO_END_CODE;
 }
 
-void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat,
+void RMTony::startStaticCalculate(CharacterTalkType nTalk, int &headPat, int &headLoopPat,
                                   int &bodyStartPat, int &bodyLoopPat) {
 	int nPat = getCurPattern();
 
@@ -1725,7 +1725,7 @@ void RMTony::startStaticCalculate(TALKTYPE nTalk, int &headPat, int &headLoopPat
 	}
 }
 
-void RMTony::startStatic(CORO_PARAM, TALKTYPE nTalk) {
+void RMTony::startStatic(CORO_PARAM, CharacterTalkType nTalk) {
 	CORO_BEGIN_CONTEXT;
 	int headPat, headLoopPat;
 	int bodyStartPat, bodyLoopPat;
@@ -1760,7 +1760,7 @@ void RMTony::startStatic(CORO_PARAM, TALKTYPE nTalk) {
 }
 
 
-void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat, int &headEndPat) {
+void RMTony::endStaticCalculate(CharacterTalkType nTalk, int &bodyEndPat, int &finalPat, int &headEndPat) {
 	switch (_talkDirection) {
 	case UP:
 	case LEFT:
@@ -1896,7 +1896,7 @@ void RMTony::endStaticCalculate(TALKTYPE nTalk, int &bodyEndPat, int &finalPat,
 	}
 }
 
-void RMTony::endStatic(CORO_PARAM, TALKTYPE nTalk) {
+void RMTony::endStatic(CORO_PARAM, CharacterTalkType nTalk) {
 	CORO_BEGIN_CONTEXT;
 	int bodyEndPat;
 	int finalPat;
-- 
cgit v1.2.3


From a46b06a587cc0b5e5767b55ba0d56264a8078f0c Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Sun, 17 Jun 2012 19:39:58 +0200
Subject: TONY: Move functions comment to doxygen format

---
 engines/tony/tonychar.cpp | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 17f046fb92..700b69a643 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -34,10 +34,6 @@
 
 namespace Tony {
 
-/****************************************************************************\
-*       Metodi di RMTony
-\****************************************************************************/
-
 bool RMTony::_bAction = false;
 
 void RMTony::initStatics() {
@@ -124,7 +120,7 @@ void RMTony::init(void) {
 
 
 void RMTony::close(void) {
-	// Disalloca @@@ Deallocation of missing item
+	// Deallocation of missing item
 //	_shadow.destroy();
 }
 
@@ -479,7 +475,6 @@ void RMTony::put(int nWhere, int nPart) {
 	if (nPart == 0) {
 		switch (getCurPattern()) {
 		case PAT_STANDDOWN:
-			//assert(0);
 			break;
 
 		case PAT_STANDUP:
@@ -690,7 +685,6 @@ bool RMTony::startTalkCalculate(CharacterTalkType nTalkType, int &headStartPat,
 		}
 		break;
 
-
 	case TALK_SING:
 		_nBodyOffset.set(-10, 25);
 		headStartPat = PAT_HEAD_LEFT;
@@ -744,7 +738,6 @@ bool RMTony::startTalkCalculate(CharacterTalkType nTalkType, int &headStartPat,
 		}
 		break;
 
-
 	case TALK_INDICATE:
 		switch (_talkDirection) {
 		case UP:
@@ -1181,7 +1174,6 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		return false;
 	}
 
-
 	bStatic = false;
 	switch (_nTalkType) {
 	case TALK_NORMAL:
@@ -1759,7 +1751,6 @@ void RMTony::startStatic(CORO_PARAM, CharacterTalkType nTalk) {
 	CORO_END_CODE;
 }
 
-
 void RMTony::endStaticCalculate(CharacterTalkType nTalk, int &bodyEndPat, int &finalPat, int &headEndPat) {
 	switch (_talkDirection) {
 	case UP:
-- 
cgit v1.2.3


From e8a6f61f8815fcf36e7a43383695c74b8925993f Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Mon, 18 Jun 2012 08:24:33 +0200
Subject: TONY: Remove useless void in function declaration

---
 engines/tony/tonychar.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 700b69a643..cd5bbdad8b 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -84,7 +84,7 @@ RMGfxSourceBuffer *RMTony::newItemSpriteBuffer(int dimx, int dimy, bool bPreRLE)
 	return spr;
 }
 
-void RMTony::init(void) {
+void RMTony::init() {
 	RMRes tony(0);
 	RMRes body(9999);
 	RMDataStream ds;
@@ -119,7 +119,7 @@ void RMTony::init(void) {
 }
 
 
-void RMTony::close(void) {
+void RMTony::close() {
 	// Deallocation of missing item
 //	_shadow.destroy();
 }
@@ -156,7 +156,7 @@ void RMTony::doFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
 	CORO_END_CODE;
 }
 
-void RMTony::show(void) {
+void RMTony::show() {
 	_bShow = true;
 	_bShowShadow = true;
 }
@@ -334,7 +334,7 @@ void RMTony::stop(CORO_PARAM) {
 }
 
 
-int RMTony::getCurPattern(void) {
+int RMTony::getCurPattern() {
 	int nPatt = RMCharacter::getCurPattern();
 
 	if (!_bShepherdess)
-- 
cgit v1.2.3


From 85150232f036d1dead6a0807bac7b10c5ba923e1 Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Thu, 21 Jun 2012 00:20:16 +0200
Subject: TONY: Some more renaming (thanks Hkz)

---
 engines/tony/tonychar.cpp | 78 +++++++++++++++++++++++------------------------
 1 file changed, 39 insertions(+), 39 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index cd5bbdad8b..74d9f20181 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -648,39 +648,39 @@ bool RMTony::startTalkCalculate(CharacterTalkType nTalkType, int &headStartPat,
 		}
 		break;
 
-	case TALK_FIANCHI:
+	case TALK_HIPS:
 		_bBodyFront = false;
 		switch (_talkDirection) {
 		case UP:
 			_nBodyOffset.set(2, 42);
 			headStartPat = PAT_HEAD_UP;
-			bodyStartPat = BPAT_FIANCHIUP_START;
+			bodyStartPat = BPAT_HIPSUP_START;
 			headLoopPat = PAT_TALK_UP;
-			bodyLoopPat = BPAT_FIANCHIUP_LOOP;
+			bodyLoopPat = BPAT_HIPSUP_LOOP;
 			break;
 
 		case DOWN:
 			_nBodyOffset.set(2, 48);
 			headStartPat = PAT_HEAD_DOWN;
-			bodyStartPat = BPAT_FIANCHIDOWN_START;
+			bodyStartPat = BPAT_HIPSDOWN_START;
 			headLoopPat = PAT_TALK_DOWN;
-			bodyLoopPat = BPAT_FIANCHIDOWN_LOOP;
+			bodyLoopPat = BPAT_HIPSDOWN_LOOP;
 			break;
 
 		case LEFT:
 			_nBodyOffset.set(-3, 53);
 			headStartPat = PAT_HEAD_LEFT;
-			bodyStartPat = BPAT_FIANCHILEFT_START;
+			bodyStartPat = BPAT_HIPSLEFT_START;
 			headLoopPat = PAT_TALK_LEFT;
-			bodyLoopPat = BPAT_FIANCHILEFT_LOOP;
+			bodyLoopPat = BPAT_HIPSLEFT_LOOP;
 			break;
 
 		case RIGHT:
 			_nBodyOffset.set(2, 53);
 			headStartPat = PAT_HEAD_RIGHT;
-			bodyStartPat = BPAT_FIANCHIRIGHT_START;
+			bodyStartPat = BPAT_HIPSRIGHT_START;
 			headLoopPat = PAT_TALK_RIGHT;
-			bodyLoopPat = BPAT_FIANCHIRIGHT_LOOP;
+			bodyLoopPat = BPAT_HIPSRIGHT_LOOP;
 			break;
 		}
 		break;
@@ -693,47 +693,47 @@ bool RMTony::startTalkCalculate(CharacterTalkType nTalkType, int &headStartPat,
 		bodyLoopPat = BPAT_SINGLEFT_LOOP;
 		break;
 
-	case TALK_RIDE:
+	case TALK_LAUGH:
 		_bBodyFront = false;
 		switch (_talkDirection) {
 		case UP:
 		case DOWN:
 		case LEFT:
 			_nBodyOffset.set(6, 56);
-			headStartPat = PAT_RIDELEFT_START;
+			headStartPat = PAT_LAUGHLEFT_START;
 			bodyStartPat = BPAT_STANDLEFT;
-			headLoopPat = PAT_RIDELEFT_LOOP;
-			bodyLoopPat = BPAT_RIDELEFT;
+			headLoopPat = PAT_LAUGHLEFT_LOOP;
+			bodyLoopPat = BPAT_LAUGHLEFT;
 			break;
 
 		case RIGHT:
 			_nBodyOffset.set(6, 56);
-			headStartPat = PAT_RIDERIGHT_START;
+			headStartPat = PAT_LAUGHRIGHT_START;
 			bodyStartPat = BPAT_STANDRIGHT;
-			headLoopPat = PAT_RIDERIGHT_LOOP;
-			bodyLoopPat = BPAT_RIDERIGHT;
+			headLoopPat = PAT_LAUGHRIGHT_LOOP;
+			bodyLoopPat = BPAT_LAUGHRIGHT;
 			break;
 		}
 		break;
 
-	case TALK_RIDE2:
+	case TALK_LAUGH2:
 		_bBodyFront = false;
 		switch (_talkDirection) {
 		case UP:
 		case DOWN:
 		case LEFT:
 			_nBodyOffset.set(6, 56);
-			headStartPat = PAT_RIDELEFT_START;
+			headStartPat = PAT_LAUGHLEFT_START;
 			bodyStartPat = BPAT_STANDLEFT;
-			headLoopPat = PAT_RIDELEFT_LOOP;
+			headLoopPat = PAT_LAUGHLEFT_LOOP;
 			break;
 
 		case RIGHT:
 			_nBodyOffset.set(6, 56);
-			headStartPat = PAT_RIDERIGHT_START;
+			headStartPat = PAT_LAUGHRIGHT_START;
 			bodyStartPat = BPAT_STANDRIGHT;
-			headLoopPat = PAT_RIDERIGHT_LOOP;
-			bodyLoopPat = BPAT_RIDERIGHT;
+			headLoopPat = PAT_LAUGHRIGHT_LOOP;
+			bodyLoopPat = BPAT_LAUGHRIGHT;
 			break;
 		}
 		break;
@@ -997,22 +997,22 @@ bool RMTony::startTalkCalculate(CharacterTalkType nTalkType, int &headStartPat,
 		}
 		break;
 
-	case TALK_NAAH:
+	case TALK_SARCASTIC:
 		switch (_talkDirection) {
 		case LEFT:
 		case UP:
 			_nBodyOffset.set(6, 56);
-			headStartPat = PAT_NAAHLEFT_START;
+			headStartPat = PAT_SARCASTICLEFT_START;
 			bodyStartPat = BPAT_STANDLEFT;
-			headLoopPat = PAT_NAAHLEFT_LOOP;
+			headLoopPat = PAT_SARCASTICLEFT_LOOP;
 			break;
 
 		case DOWN:
 		case RIGHT:
 			_nBodyOffset.set(6, 56);
-			headStartPat = PAT_NAAHRIGHT_START;
+			headStartPat = PAT_SARCASTICRIGHT_START;
 			bodyStartPat = BPAT_STANDRIGHT;
-			headLoopPat = PAT_NAAHRIGHT_LOOP;
+			headLoopPat = PAT_SARCASTICRIGHT_LOOP;
 			break;
 		}
 		break;
@@ -1180,22 +1180,22 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		bodyEndPat = 0;
 		break;
 
-	case TALK_FIANCHI:
+	case TALK_HIPS:
 		switch (_talkDirection) {
 		case UP:
-			bodyEndPat = BPAT_FIANCHIUP_END;
+			bodyEndPat = BPAT_HIPSUP_END;
 			break;
 
 		case DOWN:
-			bodyEndPat = BPAT_FIANCHIDOWN_END;
+			bodyEndPat = BPAT_HIPSDOWN_END;
 			break;
 
 		case LEFT:
-			bodyEndPat = BPAT_FIANCHILEFT_END;
+			bodyEndPat = BPAT_HIPSLEFT_END;
 			break;
 
 		case RIGHT:
-			bodyEndPat = BPAT_FIANCHIRIGHT_END;
+			bodyEndPat = BPAT_HIPSRIGHT_END;
 			break;
 		}
 		break;
@@ -1204,12 +1204,12 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		bodyEndPat = BPAT_SINGLEFT_END;
 		break;
 
-	case TALK_RIDE:
-	case TALK_RIDE2:
+	case TALK_LAUGH:
+	case TALK_LAUGH2:
 		if (_talkDirection == LEFT)
-			headEndPat = PAT_RIDELEFT_END;
+			headEndPat = PAT_LAUGHLEFT_END;
 		else if (_talkDirection == RIGHT)
-			headEndPat = PAT_RIDERIGHT_END;
+			headEndPat = PAT_LAUGHRIGHT_END;
 
 		bodyEndPat = 0;
 		break;
@@ -1230,16 +1230,16 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 		bodyEndPat = 0;
 		break;
 
-	case TALK_NAAH:
+	case TALK_SARCASTIC:
 		switch (_talkDirection) {
 		case UP:
 		case LEFT:
-			headEndPat = PAT_NAAHLEFT_END;
+			headEndPat = PAT_SARCASTICLEFT_END;
 			break;
 
 		case DOWN:
 		case RIGHT:
-			headEndPat = PAT_NAAHRIGHT_END;
+			headEndPat = PAT_SARCASTICRIGHT_END;
 			break;
 		}
 
-- 
cgit v1.2.3


From c3407390013b1e1826bdb31979a50f5e8a957f04 Mon Sep 17 00:00:00 2001
From: Alyssa Milburn
Date: Wed, 22 Aug 2012 14:00:46 +0200
Subject: TONY: Replace _vm with g_vm.

---
 engines/tony/tonychar.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 74d9f20181..8593ece480 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -115,7 +115,7 @@ void RMTony::init() {
 	ds.close();
 	_body.setPattern(0);
 
-	_nTimeLastStep = _vm->getTime();
+	_nTimeLastStep = g_vm->getTime();
 }
 
 
@@ -137,7 +137,7 @@ void RMTony::doFrame(CORO_PARAM, RMGfxTargetBuffer *bigBuf, int curLoc) {
 	setSpeed(GLOBALS._nCfgTonySpeed);
 
 	// Runs the normal character movement
-	_ctx->time = _vm->getTime();
+	_ctx->time = g_vm->getTime();
 
 	do {
 		_nTimeLastStep += (1000 / 40);
-- 
cgit v1.2.3


From 35fd91793b34b72624a89f2a76f45bc8e59020d2 Mon Sep 17 00:00:00 2001
From: Alyssa Milburn
Date: Tue, 28 Aug 2012 14:26:00 +0200
Subject: TONY: Get rid of RMDataStream.

---
 engines/tony/tonychar.cpp | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 8593ece480..9caa10bd46 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -87,7 +87,6 @@ RMGfxSourceBuffer *RMTony::newItemSpriteBuffer(int dimx, int dimy, bool bPreRLE)
 void RMTony::init() {
 	RMRes tony(0);
 	RMRes body(9999);
-	RMDataStream ds;
 
 	// Tony is shown by default
 	_bShow = _bShowShadow = true;
@@ -101,18 +100,18 @@ void RMTony::init() {
 	_bIsStaticTalk = false;
 
 	// Opens the buffer
-	ds.openBuffer(tony);
+	Common::SeekableReadStream *ds = tony.getReadStream();
 
 	// Reads his details from the stream
-	readFromStream(ds, true);
+	readFromStream(*ds, true);
 
 	// Closes the buffer
-	ds.close();
+	delete ds;
 
 	// Reads Tony's body
-	ds.openBuffer(body);
-	_body.readFromStream(ds, true);
-	ds.close();
+	ds = body.getReadStream();
+	_body.readFromStream(*ds, true);
+	delete ds;
 	_body.setPattern(0);
 
 	_nTimeLastStep = g_vm->getTime();
-- 
cgit v1.2.3


From 3c986af9ce531f4d9cab889b196991be14cb88f6 Mon Sep 17 00:00:00 2001
From: Alyssa Milburn
Date: Tue, 28 Aug 2012 22:10:10 +0200
Subject: TONY: Remove unnecessary mainloop mutex.

Also, all the related freeze functions/members.
---
 engines/tony/tonychar.cpp | 34 ----------------------------------
 1 file changed, 34 deletions(-)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index 9caa10bd46..c80203fae2 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -589,7 +589,6 @@ bool RMTony::startTalkCalculate(CharacterTalkType nTalkType, int &headStartPat,
 
 	if (_bShepherdess) {
 		// Talking whilst a shepherdess
-		mainFreeze();
 		switch (_talkDirection) {
 		case UP:
 			setPattern(PAT_PAST_TALKUP);
@@ -607,7 +606,6 @@ bool RMTony::startTalkCalculate(CharacterTalkType nTalkType, int &headStartPat,
 			setPattern(PAT_PAST_TALKRIGHT);
 			break;
 		}
-		mainUnfreeze();
 		return false;
 	}
 
@@ -1118,10 +1116,8 @@ void RMTony::startTalk(CORO_PARAM, CharacterTalkType nTalkType) {
 
 	// Perform the set pattern
 	if (_ctx->headStartPat != 0 || _ctx->bodyStartPat != 0) {
-		mainFreeze();
 		setPattern(_ctx->headStartPat);
 		_body.setPattern(_ctx->bodyStartPat);
-		mainUnfreeze();
 
 		if (_ctx->bodyStartPat != 0)
 			CORO_INVOKE_0(_body.waitForEndPattern);
@@ -1129,11 +1125,9 @@ void RMTony::startTalk(CORO_PARAM, CharacterTalkType nTalkType) {
 			CORO_INVOKE_0(waitForEndPattern);
 	}
 
-	mainFreeze();
 	setPattern(_ctx->headLoopPat);
 	if (_ctx->bodyLoopPat)
 		_body.setPattern(_ctx->bodyLoopPat);
-	mainUnfreeze();
 
 	CORO_END_CODE;
 }
@@ -1166,9 +1160,7 @@ bool RMTony::endTalkCalculate(int &headStandPat, int &headEndPat, int &bodyEndPa
 	}
 
 	if (_bShepherdess) {
-		mainFreeze();
 		setPattern(finalPat);
-		mainUnfreeze();
 		_bIsTalking = false;
 		return false;
 	}
@@ -1437,7 +1429,6 @@ void RMTony::endTalk(CORO_PARAM) {
 	// Handles the end of an animated and static, leaving everything unchanged
 	if (_bIsStaticTalk) {
 		if (_nTalkType == TALK_WITHBEARDSTATIC) {
-			mainFreeze();
 			setPattern(0);
 			if (_talkDirection == UP || _talkDirection == LEFT) {
 				_body.setPattern(BPAT_WITHBEARDLEFT_STATIC);
@@ -1446,11 +1437,8 @@ void RMTony::endTalk(CORO_PARAM) {
 				_body.setPattern(BPAT_WITHBEARDRIGHT_STATIC);
 				_nBodyOffset.set(-26, -14);
 			}
-			mainUnfreeze();
 		} else {
-			mainFreeze();
 			setPattern(_ctx->headStandPat);
-			mainUnfreeze();
 
 			CORO_INVOKE_0(_body.waitForEndPattern);
 		}
@@ -1461,36 +1449,26 @@ void RMTony::endTalk(CORO_PARAM) {
 
 	// Set the pattern
 	if (_ctx->headEndPat != 0 && _ctx->bodyEndPat != 0) {
-		mainFreeze();
 		setPattern(_ctx->headEndPat);
-		mainUnfreeze();
 
 		CORO_INVOKE_0(_body.waitForEndPattern);
 
-		mainFreeze();
 		_body.setPattern(_ctx->bodyEndPat);
-		mainUnfreeze();
 
 		CORO_INVOKE_0(waitForEndPattern);
 		CORO_INVOKE_0(_body.waitForEndPattern);
 	} else if (_ctx->bodyEndPat != 0) {
-		mainFreeze();
 		setPattern(_ctx->headStandPat);
-		mainUnfreeze();
 
 		CORO_INVOKE_0(_body.waitForEndPattern);
 
-		mainFreeze();
 		_body.setPattern(_ctx->bodyEndPat);
-		mainUnfreeze();
 
 		CORO_INVOKE_0(_body.waitForEndPattern);
 	} else if (_ctx->headEndPat != 0) {
 		CORO_INVOKE_0(_body.waitForEndPattern);
 
-		mainFreeze();
 		setPattern(_ctx->headEndPat);
-		mainUnfreeze();
 
 		CORO_INVOKE_0(waitForEndPattern);
 	} else {
@@ -1498,10 +1476,8 @@ void RMTony::endTalk(CORO_PARAM) {
 	}
 
 	if (_ctx->finalPat != 0) {
-		mainFreeze();
 		_body.setPattern(0);
 		setPattern(_ctx->finalPat);
-		mainUnfreeze();
 	}
 
 	_bIsTalking = false;
@@ -1733,19 +1709,15 @@ void RMTony::startStatic(CORO_PARAM, CharacterTalkType nTalk) {
 	// e vai con i pattern
 	_bIsStaticTalk = true;
 
-	mainFreeze();
 	setPattern(_ctx->headPat);
 	_body.setPattern(_ctx->bodyStartPat);
-	mainUnfreeze();
 
 	CORO_INVOKE_0(_body.waitForEndPattern);
 	CORO_INVOKE_0(waitForEndPattern);
 
-	mainFreeze();
 	if (_ctx->headLoopPat != -1)
 		setPattern(_ctx->headLoopPat);
 	_body.setPattern(_ctx->bodyLoopPat);
-	mainUnfreeze();
 
 	CORO_END_CODE;
 }
@@ -1902,24 +1874,18 @@ void RMTony::endStatic(CORO_PARAM, CharacterTalkType nTalk) {
 	endStaticCalculate(nTalk, _ctx->bodyEndPat, _ctx->finalPat, _ctx->headEndPat);
 
 	if (_ctx->headEndPat != 0) {
-		mainFreeze();
 		setPattern(_ctx->headEndPat);
-		mainUnfreeze();
 
 		CORO_INVOKE_0(waitForEndPattern);
 	} else {
 		// Play please
-		mainFreeze();
 		_body.setPattern(_ctx->bodyEndPat);
-		mainUnfreeze();
 
 		CORO_INVOKE_0(_body.waitForEndPattern);
 	}
 
-	mainFreeze();
 	setPattern(_ctx->finalPat);
 	_body.setPattern(0);
-	mainUnfreeze();
 
 	_bIsStaticTalk = false;
 
-- 
cgit v1.2.3


From 8c753c96a097c3b6e67b061470606278a0d8f102 Mon Sep 17 00:00:00 2001
From: Strangerke
Date: Sat, 1 Sep 2012 01:05:22 +0200
Subject: TONY: Move some functions from .h to .cpp files

---
 engines/tony/tonychar.cpp | 50 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

(limited to 'engines/tony/tonychar.cpp')

diff --git a/engines/tony/tonychar.cpp b/engines/tony/tonychar.cpp
index c80203fae2..c7fa1e4a7b 100644
--- a/engines/tony/tonychar.cpp
+++ b/engines/tony/tonychar.cpp
@@ -1892,4 +1892,54 @@ void RMTony::endStatic(CORO_PARAM, CharacterTalkType nTalk) {
 	CORO_END_CODE;
 }
 
+/**
+ * Waits until the end of a pattern
+ */
+void RMTony::waitForEndPattern(CORO_PARAM, uint32 hCustomSkip) {
+	RMCharacter::waitForEndPattern(coroParam, hCustomSkip);
+}
+
+/**
+ * Check if currently in an action
+ */
+bool RMTony::inAction() {
+	return (_bActionPending && _action != 0) | _bAction;
+}
+
+/**
+ * Check if there needs to be an update for scrolling movement
+ */
+bool RMTony::mustUpdateScrolling() {
+	return ((!inAction()) || (isMoving()));
+}
+
+/**
+ * Returns Tony's position
+ */
+RMPoint RMTony::position() {
+	return _pos;
+}
+
+/**
+ * Set the scrolling position
+ */
+void RMTony::setScrollPosition(const RMPoint &pt) {
+	RMCharacter::setScrollPosition(pt);
+}
+
+/**
+ * Tony disguises himself!
+ */
+void RMTony::setShepherdess(bool bIsPast) {
+	_bShepherdess = bIsPast;
+}
+
+int RMTony::getShepherdess() {
+	return _bShepherdess;
+}
+
+void RMTony::playSfx(int nSfx) {
+	RMItem::playSfx(nSfx);
+}
+
 } // End of namespace Tony
-- 
cgit v1.2.3