void EventBrowser::Find(bool forward)
{
if(ui->findEvent->text().isEmpty())
return;
uint32_t curEID = m_Core->CurEvent();
if(!ui->events->selectedItems().isEmpty())
curEID = ui->events->selectedItems()[0]->data(COL_EID, Qt::UserRole).toUInt();
int eid = FindEvent(ui->findEvent->text(), curEID, forward);
if(eid >= 0)
{
SelectEvent((uint32_t)eid);
ui->findEvent->setStyleSheet("");
}
else // if(WrapSearch)
{
eid = FindEvent(ui->findEvent->text(), forward ? 0 : ~0U, forward);
if(eid >= 0)
{
SelectEvent((uint32_t)eid);
ui->findEvent->setStyleSheet("");
}
else
{
ui->findEvent->setStyleSheet("QLineEdit{background-color:#ff0000;}");
}
}
}
bool CBattleDust::CheckForMerging(CBattleEvent* pEvent)
{
FUNCTION_PROFILER(GetISystem(), PROFILE_GAME);
if(!g_pGameCVars->g_battleDust_enable)
return false;
if(!pEvent)
return false;
if(!gEnv->bServer)
return false;
// check if area can merge with nearby areas
for(std::list<EntityId>::iterator it = m_eventIdList.begin(); it != m_eventIdList.end(); ++it)
{
EntityId areaId = (*it);
CBattleEvent *pBattleArea = FindEvent(areaId);
if(!pBattleArea)
continue;
if(CheckIntersection(pEvent, pBattleArea->m_worldPos, pBattleArea->m_radius) && pBattleArea->m_radius > 0 && (pBattleArea != pEvent) && pBattleArea->GetEntity())
{
MergeAreas(pBattleArea, pEvent->m_worldPos, pEvent->m_radius);
return true;
}
}
return false;
}
int EventBrowser::FindEvent(QString filter, uint32_t after, bool forward)
{
if(!m_Core->LogLoaded())
return 0;
return FindEvent(ui->events->topLevelItem(0), filter, after, forward);
}
void CRecordPlayerDlg::WorkerMain()
{
int nEvents = m_Record.GetEventCount();
if (!nEvents) // if no events
return; // nothing to do
UINT nTrackPorts = m_TrackMap.GetSize();
// convert start position from relative milliseconds to relative counts
LONGLONG StartPos = MillisToCount(m_StartPos);
int iFirst = FindEvent(StartPos); // find event at or after start position
iFirst = max(iFirst, 0); // enforce event range
LONGLONG tStart = GetPerfCount(); // get start time in absolute counts
m_StartCount = tStart; // store start time
tStart -= StartPos; // deduct start position from start time
for (int iEvent = iFirst; iEvent < nEvents; iEvent++) { // for each event
// convert event's relative time to target time in absolute counts
LONGLONG tTarget = m_EventTime[iEvent] + tStart;
do { // spin
if (m_Worker.GetStopFlag()) // if stop requested
return;
} while (GetPerfCount() < tTarget); // while current time less than target
const CMidiRecord::EVENT& ev = m_Record[iEvent];
if (ev.Port < nTrackPorts) { // if event port within track map range
// use event's port and channel to look up track index
int iTrack = m_TrackMap[ev.Port].TrackIdx[MIDI_CHAN(ev.Msg)];
if (m_TrackEnable[iTrack]) { // if track enabled
gEngine.OutputMidi(m_Track[iTrack].m_Inst,
MIDI_CMD(ev.Msg), MIDI_P1(ev.Msg), MIDI_P2(ev.Msg));
}
}
}
}
int EventBrowser::FindEvent(QTreeWidgetItem *parent, QString filter, uint32_t after, bool forward)
{
if(parent == NULL)
return -1;
for(int i = forward ? 0 : parent->childCount() - 1; i >= 0 && i < parent->childCount();
i += forward ? 1 : -1)
{
auto n = parent->child(i);
uint eid = n->data(COL_EID, Qt::UserRole).toUInt();
bool matchesAfter = (forward && eid > after) || (!forward && eid < after);
if(matchesAfter)
{
QString name = n->text(COL_NAME);
if(name.contains(filter, Qt::CaseInsensitive))
return (int)eid;
}
if(n->childCount() > 0)
{
int found = FindEvent(n, filter, after, forward);
if(found > 0)
return found;
}
}
return -1;
}
void CBattleDust::Update()
{
FUNCTION_PROFILER(GetISystem(), PROFILE_GAME);
if(!g_pGameCVars->g_battleDust_enable)
{
RemoveAllEvents();
return;
}
if(!gEnv->bServer)
return;
if(g_pGameCVars->g_battleDust_debug != 0)
{
float col[] = {1,1,1,1};
gEnv->pRenderer->Draw2dLabel(50, 40, 2.0f, col, false, "Num BD areas: %d (max %d)", (int32)m_eventIdList.size(), m_maxBattleEvents);
}
float ypos = 60.0f;
// go through the list of areas, remove any which are too small
m_maxBattleEvents = MAX(m_maxBattleEvents, m_eventIdList.size());
std::list<EntityId>::iterator next;
std::list<EntityId>::iterator it = m_eventIdList.begin();
for(; it != m_eventIdList.end(); it = next)
{
next = it; ++next;
EntityId areaId = (*it);
CBattleEvent *pBattleArea = FindEvent(areaId);
if(!pBattleArea)
continue;
if(pBattleArea->m_lifetime > 0.0f)
{
pBattleArea->m_lifeRemaining -= gEnv->pTimer->GetFrameTime();
pBattleArea->m_radius = pBattleArea->m_peakRadius * (pBattleArea->m_lifeRemaining / pBattleArea->m_lifetime);
}
if(g_pGameCVars->g_battleDust_debug != 0)
{
float col[] = {1,1,1,1};
gEnv->pRenderer->Draw2dLabel(50, ypos, 1.4f, col, false, "Area: (%.2f, %.2f, %.2f), Radius: %.2f/%.2f, Particles: %.0f, Lifetime: %.2f/%.2f", pBattleArea->m_worldPos.x, pBattleArea->m_worldPos.y, pBattleArea->m_worldPos.z, pBattleArea->m_radius, pBattleArea->m_peakRadius, pBattleArea->m_numParticles, pBattleArea->m_lifeRemaining, pBattleArea->m_lifetime);
ypos += 10.0f;
}
if(pBattleArea->m_lifeRemaining < 0.0f)
{
// remove it (NB this will also call RemoveBattleArea(), which will remove it from the list)
gEnv->pEntitySystem->RemoveEntity(areaId);
}
else
{
if(pBattleArea->GetEntity())
{
UpdateParticlesForArea(pBattleArea);
}
}
}
}
// ---------------------------------------------------------------------------
// Find CCsConversationEvent based on ConversationEntryId and delete it.
// ---------------------------------------------------------------------------
//
void CCsConversationCacheHelper::DeleteEvent(
const CCsConversationEvent& aConvEvent)
{
TInt index = FindEvent(aConvEvent);
if (KErrNotFound != index)
{
CCsConversationEvent* conversationEvent =
(*iConversationEventList)[index];
iConversationEventList->Remove(index);
delete conversationEvent;
}
}
ULONG STREAM::DisableEvent(PDDCMDCONTROL pControl)
{
pTrace->vLog(DDCMD_DisableEvent,pControl->hEvent);
PEVENT pevent = FindEvent(pControl->hEvent, &qhEvent);
if (!pevent)
return ERROR_INVALID_EVENT;
// destroying an event may change things that get referenced in the ISR
// so we really need to cli/sti around the call to DestroyElement
_cli_();
qhEvent.DestroyElement((PQUEUEELEMENT)pevent);
if (qhEvent.Head() != qhEvent.Tail())
SetNextEvent();
_sti_();
return NO_ERROR;
}
ULONG STREAM::EnableEvent(PDDCMDCONTROL pControl)
{
// see if the event already exists on the event queue
// call FindEvent if we get back an address (event exists)
// call the UpdateEvent member function and get the event info updated.
// if Findevent returns NULL (no event on queue) then call the construct
// a new event and put it on the tail of the event queue. then call
// SetNextEvent to update the next event to time out....
PEVENT pevent = FindEvent(pControl->hEvent, &qhEvent);
if (pevent)
pevent->UpdateEvent(this,pControl->hEvent,(PCONTROL_PARM)pControl->pParm);
else {
pevent= new EVENT(this,pControl->hEvent,(PCONTROL_PARM)pControl->pParm);
}
if (!pevent)
return ERROR_TOO_MANY_EVENTS;
SetNextEvent();
return NO_ERROR;
}
T_void CompileEvent(T_byte8 *p_event)
{
T_sword16 value ;
p_event[strlen(p_event)-1] = '\0' ;
value = FindEvent(p_event) ;
if (value == -1) {
printf("Error! Event '%s' unknown on line %d",
p_event,
G_line) ;
G_errors++ ;
} else {
if (G_eventPlaces[value] == 0xFFFF) {
G_eventPlaces[value] = G_place ;
} else {
printf("Error! Event '%s' already defined (line %d)\n",
p_event,
G_line) ;
G_errors++ ;
}
}
}
Trigger* MainEventPool::CreateTrigger(XmlNode* trigNode)
{
const char* trigName = XmlUtility::XmlGetString(trigNode, "name");
Trigger* trigger = xNew1(Trigger, trigName);
XmlNode* evtNode = trigNode->first_node("Event");
if(evtNode != 0) // Trigger may not have and event
{
trigger->SetEvent(FindEvent(evtNode));
}
XmlNode* actsNode = trigNode->first_node("Actions", 7);
MultiAction* actions = xNew0(MultiAction);
XmlNode* actNode = actsNode->first_node("Action", 6);
while (actNode != 0)
{
actions->AddAction(CreateAction(actNode));
actNode = actNode->next_sibling();
}
trigger->SetActions(actions);
return trigger;
}
ULONG STREAM::Control(PDDCMDCONTROL p)
{
switch (p->ulCmd) {
case DDCMD_START:
Trace(TRACE_DDCMD_CNTRL_START, 0);
if (!Start())
return ERROR_START_STREAM;
fPaused = FALSE;
fActive = TRUE;
break;
case DDCMD_STOP:
Trace(TRACE_DDCMD_CNTRL_STOP, 0);
Stop();
ReturnBuffers();
fPaused = FALSE;
fActive = FALSE;
p->pParm = &ulCurrentTime;
p->ulParmSize = sizeof(ULONG);
break;
case DDCMD_PAUSE:
Trace(TRACE_DDCMD_CNTRL_PAUSE, fPaused);
if (fPaused) return ERROR_INVALID_SEQUENCE;
Pause();
fPaused = TRUE;
fActive = FALSE;
p->pParm = &ulCurrentTime;
p->ulParmSize = sizeof(ULONG);
break;
case DDCMD_RESUME:
Trace(TRACE_DDCMD_CNTRL_RESUME, fPaused);
if (!fPaused) return ERROR_INVALID_SEQUENCE;
Resume();
fPaused = FALSE;
fActive = TRUE;
break;
case DDCMD_ENABLE_EVENT: {
Trace(TRACE_DDCMD_CNTRL_EVENT_ON, p->hEvent);
EVENT *pevent = FindEvent(p->hEvent);
if (pevent)
pevent = new (pevent) EVENT(this,p->hEvent,(PCONTROL_PARM) p->pParm);
else
pevent = new EVENT(this,p->hEvent,(PCONTROL_PARM) p->pParm);
if (!pevent)
return ERROR_TOO_MANY_EVENTS;
break;
}
case DDCMD_DISABLE_EVENT: {
Trace(TRACE_DDCMD_CNTRL_EVENT_OFF, p->hEvent);
EVENT *pevent=FindEvent(p->hEvent);
if (!pevent)
return ERROR_INVALID_EVENT;
delete pevent;
break;
}
case DDCMD_PAUSE_TIME:
Trace(TRACE_DDCMD_CNTRL_PAUSE_TIME, ulCurrentTime);
fIncrementCounter = FALSE;
break;
case DDCMD_RESUME_TIME:
Trace(TRACE_DDCMD_CNTRL_RESUME_TIME, ulCurrentTime);
fIncrementCounter = TRUE;
break;
}
return 0;
}
// Update bot based on goals
void _Bot::EvaluateGoal() {
// Respawn
if(!Player->WaitForServer && !Player->IsAlive()) {
_Buffer Packet;
Packet.Write<PacketType>(PacketType::WORLD_RESPAWN);
Network->SendPacket(Packet);
Player->WaitForServer = true;
return;
}
// Evaluate goal
switch(GoalState) {
case GoalStateType::NONE:
DetermineNextGoal();
break;
case GoalStateType::FARMING:
if(Map->NetworkID != 11) {
if(Map->NetworkID != 10) {
glm::ivec2 Position;
if(FindEvent(_Event(_Map::EVENT_MAPCHANGE, 10), Position))
MoveTo(Player->Position, Position);
}
else if(Map->NetworkID == 10) {
glm::ivec2 Position;
if(FindEvent(_Event(_Map::EVENT_MAPCHANGE, 11), Position))
MoveTo(Player->Position, Position);
}
}
else if(Map->NetworkID == 11) {
glm::ivec2 Position;
if(FindEvent(_Event(_Map::EVENT_SCRIPT, 3), Position))
MoveTo(Player->Position, Position);
}
else {
BotState = BotStateType::MOVE_RANDOM;
}
break;
case GoalStateType::HEALING:
if(Map->NetworkID != 1) {
if(!Player->WaitForServer && Player->CanTeleport()) {
_Buffer Packet;
Packet.Write<PacketType>(PacketType::PLAYER_STATUS);
Packet.Write<uint8_t>(_Object::STATUS_TELEPORT);
Network->SendPacket(Packet);
Player->WaitForServer = true;
}
}
else {
if(Player->GetHealthPercent() < 1.0f) {
glm::ivec2 Position;
if(FindEvent(_Event(_Map::EVENT_SCRIPT, 1), Position)) {
if(Player->Position == Position)
BotState = BotStateType::MOVE_HEAL;
else
MoveTo(Player->Position, Position);
}
}
else
DetermineNextGoal();
}
break;
}
}
void CBattleDust::RecordEvent(EBattleDustEventType event, Vec3 worldPos, const IEntityClass* pClass)
{
FUNCTION_PROFILER(GetISystem(), PROFILE_GAME);
if(!g_pGameCVars->g_battleDust_enable)
return;
if(!gEnv->bServer)
return;
// this typically means the xml file failed to load. Turn off the dust.
if(m_maxParticleCount == 0)
return;
SBattleEventParameter param;
if(!GetEventParams(event, pClass, param))
return;
if(param.m_power == 0 || worldPos.IsEquivalent(Vec3(0,0,0)))
return;
if(m_pBattleEventClass == NULL)
m_pBattleEventClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass( "BattleEvent" );
// first check if we need a new event
bool newEvent = true;
for(std::list<EntityId>::iterator it = m_eventIdList.begin(); it != m_eventIdList.end(); ++it)
{
EntityId areaId = (*it);
CBattleEvent *pBattleArea = FindEvent(areaId);
if(pBattleArea && CheckIntersection(pBattleArea, worldPos, param.m_power))
{
// don't need a new event as this one is within an existing one. Just merge them.
MergeAreas(pBattleArea, worldPos, param.m_power);
pBattleArea->m_lifeRemaining += param.m_lifetime;
pBattleArea->m_lifetime = pBattleArea->m_lifeRemaining;
pBattleArea->m_lifetime = CLAMP(pBattleArea->m_lifetime, 0.0f, m_maxLifetime);
pBattleArea->m_lifeRemaining = CLAMP(pBattleArea->m_lifeRemaining, 0.0f, m_maxLifetime);
newEvent = false;
break;
}
}
if(newEvent)
{
IEntitySystem * pEntitySystem = gEnv->pEntitySystem;
SEntitySpawnParams esp;
esp.id = 0;
esp.nFlags = 0;
esp.pClass = m_pBattleEventClass;
if (!esp.pClass)
return;
esp.pUserData = NULL;
esp.sName = "BattleDust";
esp.vPosition = worldPos;
// when CBattleEvent is created it will add itself to the list
IEntity * pEntity = pEntitySystem->SpawnEntity( esp );
if(pEntity)
{
// find the just-added entity in the list, and set it's properties
IGameObject* pGO = g_pGame->GetIGameFramework()->GetGameObject(pEntity->GetId());
if(pGO)
{
CBattleEvent* pNewEvent = static_cast<CBattleEvent*>(pGO->QueryExtension("BattleEvent"));
if(pNewEvent)
{
pNewEvent->m_radius = param.m_power;
pNewEvent->m_peakRadius = param.m_power;
pNewEvent->m_lifetime = param.m_lifetime;
pNewEvent->m_lifeRemaining = param.m_lifetime;
pNewEvent->m_worldPos = worldPos;
pNewEvent->m_lifetime = CLAMP(pNewEvent->m_lifetime, 0.0f, m_maxLifetime);
pNewEvent->m_lifeRemaining = CLAMP(pNewEvent->m_lifeRemaining, 0.0f, m_maxLifetime);
pGO->ChangedNetworkState(CBattleEvent::PROPERTIES_ASPECT);
}
}
}
}
}
// Check for events
void _Map::CheckEvents(_Object *Object) {
// Check for teleporting
if(Server && Object->TeleportTime == 0.0) {
Object->TeleportTime = -1.0;
Object->Status = _Object::STATUS_NONE;
Server->SpawnPlayer(Object, Object->SpawnMapID, _Map::EVENT_SPAWN);
return;
}
// Handle events
const _Tile *Tile = &Tiles[Object->Position.x][Object->Position.y];
switch(Tile->Event.Type) {
case _Map::EVENT_SPAWN:
Object->SpawnMapID = NetworkID;
Object->SpawnPoint = Tile->Event.Data;
break;
case _Map::EVENT_MAPENTRANCE:
case _Map::EVENT_MAPCHANGE:
if(Server)
Server->SpawnPlayer(Object, (NetworkIDType)Tile->Event.Data, _Map::EVENT_MAPENTRANCE);
else
Object->WaitForServer = true;
break;
case _Map::EVENT_VENDOR: {
if(Server) {
Object->Vendor = Server->Stats->GetVendor(Tile->Event.Data);
// Notify client
_Buffer Packet;
Packet.Write<PacketType>(PacketType::EVENT_START);
Packet.Write<uint32_t>(Tile->Event.Type);
Packet.Write<uint32_t>(Tile->Event.Data);
Packet.Write<glm::ivec2>(Object->Position);
Server->Network->SendPacket(Packet, Object->Peer);
}
else
Object->WaitForServer = true;
} break;
case _Map::EVENT_TRADER: {
if(Server) {
Object->Trader = Server->Stats->GetTrader(Tile->Event.Data);
// Notify client
_Buffer Packet;
Packet.Write<PacketType>(PacketType::EVENT_START);
Packet.Write<uint32_t>(Tile->Event.Type);
Packet.Write<uint32_t>(Tile->Event.Data);
Packet.Write<glm::ivec2>(Object->Position);
Server->Network->SendPacket(Packet, Object->Peer);
}
else
Object->WaitForServer = true;
} break;
case _Map::EVENT_SCRIPT: {
if(Server)
Server->RunEventScript(Tile->Event.Data, Object);
} break;
case _Map::EVENT_PORTAL: {
if(Server) {
// Find matching even/odd event
FindEvent(_Event(Tile->Event.Type, Tile->Event.Data ^ 1), Object->Position);
Server->SendPlayerPosition(Object->Peer);
}
else
Object->WaitForServer = true;
} break;
case _Map::EVENT_JUMP: {
if(Server) {
// Find next jump
FindEvent(_Event(Tile->Event.Type, Tile->Event.Data + 1), Object->Position);
Server->SendPlayerPosition(Object->Peer);
}
else
Object->WaitForServer = true;
} break;
default:
if(Server) {
Object->Vendor = nullptr;
Object->Trader = nullptr;
if(Object->NextBattle <= 0) {
Server->QueueBattle(Object, Tile->Zone, false);
}
}
break;
}
}
void EventController :: RunLoop ()
{
bool Running = true;
bool EventWait;
void * Message;
RunLoopThread = Thread :: GetCurrentThread ();
RunningPointer = & Running;
StateSync.Lock ();
State = kControllerState_Running;
StateSync.Unlock ();
InsertionQueue.ReceiveMessage ( & Message );
do
{
if ( Message == reinterpret_cast <void *> ( const_cast <int *> ( & AREF_KILL ) ) )
{
Running = false;
EventWait = false;
StateSync.Lock ();
State = kControllerState_Dead;
StateSync.Unlock ();
StateChange.Signal ();
}
else if ( Message == reinterpret_cast <void *> ( const_cast <int *> ( & AREF_PAUSE ) ) )
{
StateSync.Lock ();
State = kControllerState_Paused;
StateSync.Unlock ();
StateChange.Signal ();
InsertionQueue.ReceiveMessage ( & Message );
EventWait = false;
}
else if ( Message == reinterpret_cast <void *> ( const_cast <int *> ( & AREF_PAUSE_AND_DISCARD ) ) )
{
StateSync.Lock ();
State = kControllerState_Paused;
StateSync.Unlock ();
StateChange.Signal ();
ScheduleList.Clear ();
InsertionQueue.ReceiveMessage ( & Message );
EventWait = false;
}
else if ( Message == reinterpret_cast <void *> ( const_cast <int *> ( & AREF_RESUME ) ) )
{
StateSync.Lock ();
State = kControllerState_Running;
StateSync.Unlock ();
StateChange.Signal ();
if ( ScheduleList.Length () != 0 )
{
bool WaitReceive = false;
while ( ! WaitReceive && ScheduleList.Length () != 0 )
{
ScheduleRecord Record = ScheduleList [ 0 ];
uint64_t CurrentTime = Clock :: GetTimeMonotonicMS ();
if ( Record.TimeMS <= CurrentTime )
{
NextEvent = FindEvent ( Record.Type );
if ( NextEvent != NULL )
{
NextEvent -> Trigger ();
NextEvent = NULL;
}
if ( ScheduleList [ 0 ].DeallocTypeString )
free ( ScheduleList [ 0 ].Type );
ScheduleList.Shift ();
}
else
{
NextEventMS = Record.TimeMS;
NextEvent = FindEvent ( Record.Type );
if ( NextEvent != NULL )
WaitReceive = true;
}
}
if ( NextEvent != NULL )
EventWait = true;
else
{
InsertionQueue.ReceiveMessage ( & Message );
EventWait = false;
}
}
else
{
InsertionQueue.ReceiveMessage ( & Message );
EventWait = false;
}
}
else
{
//ScheduleRecord TempRecord;
}
if ( EventWait )
{
uint64_t CurrentTime = Clock :: GetTimeMonotonicMS ();
uint64_t Delta = NextEventMS - CurrentTime;
if ( NextEventMS > CurrentTime )
{
while ( ! InsertionQueue.TryReceiveMessage ( & Message, static_cast <double> ( Delta ) / 1000 ) )
{
if ( ScheduleList [ 0 ].DeallocTypeString )
free ( ScheduleList [ 0 ].Type );
ScheduleList.Shift ();
NextEvent -> Trigger ();
NextEvent = NULL;
if ( ScheduleList.Length () != 0 )
{
NextEvent = FindEvent ( ScheduleList [ 0 ].Type );
NextEventMS = ScheduleList [ 0 ].TimeMS;
CurrentTime = Clock :: GetTimeMonotonicMS ();
Delta = NextEventMS - CurrentTime;
}
else
break;
}
}
}
}
while ( Running );
while ( ScheduleList.Length () != 0 )
{
ScheduleRecord Record = ScheduleList.Shift ();
if ( Record.DeallocTypeString )
free ( Record.Type );
}
};
