TONY: Cleanup of GfxEngine, and added RMTony class methods

5 files changed, 1917 insertions, 944 deletions

diff --git a/engines/tony/game.cpp b/engines/tony/game.cpp
index acafbbf7c8..109eefab24 100644
--- a/engines/tony/game.cpp
+++ b/engines/tony/game.cpp
@@ -235,948 +235,4 @@ void RMOptionButton::AddToList(RMGfxTargetBuffer &bigBuf) {
 		bigBuf.AddPrim(new RMGfxPrimitive(this, m_rect));
 }
 
-
-/****************************************************************************\
-*       Metodi di RMGfxEngine
-\****************************************************************************/
-
-bool bIdleExited;
-
-void ExitAllIdles(int nCurLoc) {
-	// Chiude le idle
-	bSkipSfxNoLoop = true;
-	mpalEndIdlePoll(nCurLoc);
-	bIdleExited = true;
-	bSkipSfxNoLoop = false;
-	ExitThread(0);
-}
-
-
-RMGfxEngine::RMGfxEngine() {
-	// Crea il big buffer dove verranno disegnati i frame
-	m_bigBuf.Create(RM_BBX, RM_BBY, 16);
-	m_bigBuf.OffsetY(RM_SKIPY);
-}
-
-RMGfxEngine::~RMGfxEngine() {
-	// Chiude il buffer
-	m_bigBuf.Destroy();
-}
-
-void RMGfxEngine::OpenOptionScreen(int type) {
-	bool bRes = false;
-
-	switch (type) {
-	case 0:
-		bRes = m_opt.Init(m_bigBuf);
-		break;
-	case 1:
-		bRes = m_opt.InitLoadMenuOnly(m_bigBuf, true);
-		break;
-	case 2:
-		bRes = m_opt.InitNoLoadSave(m_bigBuf);
-		break;
-	case 3:
-		bRes = m_opt.InitLoadMenuOnly(m_bigBuf, false);
-		break;
-	case 4:
-		bRes = m_opt.InitSaveMenuOnly(m_bigBuf, false);
-		break;
-	}
-
-	if (bRes) {
-		_vm->PauseSound(true);
-
-		DisableInput();
-		m_inv.EndCombine();
-		m_curActionObj=0;
-		m_curAction=TA_GOTO;
-		m_point.SetAction(m_curAction);
-		m_point.SetSpecialPointer(RMPointer::PTR_NONE);
-		m_point.SetCustomPointer(NULL);
-		EnableMouse();
-		_vm->GrabThumbnail();
-		
-		// Esce la IDLE onde evitare la morte prematura in caricamento
-		m_bMustEnterMenu = true;							
-		if (type == 1 || type == 2) {
-			bIdleExited = true;
-		} else {
-			m_tony.StopNoAction();
-
-			uint32 id;
-			bIdleExited = false;
-			CreateThread(NULL, 10240, (LPTHREAD_START_ROUTINE)ExitAllIdles, (void *)m_nCurLoc, 0, &id);
-		}
-	}
-}
-
-void RMGfxEngine::DoFrame(bool bDrawLocation) {
-	g_system->lockMutex(csMainLoop);
-	
-	// Poll dei dispositivi di input
-	m_input.Poll();
-
-	if (m_bMustEnterMenu && bIdleExited) {
-		m_bOption = true;
-		m_bMustEnterMenu = false;
-		bIdleExited = false;
-	}
-	
-  if (m_bOption) {
-		m_opt.DoFrame(&m_input);
-		m_bOption = !m_opt.IsClosing();
-		if (!m_bOption) {
-			DisableMouse();
-			EnableInput();
-			mpalStartIdlePoll(m_nCurLoc);
-			_vm->PauseSound(false);
-		}
-	}
-
-	if (bDrawLocation && m_bLocationLoaded) {
-		// Locazione e oggetti
-		m_loc.DoFrame(&m_bigBuf);
-
-		// Controlla gli input del mouse
-		if (m_bInput && !m_tony.InAction()) {
-			// Se siamo sull'inventario, ่ lui che controlla tutti gli input
-			if (m_inv.HaveFocus(m_input.MousePos()) && !m_inter.Active()) {
-				// CLICK SINISTRO
-				// **************
-				if (m_input.MouseLeftClicked()/* && m_itemName.IsItemSelected()*/) {
-					// Left click attiva il combine, se siamo su un oggetto
-					if (m_inv.LeftClick(m_input.MousePos(),m_curActionObj)) {
-						m_curAction=TA_COMBINE;
-						m_point.SetAction(m_curAction);
-					}
-				}
-				else			
-
-				// CLICK DESTRO
-				// ************
-				if (m_input.MouseRightClicked()) {
-				  if(m_itemName.IsItemSelected()) {
-						m_curActionObj=0;
-						m_inv.RightClick(m_input.MousePos());
-					} else
-						m_inv.RightClick(m_input.MousePos());
-				} else
-
-				// RILASCIO DESTRO
-				// ***************
-				if (m_input.MouseRightReleased()) {
-					if (m_inv.RightRelease(m_input.MousePos(), m_curAction)) {
-						m_tony.MoveAndDoAction(m_itemName.GetHotspot(), m_itemName.GetSelectedItem(), m_curAction);
-
-						m_curAction=TA_GOTO;
-						m_point.SetAction(m_curAction);
-					}
-				}
-			} else {
-				// Menu Opzioni
-				// ************
-				if (m_bGUIOption) {
-					if (!m_tony.InAction() && m_bInput) {
-						if ((m_input.MouseLeftClicked() && m_input.MousePos().x < 3 && m_input.MousePos().y < 3)) {
-							OpenOptionScreen(0);
-							goto SKIPCLICKSINISTRO;
-						} else if ((GetAsyncKeyState(Common::KEYCODE_ESCAPE) & 0x8001) == 0x8001)
-							OpenOptionScreen(0);
-						else if (!_vm->getIsDemo()) {
-							if ((GetAsyncKeyState(Common::KEYCODE_F3) & 0x8001)==0x8001)
-								OpenOptionScreen(3);
-							else if ((GetAsyncKeyState(Common::KEYCODE_F2) & 0x8001)==0x8001)
-								OpenOptionScreen(4);
-						}
-					}
-				}
-
-				// CLICK SINISTRO
-				// **************
-				if (m_input.MouseLeftClicked() && !m_inter.Active()) {
-					// Se clicko dentro un oggetto, esegui l'azione
-					//if (m_itemName.IsItemSelected())
-					{
-						if (m_curAction!=TA_COMBINE)
-							m_tony.MoveAndDoAction(m_itemName.GetHotspot(), m_itemName.GetSelectedItem(), m_point.CurAction());
-						else if (m_itemName.GetSelectedItem() != NULL)
-							m_tony.MoveAndDoAction(m_itemName.GetHotspot(), m_itemName.GetSelectedItem(), TA_COMBINE, m_curActionObj);
-					}
-					
-					if (m_curAction==TA_COMBINE) {
-						m_inv.EndCombine();
-						m_point.SetSpecialPointer(RMPointer::PTR_NONE);
-					}
-
-					m_curAction=TA_GOTO;
-					m_point.SetAction(m_curAction);
-				}
-
-SKIPCLICKSINISTRO:
-				// CLICK DESTRO
-				// ************
-				if (m_curAction == TA_COMBINE) {
-					// Durante il combine, lo annulla.
-					if (m_input.MouseRightClicked()) {
-						m_inv.EndCombine();
-						m_curActionObj = 0;
-						m_curAction = TA_GOTO;
-						m_point.SetAction(m_curAction);
-						m_point.SetSpecialPointer(RMPointer::PTR_NONE);
-					}
-				} else if (m_input.MouseRightClicked() && m_itemName.IsItemSelected() && m_point.GetSpecialPointer() == RMPointer::PTR_NONE) {
-					if (m_bGUIInterface) {
-						// Prima di aprire l'interfaccia, rimette GOTO
-						m_curAction = TA_GOTO;
-						m_curActionObj = 0;
-						m_point.SetAction(m_curAction);
-						m_inter.Clicked(m_input.MousePos());
-					}
-				}
-				
-
-				// RILASCIO DESTRO
-				// ***************
-				if (m_input.MouseRightReleased()) {
-					if (m_bGUIInterface) {
-						if (m_inter.Released(m_input.MousePos(), m_curAction)) {
-							m_point.SetAction(m_curAction);
-							m_tony.MoveAndDoAction(m_itemName.GetHotspot(), m_itemName.GetSelectedItem(), m_curAction);
-
-							m_curAction=TA_GOTO;
-							m_point.SetAction(m_curAction);
-						}
-					}
-				}
-			}
-
-			// Aggiorna il nome sotto il puntatore del mouse
-			m_itemName.SetMouseCoord(m_input.MousePos());
-			if (!m_inter.Active() && !m_inv.MiniActive())
-				m_itemName.DoFrame(m_bigBuf, m_loc, m_point, m_inv);	
-		}
-
-		// Inventario & interfaccia
-		m_inter.DoFrame(m_bigBuf, m_input.MousePos());
-		m_inv.DoFrame(m_bigBuf, m_point, m_input.MousePos(), (!m_tony.InAction() && !m_inter.Active() && m_bGUIInventory));
-	}
-
-	// Anima Tony
-	m_tony.DoFrame(&m_bigBuf, m_nCurLoc);
-	
-	// Aggiorna lo scrolling per tenere Tony dentro lo schermo
-	if (m_tony.MustUpdateScrolling() && m_bLocationLoaded) {
-		RMPoint showThis=m_tony.Position();
-		showThis.y -= 60;
-		m_loc.UpdateScrolling(showThis);
-	}
-
-	if (m_bLocationLoaded)
-		m_tony.SetScrollPosition(m_loc.ScrollPosition());
-
-	if ((!m_tony.InAction() && m_bInput) || m_bAlwaysDrawMouse) {
-		m_point.SetCoord(m_input.MousePos());
-		m_point.DoFrame(&m_bigBuf);
-	}
-
-	// **********************
-	// Disegna la lista di OT
-	// **********************
-	m_bigBuf.DrawOT();
-
-#define FSTEP (480/32)
-
-	// Wipe
-	if (m_bWiping)
-	{
-		switch (m_nWipeType) {
-		case 1:
-			if (!(m_rcWipeEllipse.bottom-m_rcWipeEllipse.top>=FSTEP*2)) {
-				SetEvent(m_hWipeEvent);
-				m_nWipeType=3;
-				break;
-			}
-			
-			m_rcWipeEllipse.top+=FSTEP;
-			m_rcWipeEllipse.left+=FSTEP;
-			m_rcWipeEllipse.right-=FSTEP;
-			m_rcWipeEllipse.bottom-=FSTEP;
-			break;
-
-		case 2:
-			if (!(m_rcWipeEllipse.bottom-m_rcWipeEllipse.top<480-FSTEP)) {
-				SetEvent(m_hWipeEvent);
-				m_nWipeType=3;
-				break;
-			}
-
-			m_rcWipeEllipse.top-=FSTEP;
-			m_rcWipeEllipse.left-=FSTEP;
-			m_rcWipeEllipse.right+=FSTEP;
-			m_rcWipeEllipse.bottom+=FSTEP;
-			break;
-		}
-	}
-
-	g_system->unlockMutex(csMainLoop);
-}
-
-
-void RMGfxEngine::InitCustomDll(void) {
-	SetupGlobalVars(&m_tony, &m_point, &_vm->_theBoxes, &m_loc, &m_inv, &m_input);
-}
-
-void RMGfxEngine::ItemIrq(uint32 dwItem, int nPattern, int nStatus) {
-	static RMGfxEngine *This = NULL;
-	RMItem *item;
-
-	// Inizializzazione!
-	if ((int)dwItem == -1)
-	{
-		This=(RMGfxEngine*)nPattern;
-		return;
-	}
-
-	if (This->m_bLocationLoaded) {
-		item = This->m_loc.GetItemFromCode(dwItem);
-		if (item != NULL) {
-			if (nPattern != -1) {
-				if (bPatIrqFreeze)
-					MainFreeze();
-				item->SetPattern(nPattern, true);
-				if (bPatIrqFreeze)
-					MainUnfreeze();
-			}
-			if (nStatus!=-1)
-				item->SetStatus(nStatus);
-		}
-	}
-}
-
-/*
-	// WINBUG: This is a special case for the file open/save dialog,
-	//  which sometimes pumps while it is coming up but before it has
-	//  disabled the main window.
-	HWND hWndFocus = ::GetFocus();
-	bool bEnableParent = false;
-	m_ofn.hwndOwner = PreModal();
-	AfxUnhookWindowCreate();
-	if (m_ofn.hwndOwner != NULL && ::IsWindowEnabled(m_ofn.hwndOwner))
-	{
-		bEnableParent = true;
-		::EnableWindow(m_ofn.hwndOwner, false);
-	}
-
-	_AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
-	assert(pThreadState->m_pAlternateWndInit == NULL);
-
-	if (m_ofn.Flags & OFN_EXPLORER)
-		pThreadState->m_pAlternateWndInit = this;
-	else
-		AfxHookWindowCreate(this);
-
-	int nResult;
-	if (m_bOpenFileDialog)
-		nResult = ::GetOpenFileName(&m_ofn);
-	else
-		nResult = ::GetSaveFileName(&m_ofn);
-
-	if (nResult)
-		assert(pThreadState->m_pAlternateWndInit == NULL);
-	pThreadState->m_pAlternateWndInit = NULL;
-
-	// WINBUG: Second part of special case for file open/save dialog.
-	if (bEnableParent)
-		::EnableWindow(m_ofn.hwndOwner, true);
-	if (::IsWindow(hWndFocus))
-		::SetFocus(hWndFocus);
-*/
-
-
-void RMGfxEngine::SelectLocation(RMPoint ptTonyStart, RMPoint start) {
-#if 0
-	OPENFILENAME ofn;
-  char lpszFileName[512];
-
-	// @@@ Con TonyStart=-1,-1 allora usa la posizione scritta nella locazione
-
-  // Sceglie la locazione
-	ZeroMemory(lpszFileName,512);
-	ZeroMemory(&ofn,sizeof(ofn));
-  ofn.lStructSize=sizeof(ofn);
-  ofn.hwndOwner=NULL;
-  ofn.lpstrFilter="Locazione (*.LOC)\0*.LOC\0Locazione ottimizzata (*.LOX)\0*.LOX\0Tutti i files (*.*)\0*.*\0";
-  ofn.lpstrCustomFilter=NULL;
-  ofn.nFilterIndex=1;
-  ofn.lpstrFile=lpszFileName;
-  ofn.nMaxFile=512;
-  ofn.lpstrInitialDir=NULL;
-  ofn.lpstrTitle="Load Location";
-  ofn.Flags=OFN_FILEMUSTEXIST|OFN_HIDEREADONLY|OFN_PATHMUSTEXIST;
-
-  if (!GetOpenFileName(&ofn))
-		assert(0);
-
-	// Carica la locazione
-	m_loc.Load(lpszFileName);
-	m_bLocationLoaded = true;
-	m_nCurLoc=m_loc.TEMPGetNumLoc();
-	
-	if (ptTonyStart.x==-1 && ptTonyStart.y==-1)
-		InitForNewLocation(m_loc.TEMPGetNumLoc(),m_loc.TEMPGetTonyStart(),RMPoint(-1,-1));
-	else
-		InitForNewLocation(m_loc.TEMPGetNumLoc(),ptTonyStart,start);
-#endif
-}
-
-void RMGfxEngine::InitForNewLocation(int nLoc, RMPoint ptTonyStart, RMPoint start) {
-	if (start.x == -1 || start.y == -1) {
-		start.x = ptTonyStart.x-RM_SX/2;
-		start.y = ptTonyStart.y-RM_SY/2;
-	}
-
-	m_loc.SetScrollPosition(start);
-	
-	if (ptTonyStart.x==0 && ptTonyStart.y==0) {
-	} else {
-		m_tony.SetPosition(ptTonyStart, nLoc);
-		m_tony.SetScrollPosition(start);
-	}
-
-	m_curAction=TA_GOTO;
-	m_point.SetCustomPointer(NULL);
-	m_point.SetSpecialPointer(RMPointer::PTR_NONE);
-	m_point.SetAction(m_curAction);
-	m_inter.Reset();
-	m_inv.Reset();
-
-	mpalStartIdlePoll(m_nCurLoc);
-}
-
-HANDLE RMGfxEngine::LoadLocation(int nLoc, RMPoint ptTonyStart, RMPoint start) {
-	bool bLoaded;
-	int i;
-
-	m_nCurLoc=nLoc;
-
-	bLoaded = false;
-	for (i = 0; i < 5; i++) {
-		// Retry sul loading della locazione
-		RMRes res(m_nCurLoc);
-		if (!res.IsValid())
-			continue;
-#if 0
-		// codice per dumpare una locazione in caso serva una modifica
-		if (nLoc == 106)
-		{
-			FILE *f = fopen("loc106.lox", "wb");
-			fwrite(res.DataPointer(), res.Size(), 1, f);
-			fclose(f);
-		}
-#endif
-		m_loc.Load(res);
-		InitForNewLocation(nLoc, ptTonyStart, start);
-		bLoaded = true;
-		break;
-	}
-	
-	if (!bLoaded)
-		SelectLocation(ptTonyStart, start);
-
-	if (m_bOption)
-		m_opt.ReInit(m_bigBuf);
-
-	m_bLocationLoaded = true;
-
-	// On Enter per la locazion
-	return INVALID_HANDLE_VALUE; //mpalQueryDoAction(0, m_nCurLoc, 0);
-}
-
-HANDLE RMGfxEngine::UnloadLocation(bool bDoOnExit) {
-	HANDLE h;
-	
-	// Scarica tutta la memoria della locazione
-	mpalEndIdlePoll(m_nCurLoc);
-
-	// On Exit?
-	if (bDoOnExit) {
-		h = mpalQueryDoAction(1, m_nCurLoc, 0);
-		if (h != INVALID_HANDLE_VALUE)
-			WaitForSingleObject(h, INFINITE);
-	}
-
-	MainFreeze();
-
-	m_bLocationLoaded = false;
-	
-	m_bigBuf.ClearOT();
-	m_loc.Unload();
-
-	return INVALID_HANDLE_VALUE;
-}
-
-void RMGfxEngine::Init() {
-	// Screen loading
-	RMResRaw *raw; 
-	RMGfxSourceBuffer16 *load = NULL;
-	INIT_GFX16_FROMRAW(20038, load);
-	m_bigBuf.AddPrim(new RMGfxPrimitive(load));
-	m_bigBuf.DrawOT();
-	m_bigBuf.ClearOT();
-	delete load;
-	_vm->m_wnd.GetNewFrame(*this, NULL);
-
-
-
-	bPatIrqFreeze = true;
-
-	// GUI attivabile
-	m_bGUIOption = true;
-	m_bGUIInterface = true;
-	m_bGUIInventory = true;
-
-	bSkipSfxNoLoop = false;
-	m_bMustEnterMenu = false;
-	bIdleExited = false;
-	m_bOption = false;
-	m_bWiping = false;
-	m_hWipeEvent=CreateEvent(NULL, false, false, NULL);
-
-	// Crea l'evento di freeze
-	g_system->lockMutex(csMainLoop);
-	
-	// Inizializza la funzione di IRQ di Item per l'MPAL
-	ItemIrq((uint32)-1, (uint32)this, 0);
-	mpalInstallItemIrq(ItemIrq);
-	
-	// Inizializza DirectInput	
-	m_input.Init(/*hInst*/);
-
-	// Inizializza il puntatore del mouse
-	m_point.Init();
-
-	// Inizializza Tony
-	m_tony.Init();
-	m_tony.LinkToBoxes(&_vm->_theBoxes);
-
-	// Inizializza l'inventario e l'interfaccia
-	m_inv.Init();
-	m_inter.Init();
-
-	// Carica la locazione e setta le prioritเ		@@@@@
-	m_bLocationLoaded = false;
-/*
-	m_nCurLoc=1;
-	RMRes res(m_nCurLoc);
-	m_loc.Load(res);
-	m_loc.SetPriority(1);
-	m_tony.SetPosition(RMPoint(201,316),1);
-	//m_tony.SetPosition(RMPoint(522,305),2);
-	//m_tony.SetPosition(RMPoint(158,398),4);
-	m_tony.SetPattern(m_tony.PAT_STANDDOWN);
-	m_curAction=TA_GOTO;
-*/ 
-	EnableInput();
-
-	// Inizio del gioco
-	//m_tony.ExecuteAction(4,1,0);    //PREGAME
-	
-	m_tony.ExecuteAction(20,1,0);
-
-//	theLog << "Seleziona la locazione\n";
-	//LoadLocation(1,RMPoint(201,316),RMPoint(-1,-1));
-	//SelectLocation();
-	//LoadLocation(5,RMPoint(685,338),RMPoint(-1,-1));
-	//LoadLocation(7,RMPoint(153,424),RMPoint(-1,-1));
-	//LoadLocation(70,RMPoint(10,10),RMPoint(-1,-1));
-	//LoadLocation(20,RMPoint(112,348),RMPoint(-1,-1));
-	//LoadLocation(26,RMPoint(95,456),RMPoint(-1,-1));
-	//LoadLocation(12,RMPoint(221,415),RMPoint(-1,-1));
-	//LoadLocation(25,RMPoint(221,415),RMPoint(-1,-1));
-	//LoadLocation(16,RMPoint(111,438),RMPoint(-1,-1));
-	//LoadLocation(60,RMPoint(18,302),RMPoint(-1,-1));
-	
-	// CASTELLO
-	
-	//LoadLocation(40,RMPoint(233,441),RMPoint(-1,-1));
-}
-
-void RMGfxEngine::Close(void) {
-	m_bigBuf.ClearOT();
-
-	m_inter.Close();
-	m_inv.Close();
-	m_tony.Close();
-	m_point.Close();
-	m_input.Close();
-}
-
-void RMGfxEngine::SwitchFullscreen(bool bFull) {
-	m_input.SwitchFullscreen(bFull);
-}
-
-void RMGfxEngine::GDIControl(bool bCon)
-{
-	m_input.GDIControl(bCon);
-}
-
-/*
-void RMGfxEngine::OptionScreen(void)
-{
-	if (!m_bOption)
-	{
-		if (m_opt.Init(m_bigBuf))
-		{
-			m_bOption = true;
-			DisableInput();
-			EnableMouse();
-		}
-	}
-	else
-	{
-		if (m_opt.Close())
-		{
-			m_bOption = false;
-			DisableMouse();
-			EnableInput();
-		}
-	}
-}
-*/
-
-void RMGfxEngine::EnableInput(void) {
-	m_bInput = true;
-}
-
-void RMGfxEngine::DisableInput(void) {
-	m_bInput = false;
-	m_inter.Reset();
-}
-
-void RMGfxEngine::EnableMouse(void) {
-	m_bAlwaysDrawMouse = true;
-}
-
-void RMGfxEngine::DisableMouse(void) {
-	m_bAlwaysDrawMouse = false;
-}
-
-void RMGfxEngine::Freeze(void) {
-	g_system->lockMutex(csMainLoop);
-}
-
-void RMGfxEngine::Unfreeze(void) {
-	g_system->unlockMutex(csMainLoop);
-}
-
-void CharsSaveAll(Common::OutSaveFile *fp);
-void CharsLoadAll(Common::InSaveFile *fp);
-void MCharResetCodes(void);
-void SaveChangedHotspot(Common::OutSaveFile *f);
-void LoadChangedHotspot(Common::InSaveFile *f);
-void ReapplyChangedHotspot(void);
-
-void RestoreMusic(void);
-void SaveMusic(Common::OutSaveFile *f);
-void LoadMusic(Common::InSaveFile *f);
-
-unsigned char wrkmem[LZO1X_999_MEM_COMPRESS];
-
-void RMGfxEngine::SaveState(const char *fn, byte *curThumb, const char *name, bool bFastCompress) {
-	Common::OutSaveFile *f;
-	byte *state, *statecmp;
-	byte *thumbcmp; 
-	uint32 thumbsizecmp, thumbsize;
-	uint32 size, sizecmp;
-	int i;
-	char buf[4];
-	RMPoint tp = m_tony.Position();
-
-	// Salvataggio: variabili mpal + locazione corrente + posizione di tony + inventario
-
-	// Per ora salviamo solo lo stato MPAL
-	size = mpalGetSaveStateSize();
-	state = new byte[size];
-	statecmp = new byte[size*2];
-	mpalSaveState(state);
-
-	thumbcmp = new byte[160*120*4];
-	thumbsize = 160*120*2;
-	
-	if (bFastCompress) {
-		lzo1x_1_compress(state, size, statecmp, &sizecmp, wrkmem);
-		lzo1x_1_compress(curThumb, thumbsize, thumbcmp, &thumbsizecmp, wrkmem);
-	} else {
-		lzo1x_999_compress(state, size, statecmp, &sizecmp, wrkmem);
-		lzo1x_999_compress(curThumb, thumbsize, thumbcmp, &thumbsizecmp, wrkmem);
-	}
-
-	buf[0] = 'R';
-	buf[1] = 'M';
-	buf[2] = 'S';
-	buf[3] = 0x7;
-
-	f = g_system->getSavefileManager()->openForSaving(fn);
-	if (f == NULL) 
-		return;
-
-	f->write(buf, 4);
-	f->writeUint32LE(thumbsizecmp);
-	f->write(thumbcmp, thumbsizecmp);
-
-	// Livello di difficoltเ
-	i = mpalQueryGlobalVar("VERSIONEFACILE");
-	f->writeByte(i);
-
-	i = strlen(name);
-	f->writeByte(i);
-	f->write(name, i);
-
-	f->writeUint32LE(m_nCurLoc);
-	f->writeUint32LE(tp.x);
-	f->writeUint32LE(tp.y);
-	f->writeUint32LE(size);
-	f->writeUint32LE(sizecmp);
-	
-	f->write(statecmp, sizecmp);
-
-	delete [] state;
-	delete [] statecmp;
-	delete [] thumbcmp;
-
-	// inventario
-	size = m_inv.GetSaveStateSize();
-	state = new byte[size];
-	m_inv.SaveState(state);
-
-	f->writeUint32LE(size);
-	f->write(state, size);
-	delete[] state;
-
-	// boxes
-	size = _vm->_theBoxes.GetSaveStateSize();
-	state = new byte[size];
-	_vm->_theBoxes.SaveState(state);
-	f->writeUint32LE(size);
-	f->write(state, size);
-	delete[] state;
-
-	// New Ver5
-	bool bStat;
-	
-	// Salva lo stato della pastorella e del palesati
-	bStat = m_tony.GetPastorella();
-	f->writeByte(bStat);
-	bStat = m_inter.GetPalesati();
-	f->writeByte(bStat);
-	
-	// Salva gli mchar
-	CharsSaveAll(f);
-
-	// Salva le opzioni
-	f->writeByte(bCfgInvLocked);
-	f->writeByte(bCfgInvNoScroll);
-	f->writeByte(bCfgTimerizedText);
-	f->writeByte(bCfgInvUp);
-	f->writeByte(bCfgAnni30);
-	f->writeByte(bCfgAntiAlias);
-	f->writeByte(bCfgSottotitoli);
-	f->writeByte(bCfgTransparence);
-	f->writeByte(bCfgInterTips);
-	f->writeByte(bCfgDubbing);
-	f->writeByte(bCfgMusic);
-	f->writeByte(bCfgSFX);
-	f->writeByte(nCfgTonySpeed);
-	f->writeByte(nCfgTextSpeed);
-	f->writeByte(nCfgDubbingVolume);
-	f->writeByte(nCfgMusicVolume);
-	f->writeByte(nCfgSFXVolume);
-
-	// Salva gli hotspot
-	SaveChangedHotspot(f);
-
-	// Salva la musica
-	SaveMusic(f);
-
-	f->finalize();
-	delete f;
-}
-
-void RMGfxEngine::LoadState(const char *fn) {
-	// PROBLEMA: Bisognerebbe caricare la locazione in un thread a parte per fare la OnEnter ...
-	Common::InSaveFile *f;
-	byte *state, *statecmp;
-	uint32 size, sizecmp;
-	char buf[4];
-	RMPoint tp;
-	int loc;
-	int ver;
-	int i;
-
-	f = g_system->getSavefileManager()->openForLoading(fn);
-	if (f == NULL)
-		return;
-
-	f->read(buf, 4);
-	if (buf[0] != 'R' || buf[1] != 'M' || buf[2] != 'S') {
-		delete f;
-		return;
-	}
-	
-	ver = buf[3];
-	
-	if (ver != 0x1 && ver != 0x2 && ver != 0x3 && ver != 0x4 && ver != 0x5 && ver != 0x6 && ver != 0x7) {
-		delete f;
-		return;
-	}
-	
-	if (ver >= 0x3) {
-		// C'่ il thumbnail. Se ver >= 5, ่ compresso
-		if (ver >= 0x5) {
-			i = 0;
-			i = f->readUint32LE();
-			f->seek(i, SEEK_CUR);
-		} else
-			f->seek(160 * 120 * 2, SEEK_CUR);
-	}
-
-	if (ver >= 0x5) {
-		// Skip del livello di difficoltเ
-		f->seek(1, SEEK_CUR);
-	}
-
-	if (ver >= 0x4) {	// Skippa il nome, che non serve a nessuno
-		i = f->readByte();
-		f->seek(i, SEEK_CUR);
-	}
-
-	loc = f->readUint32LE();
-	tp.x = f->readUint32LE();
-	tp.y = f->readUint32LE();
-	size = f->readUint32LE();
-
-	if (ver >= 0x5) {
-		// Stato MPAL compresso!
-		sizecmp = f->readUint32LE();
-		state = new byte[size];
-		statecmp = new byte[sizecmp];
-		f->read(statecmp, sizecmp);
-		lzo1x_decompress(statecmp, sizecmp, state, &size);
-
-		delete[] statecmp;
-	} else {
-		state = new byte[size];
-		f->read(state, size);
-	}
-
-	mpalLoadState(state);
-	delete[] state;
-
-
-	// inventario
-	size = f->readUint32LE();
-	state = new byte[size];
-	f->read(state, size);
-
-	m_inv.LoadState(state);
-	delete[] state;
-
-	if (ver >= 0x2) {	  // Versione 2: box please
-		size = f->readUint32LE();
-		state = new byte[size];
-		f->read(state, size);
-		_vm->_theBoxes.LoadState(state);
-		delete[] state;
-	}
-
-	if (ver >= 5) {
-	  // Versione 5: 
-		bool bStat = false;
-
-		bStat = f->readByte();
-		m_tony.SetPastorella(bStat);
-		bStat = f->readByte();
-		m_inter.SetPalesati(bStat);		
-
-		CharsLoadAll(f);
-	}
-
-  if (ver >= 6) {
-		// Carica le opzioni
-		bCfgInvLocked = f->readByte();
-		bCfgInvNoScroll = f->readByte();
-		bCfgTimerizedText = f->readByte();
-		bCfgInvUp = f->readByte();
-		bCfgAnni30 = f->readByte();
-		bCfgAntiAlias = f->readByte();
-		bCfgSottotitoli = f->readByte();
-		bCfgTransparence = f->readByte();
-		bCfgInterTips = f->readByte();
-		bCfgDubbing = f->readByte();
-		bCfgMusic = f->readByte();
-		bCfgSFX = f->readByte();
-		nCfgTonySpeed = f->readByte();
-		nCfgTextSpeed = f->readByte();
-		nCfgDubbingVolume = f->readByte();
-		nCfgMusicVolume = f->readByte();
-		nCfgSFXVolume = f->readByte();
-
-		// Carica gli hotspot
-		LoadChangedHotspot(f);
-	}
-
-	if (ver >= 7) {
-		LoadMusic(f);
-	}
-
-	delete f;
-
-	UnloadLocation(false);
-	LoadLocation(loc, tp, RMPoint(-1, -1));
-	m_tony.SetPattern(RMTony::PAT_STANDRIGHT);
-	MainUnfreeze();
-	
-	// Le versioni vecchie necessitano di On enter
-	if (ver < 5)
-		mpalQueryDoAction(0, loc, 0);
-	else {
-		// In quelle nuove, ci basta resettare gli mcode
-		MCharResetCodes();
-	}
-
-	if (ver >= 6)
-		ReapplyChangedHotspot();
-
-	RestoreMusic();
-
-	m_bGUIInterface = true;
-	m_bGUIInventory = true;
-	m_bGUIOption = true;
-}
-
-void RMGfxEngine::PauseSound(bool bPause) {
-	if (m_bLocationLoaded)
-		m_loc.PauseSound(bPause);
-}
-
-void RMGfxEngine::InitWipe(int type) {
-	m_bWiping = true;
-	m_nWipeType=type;
-	m_nWipeStep=0;
-
-	if (m_nWipeType==1)
-		m_rcWipeEllipse = Common::Rect(80, 0, 640 - 80, 480);
-	else if (m_nWipeType == 2)
-		m_rcWipeEllipse = Common::Rect(320 - FSTEP, 240 - FSTEP, 320 + FSTEP, 240 + FSTEP);
-}
-
-void RMGfxEngine::CloseWipe(void) {
-	m_bWiping = false;
-}
-
-void RMGfxEngine::WaitWipeEnd(void) {
-	WaitForSingleObject(m_hWipeEvent, INFINITE);
-}
-
 } // End of namespace Tony
diff --git a/engines/tony/module.mk b/engines/tony/module.mk
index 7c2c7928a8..cbd44d467e 100644
--- a/engines/tony/module.mk
+++ b/engines/tony/module.mk
@@ -10,6 +10,7 @@ MODULE_OBJS := \
 	loc.o \
 	sound.o \
 	tony.o \
+	tonychar.o \
 	utils.o \
 	mpal/expr.o \
 	mpal/loadmpc.o \
diff --git a/engines/tony/tony.cpp b/engines/tony/tony.cpp
index edad3690e9..ea555972d0 100644
--- a/engines/tony/tony.cpp
+++ b/engines/tony/tony.cpp
@@ -251,4 +251,98 @@ void TonyEngine::GrabThumbnail(void) {
 	warning("TODO: TonyEngine::GrabThumbnail");
 }
 
+void TonyEngine::Play(void) {
+	warning("TODO TonyEngine::Play");
+	
+#if 0
+	MSG msg;
+
+	do {
+		// Se siamo in pausa, entra nel loop appropriato
+		if (m_bPaused)
+			PauseLoop();
+
+  		// Redraw del graphic engine
+		theEngine.DoFrame(m_bDrawLocation);
+
+		// Avverte che ่ finito un frame
+		PulseEvent(m_hEndOfFrame);
+
+		// Passa il buffer dall'engine alla finestra
+		if (!m_bPaused) {
+			if (!theEngine.m_bWiping)
+				m_wnd.GetNewFrame(theEngine, NULL);
+			else
+				m_wnd.GetNewFrame(theEngine, &theEngine.m_rcWipeEllipse);
+		}
+
+		// Loop minchia dei messaggi
+		if (PeekMessage(&msg, m_wnd, 0, 0, true)) {
+			if (!TranslateAccelerator(m_wnd, m_hacc, &msg)) {
+				TranslateMessage(&msg);
+				DispatchMessage(&msg);
+			}
+		}
+	} while (msg.message != WM_QUIT && !m_bQuitNow);
+#endif
+}
+
+
+
+void TonyEngine::Close(void) {
+	CloseMusic();
+	CloseHandle(m_hEndOfFrame);
+	_theBoxes.Close();
+	_theEngine.Close();
+	m_wnd.Close();
+}
+
+void TonyEngine::SwitchFullscreen(bool bFull) {
+	m_wnd.SwitchFullscreen(bFull);
+	_theEngine.SwitchFullscreen(bFull);
+}
+
+void TonyEngine::GDIControl(bool bCon) {
+	_theEngine.GDIControl(bCon);
+}
+
+
+void TonyEngine::PauseLoop(void) {
+	warning("TODO: TonyEngine::PauseLoop");
+
+#if 0
+	MSG msg;
+	int st,et;
+
+	st = timeGetTime();
+
+	while (m_bPaused && GetMessage(&msg,m_wnd,0,0)) {
+		TranslateMessage(&msg);
+		DispatchMessage(&msg);
+	}
+
+	et = timeGetTime();
+
+	m_startTime += et - st;
+#endif
+}
+
+void TonyEngine::Pause(bool bPause) {
+	// Se non e' cambiato lo stato di pausing, non fare nulla
+	if (m_bPaused == bPause)
+		return;
+
+warning("TODO: TonyEninge::Pause");
+/*
+	m_bPaused = bPause;										
+	theEngine.GDIControl(m_bPaused);
+
+	if (m_bPaused) {
+		SetWindowText(m_wnd, "Tony Tough and the night of Roasted Moths - PAUSED");
+	} else {
+		SetWindowText(m_wnd, "Tony Tough and the night of Roasted Moths");
+	}
+*/
+}
+
 } // End of namespace Tony
diff --git a/engines/tony/tony.h b/engines/tony/tony.h
index f3b840faf5..dd7e558820 100644
--- a/engines/tony/tony.h
+++ b/engines/tony/tony.h
@@ -126,6 +126,15 @@ public:
 	RMGfxEngine *GetEngine() { return &_theEngine; }
 	void GUIError(const Common::String &msg);
 
+	// Avverte che siamo guidati dal GDI
+	void GDIControl(bool bCon);
+
+	// Loop che gestisce i messaggi quando siamo in pausa
+	void PauseLoop(void);
+
+	// Carica un modulo e le sue funzioni custom
+	void InitCustomDll(LPCUSTOMFUNCTION *FuncList);
+
 	void Play();
 	void Close();
 	void Abort();
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