diff --git a/engines/tony/game.cpp b/engines/tony/game.cpp index acafbbf7c876..109eefab2408 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 7c2c7928a8bf..cbd44d467e8c 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 edad3690e941..ea555972d066 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 f3b840faf5c5..dd7e55882035 100644 --- a/engines/tony/tony.h +++ b/engines/tony/tony.h @@ -126,6 +126,15 @@ class TonyEngine : public Engine { 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 000000000000..493f10ef29c7 --- /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