char CZombie::RecalculateIA(Vect3f hisPosition)
{
Vect3f myPosition( GetInstance()->GetPosition() );
switch(GetState())
{
case (char)IDLE:
GoIdle(hisPosition,myPosition);
break;
case (char)OLIENDO:
GoOliendo(hisPosition,myPosition);
break;
case (char)MIRANDO:
GoMirando(hisPosition,myPosition);
break;
case (char)ANDANDO:
// m_pRenderableAnimatedInstanceModel->GetAnimatedInstanceModel()->BlendCycle(MIRANDO,elapsedTime);
GoAndando(hisPosition,myPosition);
break;
case (char)ATACANDO:
GoAtacando(hisPosition,myPosition);
break;
case (char)RECIBIENDOGOLPE:
GoRecibiendoGolpe(hisPosition,myPosition);
break;
case (char)VOLVIENDOINICIO:
GoVolviendoInicio(hisPosition,myPosition);
break;
case (char)MURIENDO:
GoMuriendo();
break;
}
return GetState();
}
void UIAnimatedButton::AfterInitialized()
{
GoIdle();
UIUserElement::AfterInitialized();
}
//-----------------------------------------------------------------------------
//! Handle GetMenuItem in response to prior SendGetMenuItem().
//!
//! Create a tNASWidget and accumulate it in m_WidgetItemList.
//! When all have arrived, use the list to update m_pListWidget and go idle.
//! Otherwise get the next item.
//-----------------------------------------------------------------------------
void tNASVirtualHead::OnMenuItem( quint8 /*sourceId*/, quint32 index, quint8 flags, QString name )
{
// Ignore menu items that we don't expect. E.g. maybe we sent SetMenuAction while we were still waiting for a MenuItem.
// We can also ignore the items we requested while idle, although we expect them we don't need or want them.
if (m_State == eWaitingForMenuItems)
{
// Received the response, don't timeout.
m_StateTimer->stop();
// Restart inactivity timer.
m_CloseOnUserInactivityTimer->start();
// if there are a couple of devices requesting items at the same time, we can have duplicates. Just ignore them.
for( int i = 0; i < m_WidgetItemList.count(); i++ )
{
tNASWidgetItem* pItem = static_cast< tNASWidgetItem* >( m_WidgetItemList.value( i, 0 ) );
if( ( pItem != 0 ) && ( pItem->Index() == index ) )
{
return;
}
}
m_WidgetItemList << new tNASWidgetItem( index, flags, name );
// Have we just received the last item to complete the range of [m_FirstIndexInList, m_LastIndexInList]?
if ( ( m_FillingDown && (static_cast<int>(index) == m_LastIndexInList) ) ||
( !m_FillingDown && (static_cast<int>(index) == m_FirstIndexInList) ) )
{
// Move the list of the accumulated items to the list widget.
for( int i = 0; i < m_WidgetItemList.count(); ++i )
{
if (m_FillingDown)
{
m_pListWidget->addItem( m_WidgetItemList.at( i ) );
}
else
{
m_pListWidget->insertItem( 0, m_WidgetItemList.at( i ) );
}
}
m_WidgetItemList.clear();
// We can't calculate m_NumItemsNew properly until there are
// actually some items in the list and we can ask for a valid sizeHintForRow.
// That is why we do it here instead of in resizeEvent().
// Only need to calculate it once.
int moreItemsNeeded = 0;
if ( m_CheckHeight )
{
// Calculate m_NumItemsNew = number of items that can be visible in the list plus m_NewItemsNext,
// but not less than its original value (from constructor).
int itemHeight = m_pListWidget->sizeHintForRow( 0 );
if ( (itemHeight * m_NumItemsNew) < m_pListWidget->viewport()->height() )
{
// the height of the m_NumItemsNew to grab will be to short for the window,
// find out what it will be for m_NewItemsNext items taller than the window
// + (itemHeight - 1) is for rounding up.
int oldNumItemsNew = m_NumItemsNew;
m_NumItemsNew = ( m_pListWidget->viewport()->height() + ( itemHeight * m_NewItemsNext ) + (itemHeight - 1) ) / itemHeight;
moreItemsNeeded = m_NumItemsNew - oldNumItemsNew;
if (moreItemsNeeded < 0)
{
Assert(false);
moreItemsNeeded = 0;
}
// Be careful not to go past end of menu.
if ( (m_LastIndexInList + moreItemsNeeded) > (m_MenuItemCount - 1) )
{
moreItemsNeeded = (m_MenuItemCount - 1) - m_LastIndexInList;
}
}
m_CheckHeight = false;
}
// Keep the list from growing too big.
// Remove a page of items from above if there is more than 3.
if ( (m_ItemIndex - m_FirstIndexInList) > (m_NumItemsNew * 3) )
{
for( int count = 0; count < m_NumItemsNew; ++count )
{
delete m_pListWidget->takeItem( 0 );
}
m_FirstIndexInList += m_NumItemsNew;
}
// Remove a page of items from below if there is more than 3.
if ( (m_LastIndexInList + 1 - m_ItemIndex) > (m_NumItemsNew * 3) )
{
for( int count = 0; count < m_NumItemsNew; ++count )
{
delete m_pListWidget->takeItem( m_pListWidget->count()-1 );
}
m_LastIndexInList -= m_NumItemsNew;
}
// Adjust the selection to match and scroll to the top/bottom as appropriate for the direction of travel.
m_pListWidget->setCurrentRow( m_ItemIndex - m_FirstIndexInList );
//m_pListWidget->scrollToItem( m_pListWidget->currentItem(), ( m_FillingDown ? QAbstractItemView::PositionAtTop : QAbstractItemView::PositionAtBottom ) ); TODO_MCB ?
m_pListWidget->scrollToItem( m_pListWidget->currentItem(), ( m_FillingDown ? QAbstractItemView::PositionAtBottom : QAbstractItemView::PositionAtTop ) );
// Check if we need to get some more items, because (maybe) we recalculated m_NumItemsNew (see above).
if (moreItemsNeeded > 0)
{
m_NextIndex = m_LastIndexInList + 1;
m_LastIndexInList += moreItemsNeeded;
m_FillingDown = true;
SendGetMenuItem();
}
else
{
GoIdle();
}
}
else
{
// Not yet complete, get the next item.
if ( m_FillingDown )
{
++m_NextIndex;
}
else
{
--m_NextIndex;
}
SendGetMenuItem();
}
}
}
//-----------------------------------------------------------------------------
//! Handle MenuItemCount in response to prior SendGetMenuItemCount().
//-----------------------------------------------------------------------------
void tNASVirtualHead::OnMenuItemCount( quint8 /*sourceId*/, quint32 count )
{
// Received the response, don't timeout.
m_StateTimer->stop();
// Restart inactivity timer.
m_CloseOnUserInactivityTimer->start();
// Qt uses int, not quint32, for list indices and so on.
// Limit count to MAX_INT to keep things safe.
if (count > INT_MAX)
{
m_MenuItemCount = INT_MAX;
}
else
{
m_MenuItemCount = count;
}
// Sanity check.
if ( m_ItemIndex > (m_MenuItemCount - 1) )
{
m_ItemIndex = m_MenuItemCount - 1;
}
// New menu, start with empty list.
m_pListWidget->clear();
m_WidgetItemList.clear();
if( m_MenuItemCount != 0 )
{
// Load enough items to fill the screen plus m_NewItemsNext for scrolling down,
// resizeEvent() already calculated that as m_NumItemsNew.
// Plus load m_NewItemsNext extra items above for scrolling up.
// We want m_ItemIndex to appear at top of screen.
//
// Thus:
// m_FirstIndexInList is
// Want m_NewItemsNext items preloaded above the top of the screen.
// Want m_NewItemsNext items preloaded below the bottom of the screen.
// The screen can show m_NumItemsNew
// Don't need to load all items, just the ones near m_ItemIndex.
// Need to be careful about keeping the window within [0, MenuItemCount-1].
//
// Begin with m_FirstIndexInList being m_NewItemsNext above top.
m_FirstIndexInList = m_ItemIndex - m_NewItemsNext;
if (m_FirstIndexInList < 0)
{
m_FirstIndexInList = 0;
}
//
// and m_LastIndexInList being m_NewItemsNext below the bottom.
m_LastIndexInList = m_ItemIndex + m_NumItemsNew - 1;
if (m_LastIndexInList > m_MenuItemCount - 1)
{
m_LastIndexInList = m_MenuItemCount - 1;
// we chose something near the end of the list, back up to show a full screen.
m_FirstIndexInList = m_LastIndexInList + 1 - m_NumItemsNew;
if (m_FirstIndexInList < 0)
{
m_FirstIndexInList = 0;
}
}
m_FillingDown = true;
m_NextIndex = m_FirstIndexInList;
// Request from server
SendGetMenuItem();
}
else
{
// No items to load. Go idle and wait for user input.
m_FirstIndexInList = 0;
m_LastIndexInList = 0;
m_NextIndex = 0;
GoIdle();
}
}
