void CProcessor::Edit(CBirthday * pbd)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
CSetBirthdayDlg bddlg( AfxGetMainWnd(), pbd->m_name, pbd->m_date.GetDay(), pbd->m_date.GetMonth(), pbd->m_date.GetYear() );
if( bddlg.DoModal() == IDOK )
{
// Update the data
pbd->m_name = bddlg.m_name;
if( pbd->m_date != CDate(bddlg.m_day,bddlg.m_month,bddlg.m_year) )
{
// UPDATE ALL
m_pApp->ClearKnown( pbd );
// This garantees re-sorting
CBirthday* pnew = new CBirthday;
*pnew = *pbd;
Remove( pbd );
pnew->m_date = CDate(bddlg.m_day,bddlg.m_month,bddlg.m_year);
Add( pbd=pnew );
}
// Persistency
Store();
// ONLY UPDATE SOME TEXT
m_pApp->UpdateText( pbd );
ProcessAction(true);
}
}
void CProcessor::Confirm(CBirthday *pbd)
{
pbd->m_confirmed = true;
if( !pbd->m_date.AfterAndWithinDays( CDate(),
m_pconfig->m_daysAdvance ) )
pbd->m_alerted_this_year = false;
Store();
ProcessAction(true);
}
void CProcessor::PrefsAction(HWND hwnd)
{
ASSERT(m_pconfig);
if( m_pconfig )
{
m_pconfig->PrefsAction(hwnd);
DepopulateKnowns();
PopulateKnowns();
DepopulateBirthdays();
ProcessAction(true);
}
}
void RPG_ActionHandler::PerformAction(RPG_ActionType_e const& action, bool forceAction /*= false*/, RPG_BaseEntity* const interactionEntity /*= NULL*/,
hkvVec3 const& interactionPosition /*= hkvVec3(0, 0, 0)*/, int const flags /*= 0*/)
{
// if the action and the target are the same, we're just updating flags or interaction.
bool updatingActionParams = false;
if(m_activeAction.m_Action == action)
{
if(m_activeAction.m_interactionEntity != interactionEntity ||
!m_activeAction.m_interactionPosition.isIdentical(interactionPosition) ||
m_activeAction.m_flags != flags)
{
updatingActionParams = true;
}
}
if(!forceAction &&
m_activeAction.m_Action != AT_None &&
action != AT_None)
{
// there's an action already playing, and we aren't forcing the new one. perfor more checks.
if(m_Actions[m_activeAction.m_Action]->CanOverrideActionWith(action) ||
m_Actions[action]->CanThisActionOverride(m_activeAction.m_Action))
{
forceAction = true;
}
}
if (forceAction || updatingActionParams || CanPerformAction(action))
{
// bundle the action into a struct for easier network replication
RPG_ActionData actionData(action, interactionEntity, interactionPosition, flags);
// simulate the action locally
ProcessAction(actionData, forceAction);
// replicate the action to the server
//@todo: Once the network branch is integrated, here's where we replicate this action to the server.
/*
Work that needs to happen here:
- Find out whether this is a non-authoritative client.
- If all we're doing is updating action flags, preserve bandwidth by calling a client->server UpdateActionFlags() with just that data
- If we're doing a new Action, call a client->server ProcessAction() using the constructed struct.
*/
}
else if(action != AT_None &&
m_Actions[m_activeAction.m_Action]->CanChainAction(action))
{
// can't process the new action, so check to see if we can chain it
RPG_ActionData actionData(action, interactionEntity, interactionPosition, flags);
m_pendingAction = actionData;
}
}
void CProcessor::Add(CBirthday * pbd)
{
ASSERT(m_pbds);
if( m_pbds )
{
m_pbds->Add(pbd);
ProcessAction(true);
m_pbds->Store();
}
// Add to list
m_pApp->DrawKnown( pbd );
m_pApp->UpdateCounter();
}
tResult LightMessageLogger::OnAsyncPinEvent(IPin* pSource, tInt nEventCode, tInt nParam1, tInt nParam2,
IMediaSample* pMediaSample) {
RETURN_IF_POINTER_NULL(pMediaSample);
RETURN_IF_POINTER_NULL(pSource);
__synchronized_obj(criticalSection_OnPinEvent);
if (nEventCode == IPinEventSink::PE_MediaSampleReceived) {
if (pSource == &actionInput) {
TActionStruct::ActionSub actionSub_tmp;
actionSub_tmp = tActionStruct_object.Read_Action(pMediaSample, F_LIGHT_MESSAGE_LOGGER);
ProcessAction(actionSub_tmp);
}
}
RETURN_NOERROR;
}
void CProcessor::Reload(CBirthday *pbd)
{
if( pbd->Reload() )
{
// UPDATE ALL
m_pApp->ClearKnown( pbd );
// This garantees re-sorting
CBirthday* pnew = new CBirthday;
*pnew = *pbd;
Remove( pbd );
Add( pbd=pnew );
// Persistency
Store();
ProcessAction(true);
}
}
//---------------------------------------------------------------------------------------------------
void FactionState::Update(float deltaTime)
{
std::vector<ShipInfo> shipInfos;
std::vector<ShipInfo> friendlyShips;
// Gather info on all ships
for (auto &ship : battle_.ships())
{
shipInfos.emplace_back(
ship.faction().id(), ship.id(),
ship.hp(), ship.max_hp(),
ship.position(), ship.orientation(),
ship.mass(), ship.velocity());
if (&ship.faction() == this)
friendlyShips.emplace_back(
ship.faction().id(), ship.id(),
ship.hp(), ship.max_hp(),
ship.position(), ship.orientation(),
ship.mass(), ship.velocity());
}
// Create the input buffer
AIInput input(deltaTime,
battle_.bounds(),
std::move(shipInfos),
std::move(friendlyShips));
FactionAICommand command;
ai_->Update(input, command);
const ActionBuffer& commandBuffer = command.read_buffer();
while (!commandBuffer.read_eof())
{
AIAction action = commandBuffer.BeginReadEvent();
ProcessAction(action, commandBuffer);
commandBuffer.EndReadEvent();
}
}
void IsuCompetition::AddAction(OsisAction* newAction)
{
if (!newAction)
{
return;
}
if (Current_Action)
{
delete Current_Action;
}
Current_Action = newAction;
const QMetaObject &mo = Actions::staticMetaObject;
int index = mo.indexOfEnumerator("ObsAction");
QMetaEnum metaEnum = mo.enumerator(index);
QString elementName = newAction->GetAttribute(OsisAction::Command);
elementName = elementName.toUpper();
elementName.prepend("ACTION_");
int xmlElementTag = metaEnum.keyToValue(&elementName.toStdString()[0]);
ProcessAction(xmlElementTag);
}
void Connection::ProcessSectorServerOpcode(short opcode, short bytes)
{
unsigned long tick = GetNet7TickCount();
//LogMessage("<CLIENT> ---> 0x%04x\n", opcode);
//this can be used to intercept messages from the client
switch (opcode)
{
case ENB_OPCODE_0002_LOGIN:
g_LoggedIn = true;
g_ServerMgr->m_SectorConnection = this;
LogMessage("Sending Login packet - connection active\n");
g_ServerMgr->m_UDPConnection->SetConnectionActive(true);
g_ServerMgr->m_UDPClient->SetConnectionActive(true);
time_debug = 50;
break;
case ENB_OPCODE_0006_START_ACK :
g_ServerMgr->m_UDPConnection->ForwardClientOpcode(opcode, bytes, (char*)m_RecvBuffer);
if (g_ServerMgr->m_UDPClient->GetSectorID() > 9999 || g_ServerMgr->m_UDPConnection->PreferTCP())
{
long player_id = g_ServerMgr->m_UDPClient->PlayerID();
g_ServerMgr->m_UDPConnection->ForwardClientOpcode(ENB_OPCODE_3008_STARBASE_LOGIN_COMPLETE, sizeof(player_id), (char *) &player_id);
g_ServerMgr->m_UDPClient->SetLoginComplete(true);
}
else
{
long player_id = g_ServerMgr->m_UDPClient->PlayerID();
g_ServerMgr->m_UDPConnection->ForwardClientOpcode(ENB_OPCODE_3004_PLAYER_SHIP_SENT, sizeof(player_id), (char *) &player_id);
g_ServerMgr->m_UDPConnection->KillTCPConnection();
g_ServerMgr->m_UDPClient->SetLoginComplete(true);
}
LogMessage("Sending StartAck to Server %d\n", *((long *) &m_RecvBuffer[0]) );
return;
break;
case ENB_OPCODE_0014_MOVE :
break;
case ENB_OPCODE_0012_TURN :
//only send one of these per 0.25 secs
if (tick > (m_Turn_Sent + 250))
{
g_ServerMgr->m_UDPConnection->ForwardClientOpcode(opcode, bytes, (char*)m_RecvBuffer);
m_Turn_Sent = tick;
}
return;
break;
case ENB_OPCODE_0013_TILT :
//only send one of these per 0.25 secs
if (tick > (m_Tilt_Sent + 250))
{
g_ServerMgr->m_UDPConnection->ForwardClientOpcode(opcode, bytes, (char*)m_RecvBuffer);
m_Tilt_Sent = tick;
}
return;
break;
case ENB_OPCODE_00B9_LOGOFF_REQUEST:
g_LoggedIn = true;
//drop through
case ENB_OPCODE_003A_SERVER_HANDOFF:
//DumpBuffer(m_RecvBuffer, bytes);
//LogMessage("Handoff\n", opcode);
//g_ServerMgr->m_UDPConnection->SetConnectionActive(false);
//g_ServerMgr->m_UDPClient->SetConnectionActive(false);
break;
case ENB_OPCODE_002C_ACTION:
g_ServerMgr->m_UDPConnection->ForwardClientOpcode(opcode, bytes, (char*)m_RecvBuffer);
ProcessAction();
return;
break;
case ENB_OPCODE_009F_STARBASE_ROOM_CHANGE :
HandleStarbaseRoomChange();
break;
case ENB_OPCODE_009B_WARP:
HandleWarp();
break;
default:
//LogMessage("Forwarding opcode to server 0x%04x\n", opcode);
break;
}
//forward the opcode to the server via UDP
g_ServerMgr->m_UDPConnection->ForwardClientOpcode(opcode, bytes, (char*)m_RecvBuffer);
}
int main(void) {
char str[100];
// char buffer1[100];
// /* Free and total space */
// uint32_t total, free;
/* Initialize system */
SystemInit();
/* Initialize delays */
TM_DELAY_Init();
/* Enable watchdog, 4 seconds before timeout */
if (TM_WATCHDOG_Init(TM_WATCHDOG_Timeout_8s)) {
/* Report to user */
//printf("Reset occured because of Watchdog\n");
}
/* Reset counter to 0 */
TM_DELAY_SetTime(0);
/* init DTMF*/
TM_GPIO_Init(DTMF_BIT0_PORT, DTMF_BIT0_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_Low);
TM_GPIO_Init(DTMF_BIT1_PORT, DTMF_BIT1_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_Low);
TM_GPIO_Init(DTMF_BIT2_PORT, DTMF_BIT2_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_Low);
TM_GPIO_Init(DTMF_BIT3_PORT, DTMF_BIT3_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_Low);
/* DTMF*/
if (TM_EXTI_Attach(DFMF_BIT4_PORT, DTMF_BIT4_PIN, TM_EXTI_Trigger_Rising) == TM_EXTI_Result_Ok) {
TM_USART_Puts(USART3, "khoi tao ngat DFMF_BIT4\n");
}
/*init interrup INPUT*/
if (TM_EXTI_Attach(W1_D0_PORT, W1_D0_PIN, TM_EXTI_Trigger_Rising) == TM_EXTI_Result_Ok) {
TM_USART_Puts(USART3, "khoi tao ngat W1_D0\n");
}
if (TM_EXTI_Attach(W1_D1_PORT, W1_D1_PIN, TM_EXTI_Trigger_Rising) == TM_EXTI_Result_Ok) {
TM_USART_Puts(USART3, "khoi tao ngat W1_D1\n");
}
if (TM_EXTI_Attach(W2_D1_PORT, W2_D1_PIN, TM_EXTI_Trigger_Falling) == TM_EXTI_Result_Ok) {
TM_USART_Puts(USART3, "khoi tao ngat W2_D1\n");
}
if (TM_EXTI_Attach(W2_D0_PORT, W2_D0_PIN, TM_EXTI_Trigger_Falling) == TM_EXTI_Result_Ok) {
TM_USART_Puts(USART3, "khoi tao ngat W2_D0\n"); // W2D0
}
/*init SWADD*/
TM_GPIO_Init(ADD_BIT0_PORT, ADD_BIT0_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium);
TM_GPIO_Init(ADD_BIT1_PORT, ADD_BIT1_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium);
TM_GPIO_Init(ADD_BIT2_PORT, ADD_BIT2_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium);
TM_GPIO_Init(ADD_BIT3_PORT, ADD_BIT3_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium);
TM_GPIO_Init(ADD_BIT4_PORT, ADD_BIT4_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium);
TM_GPIO_Init(ADD_BIT5_PORT, ADD_BIT5_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium);
TM_GPIO_Init(ADD_BIT6_PORT, ADD_BIT6_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium);
TM_GPIO_Init(ADD_BIT7_PORT, ADD_BIT7_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium);
/* init OUTPUT*/
TM_GPIO_Init(RELAY_DK1_PORT, RELAY_DK1_PIN, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_High);
TM_GPIO_Init(RELAY_DK2_PORT, RELAY_DK2_PIN, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_High);
TM_GPIO_Init(RELAY_DK3_PORT, RELAY_DK3_PIN, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_High);
TM_GPIO_Init(RELAY_DK4_PORT, RELAY_DK4_PIN, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_High);
/* Initialize USART6 at 115200 baud, TX: PC6, RX: PC7 , COM 1 - RFID1 gan cong tac nguon*/
TM_USART_Init(USART6, TM_USART_PinsPack_1, 115200);
/* Initialize USART3 at 115200 baud, TX: PD8, RX: PD9 , COM 2 -RFID 2 gan ethernet*/
TM_USART_Init(USART3, TM_USART_PinsPack_3, 115200);
/* Initialize USART1 at 115200 baud, TX: PA9, RX: PA10, CONG 485 */
TM_USART_Init(USART1, TM_USART_PinsPack_1, 9600);
/* Initialize USART2, with custom pins */ // COM 3 extension PC
//TM_USART_Init(USART2, TM_USART_PinsPack_Custom,9600);
TM_USART_Init(USART2, TM_USART_PinsPack_2,9600);
/* int DIR 485 set = send , reset = recvice*/
TM_GPIO_Init(CCU_DIR_PORT, CCU_DIR_PIN, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_High);
TM_GPIO_SetPinHigh(CCU_DIR_PORT,CCU_DIR_PIN);
/* Init 2 custom timers */
/* Timer1 has reload value each 500ms, enabled auto reload feature and timer is enabled */
CustomTimer1 = TM_DELAY_TimerCreate(500, 1, 1, CustomTIMER1_Task, NULL);
/* Timer1 has reload value each 1000ms, enabled auto reload feature and timer is enabled */
CustomTimer2 = TM_DELAY_TimerCreate(100, 1, 1, CustomTIMER2_Task, NULL);
/* Init LCD*/
TM_GPIO_Init(HD44780_RW_PORT, HD44780_RW_PIN, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_High);
TM_GPIO_SetPinLow(HD44780_RW_PORT,HD44780_RW_PIN);
read_sw_add();
timeout = value_dip;
memset(str,'\0',0);
//Initialize LCD 20 cols x 4 rows
TM_HD44780_Init(16, 4);
//Save custom character on location 0 in LCD
TM_HD44780_CreateChar(0, &customChar[0]);
//Put string to LCD
TM_HD44780_Puts(0, 0, "STM32F407VET\n\rCreartbyR&D-TIS"); /* 0 dong 1, 1 dong 2*/
TM_HD44780_Puts(0, 2, "Welcome");
Delayms(1000);
TM_HD44780_Clear();
sprintf(str,"Timer out %d", timeout);
TM_HD44780_Puts(0, 0,str);
Delayms(1000);
TM_HD44780_Clear();
TM_HD44780_Puts(0, 0,"----TIS8 PRO----");
//TM_USART_Puts(USART3, "Welcome2");
/*creat by duc*/
TM_WATCHDOG_Reset();
// TM_USART_BufferEmpty(USART3);
// TM_USART_BufferEmpty(USART6);
flag_RFID2=0;
flag_RFID1=0;
/*end by duc*/
while (1) {
/*process 485*/
if(flag_485){
flag_485=0;
if(LEDStatus==0) TM_USART_Puts(USART1, "/LED000>\r\n");
if(LEDStatus==1) TM_USART_Puts(USART1, "/LED001>\r\n");
if(LEDStatus==2) TM_USART_Puts(USART1, "/LED002>\r\n");
}
/* xu li W1D0 - dk1*/
if(flag_W1D0){
turn_on_dk1();
//flag_W1D0=0;
}
/* xu li W1D1 - dk2*/
if(flag_W1D1){
turn_on_dk2();
//flag_W1D1=0;
}
//TM_WATCHDOG_Reset();
// /*end*/
if(Process!=1)
TM_HD44780_Puts(0, 2,"Wait for Card"); /* 0 dong 1, 1 dong 2*/
if(flag_RFID1==1)
{
Process=1;
IDCAR1[0]=BufferCom1[4];
IDCAR1[1]=BufferCom1[5];
IDCAR1[2]=BufferCom1[6];
IDCAR1[3]=BufferCom1[7];
IDCAR1[4]=BufferCom1[8];
IDCAR1[5]=BufferCom1[9];
IDCAR1[6]=BufferCom1[10];
if(BufferCom1[1]==0x08)
{
sprintf(UID1,"%02x %02x %02x %02x,1",IDCAR1[0],IDCAR1[1],IDCAR1[2],IDCAR1[3]);
}
if(BufferCom1[1]==0x0B)
{
sprintf(UID1,"%02x %02x %02x %02x %02x %02x %02x,1",IDCAR1[0],IDCAR1[1],IDCAR1[2],IDCAR1[3],IDCAR1[4],IDCAR1[5],IDCAR1[6]);
}
TM_HD44780_Puts(0, 2,"Waiting PC..."); /* 0 dong 1, 1 dong 2*/
if(check_vip(UID1)){
flag_PC=1;
flag_R11=1;
timerdk1 =0;
Process=0;
}
else{
if(Process)TM_USART_Puts(USART2,UID1);
}
WaitPC(200);
flag_RFID1=0;
if(flag_PC)
{
TM_HD44780_Puts(0, 2,"Door opened.."); /* 0 dong 1, 1 dong 2*/
flag_PC=0;
ProcessAction();
}
else Process=0;
flag_RFID1=0;
}
if(flag_RFID2==1)
{
Process=1;
IDCAR2[0]=BufferCom2[4];
IDCAR2[1]=BufferCom2[5];
IDCAR2[2]=BufferCom2[6];
IDCAR2[3]=BufferCom2[7];
IDCAR2[4]=BufferCom2[8];
IDCAR2[5]=BufferCom2[9];
IDCAR2[6]=BufferCom2[10];
if(BufferCom2[1]==0x08)
{
sprintf(UID2,"%02x %02x %02x %02x ,2",IDCAR2[0],IDCAR2[1],IDCAR2[2],IDCAR2[3]);
}
if(BufferCom2[1]==0x0B)
{
sprintf(UID2,"%02x %02x %02x %02x %02x %02x %02x ,2",IDCAR2[0],IDCAR2[1],IDCAR2[2],IDCAR2[3],IDCAR2[4],IDCAR2[5],IDCAR2[6]);
}
TM_HD44780_Puts(0, 2,"Waiting PC..."); /* 0 dong 1, 1 dong 2*/
if(check_vip(UID2)){
flag_PC=1;
flag_R31=1;
timerdk2 =0;
Process=0;
}
else{
if(Process)TM_USART_Puts(USART2,UID2);}
WaitPC(200);
flag_RFID2=0;
if(flag_PC)
{
TM_HD44780_Puts(0, 2,"Door opened.."); /* 0 dong 1, 1 dong 2*/
flag_PC=0;
ProcessAction();
}
else Process=0;
flag_RFID2=0;
}
/**/
timer_dk1 = timerdk1/2;
if (timer_dk1 >= timeout){
turn_off_dk1();
flag_R11 =0;
flag_W1D0=0;
timerdk1=0;
timer_dk1=0;
flag_RFID1=0;
flag_RFID2=0;
Process=0;
// if(LEDStatus==0) TM_USART_Puts(USART3, "/LED000>\r\n");
}
timer_dk2 = timerdk2/2;
if (timer_dk2 >= timeout){
turn_off_dk2();
//flag_R21 =0;
flag_R31 =0;
flag_W1D1=0;
timerdk2=0;
timer_dk2=0;
//flag_RFID1=0;
Process=0;
// if(LEDStatus==0) TM_USART_Puts(USART3, "/LED000>\r\n");
}
timer_dk3 = timerdk3;
if (timer_dk3 >= 1){
turn_off_dk3();
flag_R12 =0;
timerdk3=0;
timer_dk3=0;
}
timer_dk4 = timerdk4;
if (timer_dk4 >= 1){
turn_off_dk4();
flag_R22 =0;
timer_dk4=0;
timerdk4=0;
}
TM_WATCHDOG_Reset();
}
}
bool CreatureEventAI::ProcessEvent(CreatureEventAIHolder& holder, Unit* actionInvoker /*=NULL*/)
{
if (!holder.Enabled || holder.Time)
return false;
//Check the inverse phase mask (event doesn't trigger if current phase bit is set in mask)
if (holder.Event.event_inverse_phase_mask & (1 << m_Phase))
return false;
CreatureEventAI_Event const& event = holder.Event;
//Check event conditions based on the event type, also reset events
switch (event.event_type)
{
case EVENT_T_TIMER:
if (!me->isInCombat())
return false;
//Repeat Timers
holder.UpdateRepeatTimer(me, event.timer.repeatMin, event.timer.repeatMax);
break;
case EVENT_T_TIMER_OOC:
if (me->isInCombat())
return false;
//Repeat Timers
holder.UpdateRepeatTimer(me, event.timer.repeatMin, event.timer.repeatMax);
break;
case EVENT_T_HP:
{
if (!me->isInCombat() || !me->GetMaxHealth())
return false;
uint32 perc = uint32(me->GetHealthPct());
if (perc > event.percent_range.percentMax || perc < event.percent_range.percentMin)
return false;
//Repeat Timers
holder.UpdateRepeatTimer(me, event.percent_range.repeatMin, event.percent_range.repeatMax);
break;
}
case EVENT_T_MANA:
{
if (!me->isInCombat() || !me->GetMaxPower(POWER_MANA))
return false;
uint32 perc = (me->GetPower(POWER_MANA)*100) / me->GetMaxPower(POWER_MANA);
if (perc > event.percent_range.percentMax || perc < event.percent_range.percentMin)
return false;
//Repeat Timers
holder.UpdateRepeatTimer(me, event.percent_range.repeatMin, event.percent_range.repeatMax);
break;
}
case EVENT_T_AGGRO:
break;
case EVENT_T_KILL:
//Repeat Timers
holder.UpdateRepeatTimer(me, event.kill.repeatMin, event.kill.repeatMax);
break;
case EVENT_T_DEATH:
case EVENT_T_EVADE:
break;
case EVENT_T_SPELLHIT:
//Spell hit is special case, param1 and param2 handled within CreatureEventAI::SpellHit
//Repeat Timers
holder.UpdateRepeatTimer(me, event.spell_hit.repeatMin, event.spell_hit.repeatMax);
break;
case EVENT_T_RANGE:
//Repeat Timers
holder.UpdateRepeatTimer(me, event.range.repeatMin, event.range.repeatMax);
break;
case EVENT_T_OOC_LOS:
//Repeat Timers
holder.UpdateRepeatTimer(me, event.ooc_los.repeatMin, event.ooc_los.repeatMax);
break;
case EVENT_T_RESET:
case EVENT_T_SPAWNED:
break;
case EVENT_T_TARGET_HP:
{
if (!me->isInCombat() || !me->getVictim() || !me->getVictim()->GetMaxHealth())
return false;
uint32 perc = uint32(me->getVictim()->GetHealthPct());
if (perc > event.percent_range.percentMax || perc < event.percent_range.percentMin)
return false;
//Repeat Timers
holder.UpdateRepeatTimer(me, event.percent_range.repeatMin, event.percent_range.repeatMax);
break;
}
case EVENT_T_TARGET_CASTING:
if (!me->isInCombat() || !me->getVictim() || !me->getVictim()->IsNonMeleeSpellCasted(false, false, true))
return false;
//Repeat Timers
holder.UpdateRepeatTimer(me, event.target_casting.repeatMin, event.target_casting.repeatMax);
break;
case EVENT_T_FRIENDLY_HP:
{
if (!me->isInCombat())
return false;
Unit* unit = DoSelectLowestHpFriendly((float)event.friendly_hp.radius, event.friendly_hp.hpDeficit);
if (!unit)
return false;
actionInvoker = unit;
//Repeat Timers
holder.UpdateRepeatTimer(me, event.friendly_hp.repeatMin, event.friendly_hp.repeatMax);
break;
}
case EVENT_T_FRIENDLY_IS_CC:
{
if (!me->isInCombat())
return false;
std::list<Creature*> pList;
DoFindFriendlyCC(pList, (float)event.friendly_is_cc.radius);
//List is empty
if (pList.empty())
return false;
//We don't really care about the whole list, just return first available
actionInvoker = *(pList.begin());
//Repeat Timers
holder.UpdateRepeatTimer(me, event.friendly_is_cc.repeatMin, event.friendly_is_cc.repeatMax);
break;
}
case EVENT_T_FRIENDLY_MISSING_BUFF:
{
std::list<Creature*> pList;
DoFindFriendlyMissingBuff(pList, (float)event.friendly_buff.radius, event.friendly_buff.spellId);
//List is empty
if (pList.empty())
return false;
//We don't really care about the whole list, just return first available
actionInvoker = *(pList.begin());
//Repeat Timers
holder.UpdateRepeatTimer(me, event.friendly_buff.repeatMin, event.friendly_buff.repeatMax);
break;
}
case EVENT_T_SUMMONED_UNIT:
{
//Prevent event from occuring on no unit or non creatures
if (!actionInvoker || actionInvoker->GetTypeId() != TYPEID_UNIT)
return false;
//Creature id doesn't match up
if (actionInvoker->ToCreature()->GetEntry() != event.summon_unit.creatureId)
return false;
//Repeat Timers
holder.UpdateRepeatTimer(me, event.summon_unit.repeatMin, event.summon_unit.repeatMax);
break;
}
case EVENT_T_TARGET_MANA:
{
if (!me->isInCombat() || !me->getVictim() || !me->getVictim()->GetMaxPower(POWER_MANA))
return false;
uint32 perc = (me->getVictim()->GetPower(POWER_MANA)*100) / me->getVictim()->GetMaxPower(POWER_MANA);
if (perc > event.percent_range.percentMax || perc < event.percent_range.percentMin)
return false;
//Repeat Timers
holder.UpdateRepeatTimer(me, event.percent_range.repeatMin, event.percent_range.repeatMax);
break;
}
case EVENT_T_REACHED_HOME:
case EVENT_T_RECEIVE_EMOTE:
break;
case EVENT_T_BUFFED:
{
//Note: checked only aura for effect 0, if need check aura for effect 1/2 then
// possible way: pack in event.buffed.amount 2 uint16 (ammount+effectIdx)
Aura const* aura = me->GetAura(event.buffed.spellId);
if (!aura || aura->GetStackAmount() < event.buffed.amount)
return false;
//Repeat Timers
holder.UpdateRepeatTimer(me, event.buffed.repeatMin, event.buffed.repeatMax);
break;
}
case EVENT_T_TARGET_BUFFED:
{
//Prevent event from occuring on no unit
if (!actionInvoker)
return false;
//Note: checked only aura for effect 0, if need check aura for effect 1/2 then
// possible way: pack in event.buffed.amount 2 uint16 (ammount+effectIdx)
Aura const* aura = actionInvoker->GetAura(event.buffed.spellId);
if (!aura || aura->GetStackAmount() < event.buffed.amount)
return false;
//Repeat Timers
holder.UpdateRepeatTimer(me, event.buffed.repeatMin, event.buffed.repeatMax);
break;
}
default:
sLog->outErrorDb("CreatureEventAI: Creature %u using Event %u has invalid Event Type(%u), missing from ProcessEvent() Switch.", me->GetEntry(), holder.Event.event_id, holder.Event.event_type);
break;
}
//Disable non-repeatable events
if (!(holder.Event.event_flags & EFLAG_REPEATABLE))
holder.Enabled = false;
//Store random here so that all random actions match up
uint32 rnd = rand();
//Return if chance for event is not met
if (holder.Event.event_chance <= rnd % 100)
return false;
//Process actions
for (uint8 j = 0; j < MAX_ACTIONS; ++j)
ProcessAction(holder.Event.action[j], rnd, holder.Event.event_id, actionInvoker);
return true;
}
bool CEditCategoryBuilder::Build(CWholePage* pPage)
{
CCategory Category(m_InputContext); // holds the hierarchy information from the given nodeid
CEditCategory EditCategory(m_InputContext); //holds the information
CUser* pViewer = NULL;
bool bSuccess = true;
if(!InitPage(pPage, "EDITCATEGORY",true))
{
return false;
}
// get the viewing user
pViewer = m_InputContext.GetCurrentUser();
bool bActionProcessed = false;
//Where in the hierarchy we will display from
int iDestinationNodeID = 0;
//found out if there is a nodeid
int iNodeID =0;
if (m_InputContext.ParamExists("nodeid"))
{
iNodeID = m_InputContext.GetParamInt("nodeid");
}
//find out if there is an action
CTDVString sAction;
bool bActionExists = false;
if(m_InputContext.ParamExists("action"))
{
bActionExists = m_InputContext.GetParamString("action",sAction);
}
//TagItemId can be provided as follows...
//1. activenode parameter - depreciated.
//2. tagitemid parameter if in tag mode.
int iTagItemId = 0;
if(m_InputContext.ParamExists("activenode"))
{
//ActiveNode parameter actually refers to the Id of the item to tag.
iTagItemId = m_InputContext.GetParamInt("activenode");
}
else if ( m_InputContext.ParamExists("tagmode") )
{
iTagItemId = m_InputContext.GetParamInt("tagitemid");
}
//if there is no activeNode and no action then we are doing simple navigation
if ( !iTagItemId && !bActionExists && (iNodeID >=0))
{
bSuccess = bSuccess && EditCategory.Initialise(m_InputContext.GetSiteID());
}
else if (bActionExists && bSuccess)
{
//there is something to do so let EditCategory deal with it and find out where it wants to display the hierarchy from
bSuccess = bSuccess && EditCategory.Initialise(m_InputContext.GetSiteID());
bSuccess = ProcessAction(sAction,iTagItemId,iNodeID,iDestinationNodeID,&EditCategory,pPage,bActionProcessed);
}
else
{
bSuccess = false;
}
if(bSuccess)
{
bSuccess = bSuccess && Category.InitialiseViaNodeID(iDestinationNodeID, m_InputContext.GetSiteID());
int h2g2ID = Category.Geth2g2ID();
bSuccess = bSuccess && EditCategory.AddInside("EDITCATEGORY",&Category);
if (h2g2ID > 0)
{
CGuideEntry GuideEntry(m_InputContext);
GuideEntry.Initialise(h2g2ID, m_InputContext.GetSiteID(), pViewer, true, true, true, true);
EditCategory.AddInside("HIERARCHYDETAILS", &GuideEntry);
}
// Check to see if we're in tagmode or category mode
if(bSuccess)
{
// Check to see if we're in tag mode.
if (m_InputContext.ParamExists("tagmode"))
{
// Get the TagitemID and the TagType from the url
int iTagItemID = m_InputContext.GetParamInt("tagitemid");
CTDVString sTagItemType;
m_InputContext.GetParamString("tagitemtype",sTagItemType);
int iTagMode = m_InputContext.GetParamInt("tagmode");
int iSiteID = m_InputContext.GetSiteID();
CUser* pCurrentUser = m_InputContext.GetCurrentUser();
// Now put it into the XML
CTDVString sTagInfo;
sTagInfo << "<TAGINFO MODE='" << iTagMode << "'";
// Check to see if we've been given the TagItemID
if (iTagItemID == 0)
{
// No, just do the default thing by putting the tagmose into the xml
sTagInfo << "></TAGINFO>";
bSuccess = bSuccess && EditCategory.AddInside("HIERARCHYDETAILS",sTagInfo);
}
else
{
// We have! it to the XML and then get the tagitem details as well!
sTagInfo << " TAGITEMID='" << iTagItemID << "' TAGITEMTYPE='" << sTagItemType << "'></TAGINFO>";
bSuccess = bSuccess && EditCategory.AddInside("HIERARCHYDETAILS",sTagInfo);
// Now get the tag items details
CTagItem TagItem(m_InputContext);
bool bOk = false;
if (sTagItemType.CompareText("USER"))
{
bOk = TagItem.InitialiseFromUserId(iTagItemID,iSiteID,pCurrentUser);
}
else if (sTagItemType.CompareText("THREAD"))
{
bOk = TagItem.InitialiseFromThreadId(iTagItemID,iSiteID,pCurrentUser);
}
else
{
bOk = TagItem.InitialiseItem(iTagItemID,m_InputContext.GetParamInt("tagitemtype"),iSiteID,pCurrentUser);
}
if (!bOk)
{
// Get the error from the object
bSuccess = bSuccess && EditCategory.AddInside("HIERARCHYDETAILS/TAGINFO",TagItem.GetLastErrorAsXMLString());
}
//Get taginfo
CTDVString sDetailsXML;
TagItem.GetItemDetailsXML(sDetailsXML);
bSuccess = bSuccess && EditCategory.AddInside("HIERARCHYDETAILS/TAGINFO",sDetailsXML);
// Get all the nodes that the item is currently tagged to.
if (bOk && TagItem.GetAllNodesTaggedForItem())
{
// Put the results into the XML
bSuccess = bSuccess && EditCategory.AddInside("HIERARCHYDETAILS/TAGINFO",&TagItem);
}
else
{
// Get the error from the object
bSuccess = bSuccess && EditCategory.AddInside("HIERARCHYDETAILS/TAGINFO",TagItem.GetLastErrorAsXMLString());
}
// Get all the nodes that the user has ever tagged to.
if (bOk && TagItem.GetNodesUserHasTaggedTo())
{
// Put the results into the XML
bSuccess = bSuccess && EditCategory.AddInside("HIERARCHYDETAILS/TAGINFO",&TagItem);
}
else
{
// Get the error from the object
bSuccess = bSuccess && EditCategory.AddInside("HIERARCHYDETAILS/TAGINFO",TagItem.GetLastErrorAsXMLString());
}
}
}
// Check to see if we're adding category nodes to cat lists
if (m_InputContext.ParamExists("catlistid"))
{
CTDVString sCatList, sGUID;
m_InputContext.GetParamString("catlistid",sGUID);
sCatList << "<CATEGORYLIST MODE='1' GUID='" << sGUID << "'/>";
bSuccess = bSuccess && EditCategory.AddInside("HIERARCHYDETAILS",sCatList);
}
}
}
//add the editcategory to the wholepage
if (bSuccess)
{
bSuccess = bSuccess && pPage->AddInside("H2G2",&EditCategory);
}
{//add search functionality
// Get the TagitemID and the TagType from the url
int iTagItemID = m_InputContext.GetParamInt("tagitemid");
CTDVString sTagItemType;
m_InputContext.GetParamString("tagitemtype",sTagItemType);
int iTagMode = m_InputContext.GetParamInt("tagmode");
int iSiteID = m_InputContext.GetSiteID();
int iActiveNode = m_InputContext.GetParamInt("activenode");
CUser* pCurrentUser = m_InputContext.GetCurrentUser();
CTDVString sActiveNode(iActiveNode), sNodeID(iNodeID), sTagMode(iTagMode), sTagItemID(iTagItemID);
bSuccess = bSuccess && pPage->AddInside("H2G2","<SEARCH></SEARCH>");
bSuccess = bSuccess && pPage->AddInside("H2G2/SEARCH", "<ACTION>" + sAction + "</ACTION>");
bSuccess = bSuccess && pPage->AddInside("H2G2/SEARCH", "<NODEID>" + sNodeID + "</NODEID>");
bSuccess = bSuccess && pPage->AddInside("H2G2/SEARCH", "<ACTIVENODE>" + sActiveNode + "</ACTIVENODE>");
bSuccess = bSuccess && pPage->AddInside("H2G2/SEARCH", "<TAGITEMID>" + sTagItemID + "</TAGITEMID>");
bSuccess = bSuccess && pPage->AddInside("H2G2/SEARCH", "<TAGMODE>" + sTagMode + "</TAGMODE>");
bSuccess = bSuccess && pPage->AddInside("H2G2/SEARCH", "<TAGITEMTYPE>" + sTagItemType + "</TAGITEMTYPE>");
if ( m_InputContext.ParamExists("searchstring") )
{
CTDVString sSearchString = "";
CTDVString sSearchType = "";
bool bGotSearchString = m_InputContext.GetParamString("searchstring", sSearchString);
//search type is always assumed to be hierarchial
if ( bGotSearchString)
{
bool bSearchItemsFound = false;
//detect postcode searches
if ( m_InputContext.GetAllowPostCodesInSearch() > 0 )
{
//detect if string is a postcode
CPostCodeParser oPostCodeParser ;
if (oPostCodeParser.IsPostCode(sSearchString))
{
CTDVString sActualPostCode ="";
CTDVString sActualPostCodeXML = "";
int iNode=0;
CNotice oNotice(m_InputContext);
int nRes = oNotice.GetDetailsForPostCodeArea(sSearchString, iSiteID, iNode, sActualPostCode, sActualPostCodeXML);
if (nRes == CNotice::PR_REQUESTOK)
{
if (iNode)
{
CTDVString sCategoryName;
CCategory oCategory(m_InputContext);
if ( oCategory.GetHierarchyName(iNode, sCategoryName) == false)
{
SetDNALastError("CEditCategoryBuilder::Build", "CatgeoryNotFound", "Could not be found Category's Name");
bSuccess = bSuccess && pPage->AddInside("H2G2",GetLastErrorAsXMLString());
return false;
}
bSuccess = bSuccess && pPage->AddInside("H2G2/SEARCH","<SEARCHRESULTS TYPE=\"HIERARCHY\"></SEARCHRESULTS>");
bSuccess = bSuccess && pPage->AddInside("H2G2/SEARCH/SEARCHRESULTS", "<ISPOSTCODE>1</FROMPOSTCODE>");
bSuccess = bSuccess && pPage->AddInside("H2G2/SEARCH/SEARCHRESULTS", "<SEARCHTERM>" + sActualPostCode + "</SEARCHTERM>");
CTDVString sSite(m_InputContext.GetSiteID( ));
CTDVString sCatgeory(iNode);
CTDVString sXML = "";
sXML += "<HIERARCHYRESULT>";
sXML += "<NODEID>" + sCatgeory + "</NODEID>";
sXML += "<DISPLAYNAME>" + sCategoryName + "</DISPLAYNAME>";
sXML += "<SITEID>" + sSite + "</SITEID>";
sXML += "</HIERARCHYRESULT>";
bSuccess = bSuccess && pPage->AddInside("SEARCH/SEARCHRESULTS", sXML);
bSearchItemsFound = true;
}
}
else if ( nRes == CNotice::PR_POSTCODENOTFOUND)
{
SetDNALastError("CEditCategoryBuilder::Build", "PostcodeNotFound", sSearchString + " could not be found");
bSuccess = bSuccess && pPage->AddInside("H2G2",GetLastErrorAsXMLString());
//return true;
}
else if (nRes == CNotice::PR_REQUESTTIMEOUT)
{
SetDNALastError("CEditCategoryBuilder::Build", "RequestTimedOut", "Request timed out");
bSuccess = bSuccess && pPage->AddInside("H2G2",GetLastErrorAsXMLString());
//return true;
}
}
else if ( oPostCodeParser.IsCloseMatch(sSearchString) )
{
SetDNALastError("CEditCategoryBuilder::Build", "PostCodeError", sSearchString + " looks like a post code, but it is invalid");
bSuccess = bSuccess && pPage->AddInside("H2G2",GetLastErrorAsXMLString());
//return true;
}
}
if ( bSearchItemsFound == false)
{
int iSkip = m_InputContext.GetParamInt("skip");
int iShow = m_InputContext.GetParamInt("show");
if (iShow == 0)
{
// default case... show 20 search results at a time
iShow = 20;
}
CSearch Search(m_InputContext);
Search.InitialiseHierarchySearch(sSearchString,iSiteID,iSkip,iShow);
//Add Search results to page.
bSuccess = bSuccess && pPage->AddInside("H2G2/SEARCH", &Search);
}
}
}
}
return bSuccess;
}
bool GuardianAI::ProcessEvent(CreatureEventAIHolder& pHolder, Unit* pActionInvoker, Creature* pAIEventSender /*=nullptr*/)
{
if (!pHolder.Enabled || pHolder.Time)
return false;
// Check the inverse phase mask (event doesn't trigger if current phase bit is set in mask)
if (pHolder.Event.event_inverse_phase_mask & (1 << m_Phase))
{
if (!IsTimerBasedEvent(pHolder.Event.event_type))
DEBUG_FILTER_LOG(LOG_FILTER_EVENT_AI_DEV, "CreatureEventAI: Event %u skipped because of phasemask %u. Current phase %u", pHolder.Event.event_id, pHolder.Event.event_inverse_phase_mask, m_Phase);
return false;
}
if (!IsTimerBasedEvent(pHolder.Event.event_type))
LOG_PROCESS_EVENT;
CreatureEventAI_Event const& event = pHolder.Event;
// Check event conditions based on the event type, also reset events
switch (event.event_type)
{
case EVENT_T_FRIENDLY_HP:
{
Unit* pUnit = DoSelectLowestHpFriendly((float)event.friendly_hp.radius, event.friendly_hp.hpDeficit, false);
if (!pUnit)
return false;
pActionInvoker = pUnit;
LOG_PROCESS_EVENT;
// Repeat Timers
pHolder.UpdateRepeatTimer(m_creature, event.friendly_hp.repeatMin, event.friendly_hp.repeatMax);
break;
}
default:
return CreatureEventAI::ProcessEvent(pHolder, pActionInvoker, pAIEventSender);
}
// Disable non-repeatable events
if (!(pHolder.Event.event_flags & EFLAG_REPEATABLE))
pHolder.Enabled = false;
// Store random here so that all random actions match up
uint32 rnd = rand();
// Return if chance for event is not met
if (pHolder.Event.event_chance <= rnd % 100)
return false;
// Process actions, normal case
if (!(pHolder.Event.event_flags & EFLAG_RANDOM_ACTION))
{
for (uint32 j = 0; j < MAX_ACTIONS; ++j)
ProcessAction(pHolder.Event.action[j], rnd, pHolder.Event.event_id, pActionInvoker, pAIEventSender);
}
// Process actions, random case
else
{
// amount of real actions
uint32 count = 0;
for (uint32 j = 0; j < MAX_ACTIONS; ++j)
if (pHolder.Event.action[j].type != ACTION_T_NONE)
++count;
if (count)
{
// select action number from found amount
uint32 idx = rnd % count;
// find selected action, skipping not used
uint32 j = 0;
for (; ; ++j)
{
if (pHolder.Event.action[j].type != ACTION_T_NONE)
{
if (!idx)
break;
--idx;
}
}
ProcessAction(pHolder.Event.action[j], rnd, pHolder.Event.event_id, pActionInvoker, pAIEventSender);
}
}
return true;
}
void RPG_ActionHandler::ProcessAction(RPG_ActionData const& actionData, bool const forceAction /*= false*/)
{
// if we're already doing the requested move, ignore the call except to update flags or interaction entities.
if (actionData.m_Action == m_activeAction.m_Action)
{
// same move, updated flags
if (actionData.m_Action != AT_None && actionData.m_flags != m_activeAction.m_flags)
{
m_activeAction.m_flags = actionData.m_flags;
//@todo: if this is happening on the authoritative server, replicate this flag change to clients.
if (m_Actions[actionData.m_Action])
{
m_Actions[actionData.m_Action]->UpdateFlags(actionData.m_flags);
}
}
// same move, updated interaction entity
if(actionData.m_interactionEntity != m_activeAction.m_interactionEntity ||
!actionData.m_interactionPosition.isIdentical(m_activeAction.m_interactionPosition))
{
m_activeAction.m_interactionEntity = actionData.m_interactionEntity;
m_activeAction.m_interactionPosition = actionData.m_interactionPosition;
if(m_Actions[actionData.m_Action])
{
m_Actions[actionData.m_Action]->UpdateInteraction(actionData.m_interactionEntity, actionData.m_interactionPosition);
// clear the pending action, as enough data has changed for the pending action to probably not be the desired behavior.
m_pendingAction.Clear();
}
}
// clear the pending action if this was forced
if(forceAction)
{
m_pendingAction.Clear();
}
// no further action required, since this isn't a new move.
return;
}
// if we're chaining from an action that needs to complete first, defer this action
if (m_endingAction)
{
m_pendingAction = actionData;
return;
}
// verify that we can do this move
if (actionData.m_Action != AT_None && !forceAction && !m_chainingAction && !CanPerformAction(actionData.m_Action))
{
Vision::Error.Warning("Cannot perform requested Action.");
return;
}
// ready to go.
m_previousAction = m_activeAction;
// stop the previous action, if any
if (m_activeAction.m_Action != AT_None)
{
m_endingAction = true;
m_activeAction.m_Action = AT_None;
RPG_ActionType_e nextAction = actionData.m_Action;
if (nextAction == AT_None && m_pendingAction.m_Action != AT_None)
{
nextAction = m_pendingAction.m_Action;
}
CleanUpAction(m_previousAction.m_Action, nextAction);
m_endingAction = false;
}
// if we need to start a pending action, do it now
if (actionData.m_Action == AT_None && m_pendingAction.m_Action != AT_None)
{
// Recursively Process the pending action if one exists.
m_chainingAction = true;
m_activeAction.m_Action = m_previousAction.m_Action; // restore this value, since the pending action call will need it.
ProcessAction(m_pendingAction);
m_chainingAction = false;
if (m_activeAction.m_Action == m_pendingAction.m_Action)
{
m_pendingAction.Clear();
return;
}
}
// set the new Action
m_activeAction = actionData;
// @todo: Once the network branch is in, replicate these values.
// - m_replicatedAction = m_activeAction;
// - force net update
if (m_activeAction.m_Action != AT_None)
{
StartAction(m_activeAction.m_Action, m_previousAction.m_Action, forceAction, m_activeAction.m_interactionEntity, m_activeAction.m_interactionPosition, m_activeAction.m_flags);
// if this was a forced action, clear any pending action, as this was an interrupt of the current action
if (forceAction)
{
m_pendingAction.Clear();
}
}
}
