BOOL CIOCPFileAccessor::QueryRead(ULONG64 StartPos,ULONG64 ReadSize)
{
if(m_FileHandle!=INVALID_HANDLE_VALUE)
{
while(ReadSize)
{
ULONG64_CONVERTER Pos;
Pos.QuadPart=StartPos;
ULONG64 PacketSize=ReadSize;
if(PacketSize>MAX_DATA_PACKET_SIZE)
PacketSize=MAX_DATA_PACKET_SIZE;
ReadSize-=PacketSize;
COverLappedObject * pOverLappedObject=GetServer()->CreateOverLappedObject();
if(pOverLappedObject==NULL)
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::创建Write用OverLappedObject失败！"));
PushError(FET_QUEUE_ERROR,FQEC_QUEUE_FULL);
return FALSE;
}
pOverLappedObject->SetType(IO_FILE_READ);
pOverLappedObject->SetIOCPEventRouter(m_pIOCPEventRouter);
pOverLappedObject->GetDataBuff()->SetUsedSize((int)PacketSize);
pOverLappedObject->SetParentID(GetID());
pOverLappedObject->GetOverlapped()->Offset=Pos.LowPart;
pOverLappedObject->GetOverlapped()->OffsetHigh=Pos.HighPart;
if(m_UseAsyncQuery)
{
if(!DoOverlappedOperation(pOverLappedObject))
{
GetServer()->DeleteOverLappedObject(pOverLappedObject);
return FALSE;
}
}
else
{
if(!m_RequestQueue.PushBack(pOverLappedObject))
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::请求缓冲队列已满！"));
GetServer()->DeleteOverLappedObject(pOverLappedObject);
PushError(FET_QUEUE_ERROR,FQEC_QUEUE_FULL);
return FALSE;
}
}
Pos.QuadPart+=PacketSize;
}
DoNextOverlappedOperation();
return TRUE;
}
return FALSE;
}
bool CMagicState::ValidCast(CSpell* PSpell, CBattleEntity* PTarget)
{
if (!CheckValidTarget(PTarget))
{
PushError(MSGBASIC_CANNOT_ON_THAT_TARG, 0);
return false;
}
if(!m_enableCasting ||
m_PEntity->StatusEffectContainer->HasStatusEffect(EFFECT_SILENCE) ||
m_PEntity->StatusEffectContainer->HasStatusEffect(EFFECT_MUTE))
{
PushError(MSGBASIC_UNABLE_TO_CAST_SPELLS, PSpell->getID());
return false;
}
if (PSpell->getSpellGroup() == SPELLGROUP_NINJUTSU)
{
if(m_PEntity->objtype == TYPE_PC && !(m_flags & MAGICFLAGS_IGNORE_TOOLS) && !battleutils::HasNinjaTool(m_PEntity, PSpell, false))
{
PushError(MSGBASIC_NO_NINJA_TOOLS, PSpell->getID());
return false;
}
}
// check has mp available
else if(!m_PEntity->StatusEffectContainer->HasStatusEffect(EFFECT_MANAFONT) && !(m_flags & MAGICFLAGS_IGNORE_MP) && CalculateMPCost(PSpell) > m_PEntity->health.mp)
{
if(m_PEntity->objtype == TYPE_MOB && m_PEntity->health.maxmp == 0)
{
ShowWarning("CMagicState::ValidCast Mob (%u) tried to cast magic with no mp!\n", m_PEntity->id);
}
PushError(MSGBASIC_NOT_ENOUGH_MP, PSpell->getID());
return false;
}
if (!spell::CanUseSpell(m_PEntity, PSpell->getID()))
{
PushError(MSGBASIC_CANNOT_CAST_SPELL, PSpell->getID());
return false;
}
if(PTarget->isDead() && !(PSpell->getValidTarget() & TARGET_PLAYER_DEAD))
{
return false;
}
if(!PTarget->isDead() && (PSpell->getValidTarget() & TARGET_PLAYER_DEAD))
{
return false;
}
return true;
}
BOOL CIOCPFileAccessor::DoOverlappedOperation(COverLappedObject * pOverLappedObject)
{
if(m_FileHandle!=INVALID_HANDLE_VALUE)
{
if(pOverLappedObject->GetType()==IO_FILE_READ)
{
if(!ReadFile(m_FileHandle,
pOverLappedObject->GetDataBuff()->GetBuffer(),
pOverLappedObject->GetDataBuff()->GetUsedSize(),
NULL,pOverLappedObject->GetOverlapped()))
{
int ErrorCode=GetLastError();
if(ErrorCode!=ERROR_IO_PENDING)
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::发出Read请求失败%d！"),ErrorCode);
PushError(FET_SYSTEM_ERROR,ErrorCode,
pOverLappedObject->GetOverlapped()->OffsetHigh,
pOverLappedObject->GetOverlapped()->Offset,
pOverLappedObject->GetDataBuff()->GetUsedSize());
return FALSE;
}
}
return TRUE;
}
else if(pOverLappedObject->GetType()==IO_FILE_WRITE)
{
if(!WriteFile(m_FileHandle,
pOverLappedObject->GetDataBuff()->GetBuffer(),
pOverLappedObject->GetDataBuff()->GetUsedSize(),
NULL,pOverLappedObject->GetOverlapped()))
{
int ErrorCode=GetLastError();
if(ErrorCode!=ERROR_IO_PENDING)
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::发出Write请求失败%d！"),ErrorCode);
PushError(FET_SYSTEM_ERROR,ErrorCode,
pOverLappedObject->GetOverlapped()->OffsetHigh,
pOverLappedObject->GetOverlapped()->Offset,
pOverLappedObject->GetDataBuff()->GetUsedSize());
return FALSE;
}
}
}
else
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::未知的Overlapped请求%d！"),pOverLappedObject->GetType());
PushError(FET_UNKNOW,0);
return FALSE;
}
}
return FALSE;
}
//==========================================================================================
// ExecHolder::Execute()
//==========================================================================================
// - Command function override
// - Holder "Autohold" state machine
//==========================================================================================
void ExecHolder::Execute() {
Robot::holder->Execute();
switch(state){
case WAIT_FOR_BALL_TO_ENTER:
WaitForBallToEnter();
break;
case GO_TO_FORWARD_LIMIT:
GoToForwardLimit();
break;
case WAIT_FOR_PUSH_REQUEST:
WaitForPushRequest();
break;
case WAIT_FOR_BALL_TO_LEAVE:
WaitForBallToLeave();
break;
case GO_TO_REVERSE_LIMIT:
GoToReverseLimit();
break;
case REMOVE_BALL:
RemoveBall();
break;
case PUSH_ERROR:
PushError();
break;
}
}
void
Str_PushError (MyStream * ms, const char * fmt, ...)
{
va_list args;
VA_START (args, fmt);
PushMsg (" ", fmt, args, NULL);
va_end (args);
PushError ("in %s:%d:", Str_GetName(ms), Str_GetLine(ms));
}
bool CState::IsOnCoolDown(uint32 tick)
{
if(tick - m_lastCoolTime < m_coolTime)
{
PushError(MSGBASIC_WAIT_LONGER);
return true;
}
return false;
}
bool CMagicState::CanCastSpell(CSpell* PSpell, CBattleEntity* PTarget, uint8 flags)
{
if(PSpell == NULL) return false;
if(!ValidCast(PSpell, PTarget))
{
return false;
}
if(m_PEntity->objtype == TYPE_PC)
{
float distanceValue = distance(m_PEntity->loc.p, PTarget->loc.p);
// pc has special messages
if(distanceValue > 25)
{
PushError(MSGBASIC_TOO_FAR_AWAY, PSpell->getID());
return false;
}
else if(distanceValue > m_maxStartDistance)
{
PushError(MSGBASIC_OUT_OF_RANGE_UNABLE_CAST, PSpell->getID());
return false;
}
}
else if(!m_PTargetFind->isWithinRange(&PTarget->loc.p, m_maxStartDistance)){
return false;
}
// player specific
if(m_PEntity->objtype == TYPE_PC && !ValidCharCast(PSpell))
{
return false;
}
int32 msgID = luautils::OnMagicCastingCheck(m_PEntity, PTarget, PSpell);
if(msgID){
PushError((MSGBASIC_ID)msgID, PSpell->getID());
return false;
}
return true;
}
bool CMagicState::CheckInterrupt()
{
if(m_interruptSpell)
{
PushMessage(MSGBASIC_IS_INTERRUPTED);
return true;
}
if(!m_PTargetFind->isWithinRange(&m_PTarget->loc.p, m_maxFinishDistance))
{
PushError(MSGBASIC_OUT_OF_RANGE_UNABLE_CAST, m_PSpell->getID());
return true;
}
// check if in same place
if(m_PEntity->objtype == TYPE_PC && HasMoved())
{
PushError(MSGBASIC_IS_INTERRUPTED, m_PSpell->getID());
return true;
}
if(!ValidCast(m_PSpell, m_PTarget))
{
return true;
}
if(battleutils::IsIntimidated(m_PEntity, m_PTarget))
{
PushMessage(MSGBASIC_IS_INTIMIDATED);
return true;
}
if(battleutils::IsParalyzed(m_PEntity))
{
PushMessage(MSGBASIC_IS_PARALYZED);
return true;
}
return false;
}
bool CState::CheckValidTarget(CBattleEntity* PTarget)
{
if(PTarget == NULL)
{
return false;
}
// is owner
if(!m_PTargetFind->isMobOwner(PTarget))
{
PushError(MSGBASIC_ALREADY_CLAIMED);
return false;
}
// pc only checks
if(m_PEntity->objtype == TYPE_PC)
{
// assert you cannot target pets for anything
if(PTarget->PMaster != NULL && PTarget->PMaster->objtype == TYPE_PC)
{
// this is someones pet. cannot target
PushError(MSGBASIC_THAT_SOMEONES_PET);
return false;
}
// act on battlefield targets unless I have it too
if(PTarget->StatusEffectContainer->HasStatusEffect(EFFECT_BATTLEFIELD) && !m_PEntity->StatusEffectContainer->HasStatusEffect(EFFECT_BATTLEFIELD))
{
PushError(MSGBASIC_CANNOT_ON_THAT_TARG);
return false;
}
}
if(PTarget->getZone() >= MAX_ZONEID || m_PEntity->getZone() >= MAX_ZONEID)
{
PushError(MSGBASIC_CANNOT_ON_THAT_TARG);
return false;
}
return !(m_PEntity->loc.zone == NULL || PTarget->getZone() != m_PEntity->getZone() || PTarget->IsNameHidden());
}
bool CMagicState::ValidCharCast(CSpell* PSpell)
{
CCharEntity* PChar = (CCharEntity*)m_PEntity;
// has spell and can use it
int16 spellID = PSpell->getID();
if (!charutils::hasSpell(PChar, spellID) || !spell::CanUseSpell(PChar, spellID))
{
PushError(MSGBASIC_CANNOT_CAST_SPELL, spellID);
return false;
}
// check recast
if (PChar->PRecastContainer->Has(RECAST_MAGIC, spellID))
{
PushError(MSGBASIC_UNABLE_TO_CAST, spellID);
return false;
}
// can use msic
if (!m_PEntity->loc.zone->CanUseMisc(PSpell->getZoneMisc()))
{
PushError(MSGBASIC_CANNOT_USE_IN_AREA, spellID);
return false;
}
// check summoning
if (PSpell->getSpellGroup() == SPELLGROUP_SUMMONING && PChar->PPet != NULL)
{
PushError(MSGBASIC_ALREADY_HAS_A_PET, spellID);
return false;
}
return true;
}
BOOL CIOCPFileAccessor::OnIOCPEvent(int EventID,COverLappedObject * pOverLappedObject)
{
if(m_FileHandle!=INVALID_HANDLE_VALUE)
{
if(EventID==IOE_PACKET)
{
if(pOverLappedObject->GetType()==IO_FILE_WRITE)
{
if(m_DataQueue.PushBack(pOverLappedObject))
{
if(!m_UseAsyncQuery)
{
if(!DoNextOverlappedOperation())
{
}
}
return TRUE;
}
else
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::数据队列已满！"));
PushError(FET_QUEUE_ERROR,FQEC_QUEUE_FULL,pOverLappedObject->GetType(),
pOverLappedObject->GetOverlapped()->OffsetHigh,
pOverLappedObject->GetOverlapped()->Offset,
pOverLappedObject->GetDataBuff()->GetUsedSize());
}
}
else if(pOverLappedObject->GetType()==IO_FILE_READ)
{
if(m_DataQueue.PushBack(pOverLappedObject))
{
if(!m_UseAsyncQuery)
{
if(!DoNextOverlappedOperation())
{
}
}
return TRUE;
}
else
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::数据队列已满！"));
PushError(FET_QUEUE_ERROR,FQEC_QUEUE_FULL,pOverLappedObject->GetType(),
pOverLappedObject->GetOverlapped()->OffsetHigh,
pOverLappedObject->GetOverlapped()->Offset,
pOverLappedObject->GetDataBuff()->GetUsedSize());
}
}
else
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::收到非法IOCP包！"));
PushError(FET_UNKNOW,0,
pOverLappedObject->GetOverlapped()->OffsetHigh,
pOverLappedObject->GetOverlapped()->Offset,
pOverLappedObject->GetDataBuff()->GetUsedSize());
}
}
else
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::收到IOCP错误！"));
PushError(FET_SYSTEM_ERROR,pOverLappedObject->GetErrorCode(),
pOverLappedObject->GetOverlapped()->OffsetHigh,
pOverLappedObject->GetOverlapped()->Offset,
pOverLappedObject->GetDataBuff()->GetUsedSize());
}
}
else
{
PrintNetLog(0xffffffff,_T("CIOCPFileAccessor::文件未打开IOCP包被忽略！"));
}
GetServer()->DeleteOverLappedObject(pOverLappedObject);
return TRUE;
}
BOOL CIOCPFileAccessor::Open(LPCTSTR lpFileName,
DWORD dwDesiredAccess,
DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition,
DWORD dwFlagsAndAttributes,
int DataQueueSize,
int RequestQueuSize,
int ErrorQueuSize)
{
if(m_FileHandle!=INVALID_HANDLE_VALUE)
{
Close();
}
if(GetServer()==NULL)
return FALSE;
if(m_pIOCPEventRouter==NULL)
{
m_pIOCPEventRouter=GetServer()->CreateEventRouter();
m_pIOCPEventRouter->Init(this);
}
if(!m_DataQueue.Create(DataQueueSize))
{
PrintNetLog(0,_T("CIOCPFileAccessor::创建数据缓冲失败"));
return FALSE;
}
if(RequestQueuSize==0)
{
m_UseAsyncQuery=true;
PrintNetLog(0,_T("CIOCPFileAccessor::开启异步请求模式"));
}
else
{
m_UseAsyncQuery=false;
if(!m_RequestQueue.Create(RequestQueuSize))
{
PrintNetLog(0,_T("CIOCPFileAccessor::创建请求缓冲失败"));
return FALSE;
}
}
if(!m_ErrorQueue.Create(ErrorQueuSize))
{
PrintNetLog(0,_T("CIOCPFileAccessor::创建错误缓冲失败"));
return FALSE;
}
dwFlagsAndAttributes|=FILE_FLAG_OVERLAPPED;
m_FileHandle=::CreateFile(lpFileName,dwDesiredAccess,dwShareMode,lpSecurityAttributes,
dwCreationDisposition,dwFlagsAndAttributes,NULL);
if(m_FileHandle==INVALID_HANDLE_VALUE)
{
UINT ErrorCode=GetLastError();
PrintNetLog(0,_T("CIOCPFileAccessor::打开文件失败%u"),ErrorCode);
PushError(FET_SYSTEM_ERROR,ErrorCode);
return FALSE;
}
if(!GetServer()->BindFile(m_FileHandle))
{
Close();
return FALSE;
}
m_ReadPosition.QuadPart=0;
m_WritePosition.QuadPart=0;
OnOpen();
return TRUE;
}
