int CLifeStone::CreateLifeStone(int iIndex)
{
LPOBJ lpObj = &gObj[iIndex];
int iMonsterIndex = -1;
BYTE cX = lpObj->X;
BYTE cY = lpObj->Y;
if ( g_CastleSiegeSync.GetCastleState() != CASTLESIEGE_STATE_STARTSIEGE )
{
MsgOutput(iIndex, lMsg.Get(1645));
return FALSE;
}
if ( lpObj->GuildStatus != G_MASTER )
{
return FALSE;
}
if ( lpObj->m_btCsJoinSide < 2 )
{
MsgOutput(iIndex, lMsg.Get(1641)); //HermeX Fix
return FALSE;
}
if ( lpObj->lpGuild->lpLifeStone ) //HermeX Fix
{
MsgOutput(iIndex, lMsg.Get(1642)); //HermeX Fix
return FALSE;
}
if( cX > 150 && cX < 210 && cY > 175 && cY < 230 )
{
MsgOutput(iIndex, lMsg.Get(1644)); //HermeX Fix
return FALSE;
}
BYTE btMapAttr = MapC[lpObj->MapNumber].GetAttr(cX, cY);
if ( btMapAttr & 16 != 16 ) //siege camp?
{
//return FALSE;
}
if ( gObj[iIndex].MapNumber != MAP_INDEX_CASTLESIEGE )
{
MsgOutput(iIndex, lMsg.Get(1627)); //HermeX Fix
return FALSE;
}
iMonsterIndex = gObjAddMonster(lpObj->MapNumber);
if ( iMonsterIndex >= 0 )
{
MONSTER_ATTRIBUTE * MAttr = gMAttr.GetAttr(278);
if ( MAttr == NULL )
{
gObjDel(iMonsterIndex);
return FALSE;
}
gObjSetMonster(iMonsterIndex, 278);
gObj[iMonsterIndex].Live = TRUE;
gObj[iMonsterIndex].Life = MAttr->m_Hp;
gObj[iMonsterIndex].MaxLife = MAttr->m_Hp;
gObj[iMonsterIndex].m_PosNum = -1;
gObj[iMonsterIndex].X = cX;
gObj[iMonsterIndex].Y = cY;
gObj[iMonsterIndex].MTX = cX;
gObj[iMonsterIndex].MTY = cY;
gObj[iMonsterIndex].TX = cX;
gObj[iMonsterIndex].TY = cY;
gObj[iMonsterIndex].m_OldX = cX;
gObj[iMonsterIndex].m_OldY = cY;
gObj[iMonsterIndex].StartX = cX;
gObj[iMonsterIndex].StartY = cY;
gObj[iMonsterIndex].MapNumber = lpObj->MapNumber;
gObj[iMonsterIndex].m_MoveRange = 0;
gObj[iMonsterIndex].Level = MAttr->m_Level;
gObj[iMonsterIndex].Type = OBJ_MONSTER;
gObj[iMonsterIndex].MaxRegenTime = 1000;
gObj[iMonsterIndex].Dir = 1;
gObj[iMonsterIndex].RegenTime = GetTickCount();
gObj[iMonsterIndex].m_Attribute = 0;
gObj[iMonsterIndex].DieRegen = 0;
gObj[iMonsterIndex].m_btCsNpcType = OBJ_NPC; //HermeX Fix
gObj[iMonsterIndex].m_btCsJoinSide = lpObj->m_btCsJoinSide;
gObj[iMonsterIndex].lpGuild = lpObj->lpGuild;
gObj[iMonsterIndex].m_btCreationState = 0;
lpObj->lpGuild->lpLifeStone = &gObj[iMonsterIndex]; //SirMaster Fix
gObj[iMonsterIndex].m_iCreatedActivationTime = 0; //new
MsgOutput(iIndex, lMsg.Get(1646));
LogAddTD("[CastleSiege] LifeStone is created - [%s] [%s][%s] (Map:%d)(X:%d, Y:%d)",lpObj->lpGuild->Name,
lpObj->AccountID,lpObj->Name,lpObj->MapNumber,cX,cY);
lpObj->m_btLifeStoneCount++;
}
else
{
MsgOutput(iIndex, lMsg.Get(1647));
return FALSE;
}
return TRUE;
}
//00414B10 - identical
BOOL CKalimaGate::CreateKalimaGate(int iIndex, BYTE btLevel, BYTE cTX, BYTE cTY)
{
BOOL bKalimaGateCreateSucceed=FALSE;
int iMonsterIndex=-1;
EnterCriticalSection(&this->m_critKalimaGate );
__try
{
int iKalimaGateLevel;
int iMapNumber;
BYTE btMapAttr;
int iMonsterType;
BYTE cX;
BYTE cY;
if ( gObjIsConnected(iIndex) == PLAYER_EMPTY )
{
return false;
}
LogAddTD("[Kalima] [%s][%s] Try to Create Kalima Gate", gObj[iIndex].AccountID, gObj[iIndex].Name);
iKalimaGateLevel = this->GetKalimaGateLevel(iIndex);
if ( iKalimaGateLevel < btLevel-1 )
{
return false;
}
iKalimaGateLevel = btLevel-1;
if ( DS_MAP_RANGE(gObj[iIndex].MapNumber) )
{
return false;
}
if ( BC_MAP_RANGE(gObj[iIndex].MapNumber) )
{
return false;
}
if ( CC_MAP_RANGE(gObj[iIndex].MapNumber) )
{
return false;
}
if ( CHECK_ILLUSIONTEMPLE(gObj[iIndex].MapNumber) )//NEW
{
return false;
}
#ifdef IMPERIAL
if( CImperialGuardian::IsEventMap(gObj[iIndex].MapNumber) )
{
return false;
}
#endif
if ( KALIMA_FLOOR_RANGE(iKalimaGateLevel)== FALSE )
{
LogAddTD("[Kalima] [%s][%s] Failed to Summon Kalima Gate - Gate Level Check Error : %d",
gObj[iIndex].AccountID, gObj[iIndex].Name, iKalimaGateLevel+1);
return false;
}
iMapNumber = gObj[iIndex].MapNumber;
btMapAttr = MapC[iMapNumber].GetAttr(gObj[iIndex].X, gObj[iIndex].Y);
if ( btMapAttr &1 != 0 )
{
LogAddTD("[Kalima] [%s][%s] Failed to Summon Kalima Gate - Called in Saftey Area (Map:%d, X:%d, Y:%d)",
gObj[iIndex].AccountID, gObj[iIndex].Name, gObj[iIndex].MapNumber,
gObj[iIndex].X, gObj[iIndex].Y);
return false;
}
if ( gObj[iIndex].m_cKalimaGateExist == TRUE )
{
GCServerMsgStringSend(lMsg.Get( MSGGET( 4, 224)), iIndex, 1);
LogAddTD("[Kalima] [%s][%s] Failed to Summon Kalima Gate - Already Have Gate (SummonIndex:%d)",
gObj[iIndex].AccountID, gObj[iIndex].Name, gObj[iIndex].m_iKalimaGateIndex);
return false;
}
iMonsterType = iKalimaGateLevel+152;
cX = cTX;
cY = cTY;
btMapAttr = MapC[iMapNumber].GetAttr(cX, cY);
if ( btMapAttr != 0 )
{
if (this->GetRandomLocation(iMapNumber, cX, cY) == 0)
{
LogAddTD("[Kalima] [%s][%s] Failed to Summon Kalima Gate - Failed to get Location (MapNumber:%d, X:%d, Y:%d)",
gObj[iIndex].AccountID, gObj[iIndex].Name, gObj[iIndex].MapNumber, cX, cY);
return false;
}
}
if ( gObj[iIndex].MapNumber == 10 )
{
LogAddTD("[Kalima] [%s][%s] Failed to Summon Kalima Gate - Uable to Summon in this Map (MapNumber:%d)",
gObj[iIndex].AccountID, gObj[iIndex].Name, gObj[iIndex].MapNumber);
return false;
}
iMonsterIndex = gObjAddMonster(iMapNumber);
if ( iMonsterIndex >= 0 )
{
LPMONSTER_ATTRIBUTE lpMATTR = gMAttr.GetAttr(iMonsterType);
if ( lpMATTR == NULL )
{
gObjDel(iMonsterIndex);
LogAddTD("[Kalima] [%s][%s] Kalima Gate Vanished - lpMATTR == NULL (SummonIndex:%d)",
gObj[iIndex].AccountID, gObj[iIndex].Name, iMonsterIndex);
return false;
}
gObjSetMonster(iMonsterIndex, iMonsterType);
gObj[iMonsterIndex].Live = TRUE;
gObj[iMonsterIndex].Life = 1000.0;
gObj[iMonsterIndex].MaxLife = 1000.0;
gObj[iMonsterIndex].m_PosNum = -1;
gObj[iMonsterIndex].X = cX;
gObj[iMonsterIndex].Y = cY;
gObj[iMonsterIndex].MTX = cX;
gObj[iMonsterIndex].MTY = cY;
gObj[iMonsterIndex].TX = cX;
gObj[iMonsterIndex].TY = cY;
gObj[iMonsterIndex].m_OldX = cX;
gObj[iMonsterIndex].m_OldY = cY;
gObj[iMonsterIndex].StartX = cX;
gObj[iMonsterIndex].StartY = cY;
gObj[iMonsterIndex].MapNumber = iMapNumber;
gObj[iMonsterIndex].m_MoveRange = 0;
gObj[iMonsterIndex].m_cKalimaGateEnterCount = 0;
gObj[iIndex].m_cKalimaGateExist = TRUE;
gObj[iIndex].m_iKalimaGateIndex = iMonsterIndex;
gObj[iMonsterIndex].Level = lpMATTR->m_Level;
gObj[iMonsterIndex].Type = OBJ_MONSTER;
gObj[iMonsterIndex].MaxRegenTime = 1000;
gObj[iMonsterIndex].Dir = 1;
gObj[iMonsterIndex].m_RecallMon = iIndex;
gObj[iMonsterIndex].RegenTime = GetTickCount();
gObj[iMonsterIndex].m_Attribute = iKalimaGateLevel + 51;
gObj[iMonsterIndex].DieRegen = FALSE;
LogAddTD("[Kalima] [%s][%s] Create Kalima Gate Successfuly (Live:%d, GateTick:%u, DieRegen:%d, Map:%d, X:%d, Y:%d, SummonIndex:%d, OwnerIndex:%d, GateNo.:%d)",
gObj[iIndex].AccountID, gObj[iIndex].Name, gObj[iMonsterIndex].Live, gObj[iMonsterIndex].RegenTime,
gObj[iMonsterIndex].DieRegen, gObj[iMonsterIndex].MapNumber, gObj[iMonsterIndex].X,
gObj[iMonsterIndex].Y, iMonsterIndex, iIndex, iKalimaGateLevel+1);
bKalimaGateCreateSucceed = TRUE;
}
}
__finally
{
LeaveCriticalSection(&this->m_critKalimaGate);
}
return true;
}
void CSantaEvent::AddMonsters()
{
int iMonsterIndex = gObjAddMonster(0);
if( iMonsterIndex >= 0 )
{
LPOBJ lpObj = &gObj[iMonsterIndex];
gObjSetMonster(iMonsterIndex, 476);
while ( gMSetBase.GetBoxPosition(0, g_SantaMapPosition[0][0], g_SantaMapPosition[0][1], g_SantaMapPosition[0][2], g_SantaMapPosition[0][3], lpObj->X, lpObj->Y) == 0 )
{
}
gSantaEvent.BossMapX = lpObj->X;
gSantaEvent.BossMapY = lpObj->Y;
lpObj->X = gSantaEvent.BossMapX;
lpObj->TX = gSantaEvent.BossMapX;
lpObj->MTX = gSantaEvent.BossMapX;
lpObj->m_OldX = gSantaEvent.BossMapX;
lpObj->StartX = gSantaEvent.BossMapX;
lpObj->Y = gSantaEvent.BossMapY;
lpObj->TY = gSantaEvent.BossMapY;
lpObj->MTY = gSantaEvent.BossMapY;
lpObj->m_OldY = gSantaEvent.BossMapY;
lpObj->StartY = gSantaEvent.BossMapY;
lpObj->MapNumber = 0;
lpObj->Dir = rand()%8;
lpObj->Level = 87;
lpObj->RegenTime = 0;
lpObj->DieRegen = 0;
lpObj->m_MoveRange = 1;
gSantaEvent.MonsterIndex[gSantaEvent.MonsterCount] = iMonsterIndex;
gSantaEvent.MonsterCount++;
CLog.LogAdd("Make Evil Santa Claus Map %d Coords (%d,%d)",0,gSantaEvent.BossMapX,gSantaEvent.BossMapY);
}
for (int n=0;n<15;n++)
{
int iMonsterIndex = gObjAddMonster(0);
if( iMonsterIndex >= 0 )
{
LPOBJ lpObj = &gObj[iMonsterIndex];
gObjSetMonster(iMonsterIndex, 466);
gMSetBase.GetBoxPosition(0, gSantaEvent.BossMapX-4, gSantaEvent.BossMapY-4,gSantaEvent.BossMapX+4, gSantaEvent.BossMapY+4, lpObj->X, lpObj->Y);
lpObj->TX = lpObj->X;
lpObj->MTX = lpObj->X;
lpObj->m_OldX = lpObj->X;
lpObj->StartX = lpObj->X;
lpObj->Y = lpObj->Y;
lpObj->TY = lpObj->Y;
lpObj->MTY = lpObj->Y;
lpObj->m_OldY = lpObj->Y;
lpObj->StartY = lpObj->Y;
lpObj->MapNumber = 0;
lpObj->Dir = rand()%8;
lpObj->Level = 87;
lpObj->RegenTime = 0;
lpObj->DieRegen = 0;
lpObj->m_MoveRange = 1;
gSantaEvent.MonsterIndex[gSantaEvent.MonsterCount] = iMonsterIndex;
gSantaEvent.MonsterCount++;
CLog.LogAdd("Make Cursed Goblin Map %d Coords (%d,%d)",lpObj->MapNumber,lpObj->X,lpObj->Y);
}
}
}
BOOL CKalimaGate::CreateKalimaGate2(int iIndex, int iMonMapNumber, BYTE cTX, BYTE cTY)
{
BOOL bKalimaGateCreateSucceed = FALSE;
int iMonsterIndex = -1;
EnterCriticalSection(&this->m_critKalimaGate);
__try
{
if ( !gObjIsConnected(iIndex))
return FALSE;
CLog.LogAdd("[Kalima] [%s][%s] Try to Create Kalima Gate (NextMap)",
gObj[iIndex].AccountID, gObj[iIndex].Name);
if ( iMonMapNumber < MAP_INDEX_KALIMA1 || iMonMapNumber > MAP_INDEX_KALIMA6-1 )
{
CLog.LogAdd("[Kalima] [%s][%s] Failed to Summon Kalima Gate (NextMap) - MapNumber Error : %d",
gObj[iIndex].AccountID, gObj[iIndex].Name, iMonMapNumber);
return FALSE;
}
if ( gObj[iIndex].m_cKalimaGateExist == TRUE )
{
GCServerMsgStringSend(lMsg.Get(MSGGET(4, 224)), iIndex, 1);
CLog.LogAdd("[Kalima] [%s][%s] Failed to Summon Kalima Gate (NextMap) - Already Have Gate (SummonIndex:%d)",
gObj[iIndex].AccountID, gObj[iIndex].Name, gObj[iIndex].m_iKalimaGateIndex);
return FALSE;
}
int iMonsterType = iMonMapNumber + 129;
BYTE cX = cTX;
BYTE cY = cTY;
BYTE btMapAttr = MapC[iMonMapNumber].GetAttr(cX, cY);
if ( btMapAttr != 0 )
{
if ( this->GetRandomLocation(iMonMapNumber, cX, cY) == FALSE )
{
CLog.LogAdd("[Kalima] [%s][%s] Failed to Summon Kalima Gate (NextMap) - Failed to get Location (MapNumber:%d, X:%d, Y:%d)",
gObj[iIndex].AccountID, gObj[iIndex].Name, iMonMapNumber, cX, cY);
return FALSE;
}
}
iMonsterIndex = gObjAddMonster(iMonMapNumber);
if ( iMonsterIndex >= 0 )
{
MONSTER_ATTRIBUTE * lpMATTR = gMAttr.GetAttr(iMonsterType);
if ( !lpMATTR )
{
gObjDel(iMonsterIndex);
CLog.LogAdd("[Kalima] [%s][%s] Kalima Gate Vanished (NextMap) - lpMATTR == NULL (SummonIndex:%d)",
gObj[iIndex].AccountID, gObj[iIndex].Name, iMonsterIndex);
return FALSE;
}
gObjSetMonster(iMonsterIndex, iMonsterType);
gObj[iMonsterIndex].Live = TRUE;
gObj[iMonsterIndex].Life = 1000.0;
gObj[iMonsterIndex].MaxLife = 1000.0;
gObj[iMonsterIndex].m_PosNum = -1;
gObj[iMonsterIndex].X = cX;
gObj[iMonsterIndex].Y = cY;
gObj[iMonsterIndex].MTX = cX;
gObj[iMonsterIndex].MTY = cY;
gObj[iMonsterIndex].TX = cX;
gObj[iMonsterIndex].TY = cY;
gObj[iMonsterIndex].m_OldX = cX;
gObj[iMonsterIndex].m_OldY = cY;
gObj[iMonsterIndex].StartX = cX;
gObj[iMonsterIndex].StartY = cY;
gObj[iMonsterIndex].MapNumber = iMonMapNumber;
gObj[iMonsterIndex].m_MoveRange = 0;
gObj[iMonsterIndex].m_cKalimaGateEnterCount = 0;
gObj[iIndex].m_cKalimaGateExist = TRUE;
gObj[iIndex].m_iKalimaGateIndex = iMonsterIndex;
gObj[iMonsterIndex].Level = lpMATTR->m_Level;
gObj[iMonsterIndex].Type = OBJ_MONSTER;
gObj[iMonsterIndex].MaxRegenTime = 1000;
gObj[iMonsterIndex].Dir = 1;
gObj[iMonsterIndex].m_RecallMon = iIndex;
gObj[iMonsterIndex].RegenTime = GetTickCount();
gObj[iMonsterIndex].m_Attribute = 58;
gObj[iMonsterIndex].DieRegen = FALSE;
CLog.LogAdd("[Kalima] [%s][%s] Create Kalima Gate Successfuly (NextMap) (Live:%d, GateTick:%u, DieRegen:%d, Map:%d, X:%d, Y:%d, SummonIndex:%d, OwnerIndex:%d)",
gObj[iIndex].AccountID, gObj[iIndex].Name, gObj[iMonsterIndex].Live, gObj[iMonsterIndex].RegenTime,
gObj[iMonsterIndex].DieRegen, gObj[iMonsterIndex].MapNumber, gObj[iMonsterIndex].X,
gObj[iMonsterIndex].Y, iMonsterIndex, iIndex);
bKalimaGateCreateSucceed = TRUE;
}
}
__finally
{
LeaveCriticalSection(&this->m_critKalimaGate);
}
return TRUE;
}
//----- (00563760) --------------------------------------------------------
BOOL CMercenary::CreateMercenary(int iIndex, int iMercenaryTypeIndex, BYTE cTX, BYTE cTY)
{
#if (GS_CASTLE==1)
LPOBJ lpObj = &gObj[iIndex];
int iMonsterIndex=-1;
BYTE btMapAttr = MapC[lpObj->MapNumber].GetAttr(cTX, cTY);
if ( lpObj->MapNumber != MAP_INDEX_CASTLESIEGE )
{
GCServerMsgStringSend(lMsg.Get(MSGGET(6, 91)), lpObj->m_Index, 1);
return FALSE;
}
if ( g_CastleSiege.GetCastleState() != 7 )
{
GCServerMsgStringSend(lMsg.Get(MSGGET(6, 94)), lpObj->m_Index, 1);
return FALSE;
}
if ( iMercenaryTypeIndex != 286 && iMercenaryTypeIndex != 287 )
goto SKIP_CHK;
if ( lpObj->m_btCsJoinSide != 1 )
{
GCServerMsgStringSend(lMsg.Get(MSGGET(6, 92)), lpObj->m_Index, 1);
return FALSE;
}
if ( lpObj->GuildStatus != GUILD_MASTER && lpObj->GuildStatus != GUILD_ASSISTANT )
{
GCServerMsgStringSend(lMsg.Get(MSGGET(6, 93)), lpObj->m_Index, 1);
return FALSE;
}
SKIP_CHK:
if ( this->m_iMercenaryCount > 100 )
{
GCServerMsgStringSend(lMsg.Get(MSGGET(6, 95)), lpObj->m_Index, 1);
return FALSE;
}
iMonsterIndex = gObjAddMonster(lpObj->MapNumber);
if ( iMonsterIndex < 0 )
{
GCServerMsgStringSend(lMsg.Get(MSGGET(6, 97)), lpObj->m_Index, 1);
return FALSE;
}
LPMONSTER_ATTRIBUTE lpMATTR = gMAttr.GetAttr(iMercenaryTypeIndex);
if ( !lpMATTR )
{
gObjDel(iMonsterIndex);
LogAddTD("[CastleSiege] [%s][%s] Mercenary Vanished (NextMap) - lpMATTR == NULL (SummonIndex:%d)",
lpObj->AccountID, lpObj->Name, iMonsterIndex);
return FALSE;
}
gObjSetMonster(iMonsterIndex, iMercenaryTypeIndex,"CMercenary::CreateMercenary");
gObj[iMonsterIndex].Live = TRUE;
gObj[iMonsterIndex].Life = lpMATTR->m_Hp;
gObj[iMonsterIndex].MaxLife = lpMATTR->m_Hp;
gObj[iMonsterIndex].m_PosNum = -1;
gObj[iMonsterIndex].X = cTX;
gObj[iMonsterIndex].Y = cTY;
gObj[iMonsterIndex].MTX = cTX;
gObj[iMonsterIndex].MTY = cTY;
gObj[iMonsterIndex].TX = cTX;
gObj[iMonsterIndex].TY = cTY;
gObj[iMonsterIndex].m_OldX = cTX;
gObj[iMonsterIndex].m_OldY = cTY;
gObj[iMonsterIndex].StartX = cTX;
gObj[iMonsterIndex].StartY = cTY;
gObj[iMonsterIndex].MapNumber = lpObj->MapNumber;
gObj[iMonsterIndex].m_MoveRange = 0;
gObj[iMonsterIndex].Level = lpMATTR->m_Level; //*(_WORD *)(lpMATTR + 28) lpMATTR->m_Hp
gObj[iMonsterIndex].Type = OBJ_MONSTER; //2
gObj[iMonsterIndex].MaxRegenTime = 1000;
gObj[iMonsterIndex].Dir = 1;
gObj[iMonsterIndex].RegenTime = GetTickCount();
gObj[iMonsterIndex].m_Attribute = 0;
gObj[iMonsterIndex].DieRegen = 0;
gObj[iMonsterIndex].m_btCsNpcType = 2;
gObj[iMonsterIndex].m_btCsJoinSide = 1;
GCServerMsgStringSend(lMsg.Get(MSGGET(6, 96)), lpObj->m_Index, 1);
this->m_iMercenaryCount += 1;
if ( lpObj->lpGuild )
LogAddTD("[CastleSiege] Mercenary is summoned [%d] - [%d][%d] [%s][%s][%d] - (Guild : %s)", gObj[iMonsterIndex].Class,gObj[iMonsterIndex].X,gObj[iMonsterIndex].Y,lpObj->AccountID,lpObj->Name,lpObj->MapNumber,lpObj->lpGuild->Name);
else
LogAddTD("[CastleSiege] Mercenary is summoned [%d] - [%d][%d] [%s][%s][%d]", gObj[iMonsterIndex].Class,gObj[iMonsterIndex].X,gObj[iMonsterIndex].Y,lpObj->AccountID,lpObj->Name,lpObj->MapNumber);
#endif
return TRUE;
}
// ----------------------------------------------------------------------------------------
void CDoubleGoer::SetMonsters()
{
char Type = gDoubleGoer.GetEventIndex(gDoubleGoer.EventMap);
if ( Type == -1 )
{
CLog.LogAdd("[BUG TRACER][DoubleGoer]: Set Monsters -> Type Error");
return;
}
if ( gDoubleGoer.NormalMonsterCount[Type] <= 0 )
{
CLog.LogAdd("[BUG TRACER][DoubleGoer]: Set Monsters -> Monster Count Error");
return;
}
int result = -1;
int MobCt = gDoubleGoer.NormalMonsterCount[Type];
for (int i=0;i<gDoubleGoer.NormalMonsterCount[Type];i++)
{
if ( gDoubleGoer.NormalMonsterPos[Type][i] != -1 )
{
result = gObjAddMonster(gDoubleGoer.EventMap);
if ( result >= 0 )
{
gObj[result].m_PosNum = gDoubleGoer.NormalMonsterPos[Type][i];
gObj[result].X = gMSetBase.m_Mp[gDoubleGoer.NormalMonsterPos[Type][i]].m_X;
gObj[result].Y = gMSetBase.m_Mp[gDoubleGoer.NormalMonsterPos[Type][i]].m_Y;
gObj[result].MapNumber = gDoubleGoer.EventMap;
gObj[result].TX = gObj[result].X;
gObj[result].TY = gObj[result].Y;
gObj[result].m_OldX = gObj[result].X;
gObj[result].m_OldY = gObj[result].Y;
gObj[result].StartX = gObj[result].X;
gObj[result].StartY = gObj[result].Y;
gObj[result].MTX = gDoubleGoer.EventX;
gObj[result].MTY = gDoubleGoer.EventY;
gObjSetMonster(result, gMSetBase.m_Mp[gDoubleGoer.NormalMonsterPos[Type][i]].m_Type);
gObj[result].Dir = rand()%8;
gDoubleGoer.MonstersAddIndex[gDoubleGoer.MonstersAddCount] = result;
gDoubleGoer.MonstersAddCount++;
}
else
{
CLog.LogAdd("[BUG TRACER][DoubleGoer]: Set Monsters -> Add Monster Error");
}
}
}
for (int i=0;i<3;i++)
{
if ( gDoubleGoer.BossMonsterPos[Type][i] != -1 )
{
result = gObjAddMonster(gDoubleGoer.EventMap);
if ( result >= 0 )
{
gObj[result].m_PosNum = gDoubleGoer.BossMonsterPos[Type][i];
gObj[result].X = gMSetBase.m_Mp[gDoubleGoer.BossMonsterPos[Type][i]].m_X;
gObj[result].Y = gMSetBase.m_Mp[gDoubleGoer.BossMonsterPos[Type][i]].m_Y;
gObj[result].MapNumber = gDoubleGoer.EventMap;
gObj[result].TX = gObj[result].X;
gObj[result].TY = gObj[result].Y;
gObj[result].m_OldX = gObj[result].X;
gObj[result].m_OldY = gObj[result].Y;
gObj[result].StartX = gObj[result].X;
gObj[result].StartY = gObj[result].Y;
gObj[result].MTX = gDoubleGoer.EventX;
gObj[result].MTY = gDoubleGoer.EventY;
gObj[result].MaxRegenTime = 0;
gObjSetMonster(result, gMSetBase.m_Mp[gDoubleGoer.BossMonsterPos[Type][i]].m_Type);
gObj[result].Dir = rand()%8;
gDoubleGoer.BossMonsterIndex[i] = result;
}
else
{
CLog.LogAdd("[DoubleGoer]: Set Monsters -> Add Monster Error");
}
}
}
}
// -----------------------------------------------------------------------------------------------------------------------
void CIllusionTemple::SetTempleMonsters(int iTempleIndex)
{
if ( IT_FLOOR_RANGE(iTempleIndex) == FALSE )
{
return;
}
for(int iStatueIndex = 0; iStatueIndex < MAX_IT_STATUES; iStatueIndex++)
{
int result = 0;
result = gObjAddMonster(iTempleIndex + MAP_INDEX_ILLUSION1);
if ( result >= 0 && result < OBJMAX)
{
gObj[result].m_PosNum = -1;
gObj[result].X = s_itStatuePosition[iStatueIndex].PositionX;
gObj[result].Y = s_itStatuePosition[iStatueIndex].PositionY;
gObj[result].MapNumber = MAP_INDEX_ILLUSION1 + iTempleIndex;
gObj[result].TX = s_itStatuePosition[iStatueIndex].PositionX;
gObj[result].TY = s_itStatuePosition[iStatueIndex].PositionY;
gObj[result].m_OldX = s_itStatuePosition[iStatueIndex].PositionX;
gObj[result].m_OldY = s_itStatuePosition[iStatueIndex].PositionY;
gObj[result].Dir = s_itStatuePosition[iStatueIndex].Direction;
gObj[result].StartX = s_itStatuePosition[iStatueIndex].PositionX;
gObj[result].StartY = s_itStatuePosition[iStatueIndex].PositionY;
gObjSetMonster(result, 380);
gObj[result].MaxRegenTime = 200;
this->m_IllusionTemple[iTempleIndex].m_Statues[iStatueIndex] = result;
}
else
{
this->SetTempleState(iTempleIndex, IT_STATE_CLOSED);
CLog.LogAddC(2, "[IllusionTemple] Statue Setup Error! (Statue:%d, Temple:%d)", iStatueIndex, iTempleIndex + 1);
return;
}
}
this->m_IllusionTemple[iTempleIndex].m_BallOwner = this->m_IllusionTemple[iTempleIndex].m_Statues[rand()%2];
for ( int n = 0; n < gMSetBase.m_Count; n++)
{
if ( IT_MAP_RANGE(gMSetBase.m_Mp[n].m_MapNumber) == TRUE )
{
if ( (gMSetBase.m_Mp[n].m_MapNumber - MAP_INDEX_ILLUSION1) != iTempleIndex )
{
continue;
}
if(gMSetBase.m_Mp[n].m_Type == 380) continue;
int result = gObjAddMonster(gMSetBase.m_Mp[n].m_MapNumber);
if ( result >= 0 && result <= OBJMAX)
{
gObj[result].m_PosNum = n;
gObj[result].X = gMSetBase.m_Mp[n].m_X;
gObj[result].Y = gMSetBase.m_Mp[n].m_Y;
gObj[result].MapNumber = gMSetBase.m_Mp[n].m_MapNumber;
gObj[result].TX = gObj[result].X;
gObj[result].TY = gObj[result].Y;
gObj[result].m_OldX = gObj[result].X;
gObj[result].m_OldY = gObj[result].Y;
gObj[result].Dir = gMSetBase.m_Mp[n].m_Dir;
gObj[result].StartX = (BYTE)gObj[result].X;
gObj[result].StartY = (BYTE)gObj[result].Y;
gObjSetMonster(result, gMSetBase.m_Mp[n].m_Type);
gObj[result].MaxRegenTime = 2000;
this->m_IllusionTemple[iTempleIndex].m_SpawnedMonsters.push_back(result);
}
}
}
}
int CLifeStone::CreateLifeStone(int iIndex)
{
LPOBJ lpObj = &gObj[iIndex];
int iMonsterIndex = -1;
BYTE cX = (BYTE)lpObj->X;
BYTE cY = (BYTE)lpObj->Y;
if ( g_CastleSiegeSync.GetCastleState() != 7 )
{
MsgOutput(iIndex, "You can't summon the Life Stone after the Siege begins.");
return FALSE;
}
if ( lpObj->GuildStatus != 0x80 )
return FALSE;
if ( lpObj->m_btCsJoinSide < 2 )
{
MsgOutput(iIndex, "Can only be used by the Offensive Alliance.");
return FALSE;
}
if ( lpObj->lpGuild->lpLifeStone )
{
MsgOutput(iIndex, "Life Stone has already been summoned.");
return FALSE;
}
if ( cX > 150 && cX < 210 && cY > 175 && cY < 230 )
{
MsgOutput(iIndex, "You can't summon the Life Stone inside the Dragon Tower.");
return FALSE;
}
BYTE btMapAttr = MapC[lpObj->MapNumber].GetAttr(cX, cY);
if ( gObj[iIndex].MapNumber != MAP_INDEX_CASTLESIEGE )
{
MsgOutput(iIndex, "This is not a map of the Offensive Alliance.");
return FALSE;
}
iMonsterIndex = gObjAddMonster(lpObj->MapNumber);
if ( iMonsterIndex >= 0 )
{
MONSTER_ATTRIBUTE * MAttr = gMAttr.GetAttr(278);
if ( MAttr == NULL )
{
gObjDel(iMonsterIndex);
return FALSE;
}
gObjSetMonster(iMonsterIndex, 278);
gObj[iMonsterIndex].Live = TRUE;
gObj[iMonsterIndex].Life = MAttr->m_Hp;
gObj[iMonsterIndex].MaxLife = MAttr->m_Hp;
gObj[iMonsterIndex].m_PosNum = -1;
gObj[iMonsterIndex].X = cX;
gObj[iMonsterIndex].Y = cY;
gObj[iMonsterIndex].MTX = cX;
gObj[iMonsterIndex].MTY = cY;
gObj[iMonsterIndex].TX = cX;
gObj[iMonsterIndex].TY = cY;
gObj[iMonsterIndex].m_OldX = cX;
gObj[iMonsterIndex].m_OldY = cY;
gObj[iMonsterIndex].StartX = cX;
gObj[iMonsterIndex].StartY = cY;
gObj[iMonsterIndex].MapNumber = lpObj->MapNumber;
gObj[iMonsterIndex].m_MoveRange = 0;
gObj[iMonsterIndex].Level = MAttr->m_Level;
gObj[iMonsterIndex].Type = OBJ_MONSTER;
gObj[iMonsterIndex].MaxRegenTime = 1000;
gObj[iMonsterIndex].Dir = 1;
gObj[iMonsterIndex].RegenTime = GetTickCount();
gObj[iMonsterIndex].m_Attribute = 0;
gObj[iMonsterIndex].DieRegen = 0;
gObj[iMonsterIndex].m_btCsNpcType = OBJ_NPC;
gObj[iMonsterIndex].m_btCsJoinSide = lpObj->m_btCsJoinSide;
gObj[iMonsterIndex].lpGuild = lpObj->lpGuild;
gObj[iMonsterIndex].m_btCreationState = 0;
lpObj->lpGuild->lpLifeStone = &gObj[iMonsterIndex];
MsgOutput(iIndex, "Life Stone summon succeeded!");
LogAdd("[CastleSiege] LifeStone is created - [%s] [%s][%s] (Map:%d)(X:%d, Y:%d)",
lpObj->lpGuild->Name, lpObj->AccountID, lpObj->Name, lpObj->MapNumber, cX, cY);
lpObj->m_btLifeStoneCount++;
}
else
{
MsgOutput(iIndex, "Life Stone summon failed!");
return FALSE;
}
return TRUE;
}
int CKanturuMonsterMng::SetKanturuMonster(int iGroupNumber)
{
int iMapNumber = 0;
WORD wType = 0;
LPOBJ lpObj;
int iResult;
int iRegenCount = 0;
for ( int iCount=0;iCount<MAX_KANTURU_MONSTER;iCount++)
{
if ( this->m_SetBaseInfo[iCount].btGroup == iGroupNumber &&
this->m_SetBaseInfo[iCount].wType != 0 )
{
iResult = gObjAddMonster(this->m_SetBaseInfo[iCount].btMapNumber);
if ( iResult < 0 )
{
LogAddTD("[ KANTURU ][ SetBossMapMonster ] Fail - Type:%d Map[%d]-[%d][%d]",
this->m_SetBaseInfo[iCount].wType,
this->m_SetBaseInfo[iCount].btMapNumber,
this->m_SetBaseInfo[iCount].btX,
this->m_SetBaseInfo[iCount].btY);
}
else
{
lpObj = &gObj[iResult];
lpObj->m_PosNum = -1;
lpObj->X = this->m_SetBaseInfo[iCount].btX;
lpObj->Y = this->m_SetBaseInfo[iCount].btY;
lpObj->MapNumber = this->m_SetBaseInfo[iCount].btMapNumber;
if ( this->GetPosition(iCount, lpObj->MapNumber, lpObj->X, lpObj->Y) == FALSE )
{
gObjDel(iResult);
continue;
}
lpObj->TX = lpObj->X;
lpObj->TY = lpObj->Y;
lpObj->m_OldX = lpObj->X;
lpObj->m_OldY = lpObj->Y;
lpObj->StartX = lpObj->X;
lpObj->StartY = lpObj->Y;
lpObj->m_MoveRange = this->m_SetBaseInfo[iCount].btDistance;
lpObj->DieRegen = FALSE;
if ( this->m_SetBaseInfo[iCount].btDir == 0xFF )
{
lpObj->Dir = rand()%8;
}
else
{
lpObj->Dir = this->m_SetBaseInfo[iCount].btDir;
}
if ( gObjSetMonster(iResult, this->m_SetBaseInfo[iCount].wType) == FALSE )
{
gObjDel(iResult);
continue;
}
if ( this->m_SetBaseInfo[iCount].wType == 364 ) /// Maya Hand
{
this->m_iMayaObjIndex = iResult;
LogAddTD("[ KANTURU ][ SetBossMapMonster ] %s(Index:%d / ObjIndex:%d) Map:%d-[%d][%d]",
gObj[iResult].Name, gObj[iResult].Class, iResult, gObj[iResult].MapNumber,
gObj[iResult].X, gObj[iResult].Y);
continue;
}
if ( gObj[iResult].Type == OBJ_MONSTER )
{
this->m_KanturuMonster.AddObj(iResult);
this->m_iMaxRegenMonsterCount++;
this->m_iAliveMonsterCount++;
LogAddTD("[ KANTURU ][ SetBossMapMonster ] Count:%d %s(Index:%d / ObjIndex:%d) Map:%d-[%d][%d]",
this->m_iAliveMonsterCount, gObj[iResult].Name, gObj[iResult].Class, iResult,
gObj[iResult].MapNumber,gObj[iResult].X, gObj[iResult].Y);
}
iRegenCount++;
}
}
}
return iRegenCount;
}
BOOL MonsterHerd::AddMonster(int iMonsterType, BOOL bRegen, BOOL bAttackFirst)
{
if ( this->m_bHasInfo == 0 )
{
return false;
}
int iIndex;
BYTE btMapNumber = this->m_iMapNumber;
BYTE cX=0;
BYTE cY=0;
if (this->GetRandomLocation(cX, cY) == FALSE )
{
return false;
}
iIndex = gObjAddMonster(this->m_iMapNumber);
if ( iIndex >= 0 )
{
gObj[iIndex].m_PosNum = -1;
gObj[iIndex].X = cX;
gObj[iIndex].Y = cY;
gObj[iIndex].MapNumber = this->m_iMapNumber;
gObj[iIndex].TX = gObj[iIndex].X;
gObj[iIndex].TY = gObj[iIndex].Y;
gObj[iIndex].m_OldX = gObj[iIndex].X;
gObj[iIndex].m_OldY = gObj[iIndex].Y;
gObj[iIndex].StartX = gObj[iIndex].X;
gObj[iIndex].StartY = gObj[iIndex].Y;
LPMONSTER_ATTRIBUTE iAttr = gMAttr.GetAttr(iMonsterType);
if ( iAttr == NULL )
{
gObjDel(iIndex);
return false;
}
gObj[iIndex].Level = iAttr->m_Level;
gObjSetMonster(iIndex, iMonsterType);
gObj[iIndex].MaxRegenTime = 1000;
gObj[iIndex].Dir = rand() % 8;
gObj[iIndex].m_bIsInMonsterHerd = 1;
gObj[iIndex].m_bIsMonsterAttackFirst = bAttackFirst;
gObj[iIndex].m_lpMonsterHerd = this;
EnterCriticalSection(&this->m_critMonsterHerd);
_MONSTER_HERD_DATA pMonsterData;
pMonsterData.m_iIndex = iIndex;
pMonsterData.m_iType = iMonsterType;
pMonsterData.m_iX = cX;
pMonsterData.m_iX = cY; // #error Apply Deathway Fix, change btXMap for btYMap
pMonsterData.m_bRegen = bRegen;
this->m_mapMonsterHerd.insert( std::pair<int, _MONSTER_HERD_DATA>(iIndex, pMonsterData) );
LeaveCriticalSection(&this->m_critMonsterHerd);
}
else
{
return FALSE;
}
return TRUE;
}
BOOL CRaklionSelupan::CreateSelupan()
{
int m_Type = -1;
for ( int n=0;n<gMSetBase.m_Count;n++)
{
if( gMSetBase.m_Mp[n].m_Type == 459 )
{
m_Type = n;
}
}
LPOBJ lpObj = NULL;
int result = 0;
result = gObjAddMonster(MAP_INDEX_RAKLIONBOSS);
if ( result < 0 )
{
LogAddTD("[RAKLION] CreateSelupan error");
return FALSE;
}
lpObj = &gObj[result];
gObjSetPosMonster(result, m_Type);
gObjSetMonster(result, 459);
LogAddTD("[RAKLION] Create Selupan : X (%d) / Y(%d)",lpObj->X,lpObj->Y);
LPOBJ lpTargetObj = NULL;
for (int n=0;n<OBJMAX;n++)
{
lpTargetObj = &gObj[n];
if(lpTargetObj->MapNumber == MAP_INDEX_RAKLIONBOSS)
{
gObjStateSetCreate(n);
}
}
for (int n=0;n<OBJMAX;n++)
{
lpTargetObj = &gObj[n];
if(lpTargetObj->MapNumber == MAP_INDEX_RAKLIONBOSS)
{
gObjViewportListDestroy(n);
}
}
for (int n=0;n<OBJMAX;n++)
{
lpTargetObj = &gObj[n];
if(lpTargetObj->MapNumber == MAP_INDEX_RAKLIONBOSS)
{
gObjViewportListCreate(n);
}
}
for (int n=0;n<OBJMAX;n++)
{
lpTargetObj = &gObj[n];
if(lpTargetObj->MapNumber == MAP_INDEX_RAKLIONBOSS)
{
gObjViewportListProtocol(n);
}
}
gObjSetState();
this->m_iBossAttackMin = lpObj->m_AttackDamageMin;
this->m_iBossAttackMax = lpObj->m_AttackDamageMax;
return TRUE;
}
//----- (00562770) --------------------------------------------------------
BOOL CLifeStone::CreateLifeStone(int iIndex)
{
LPOBJ lpObj = &gObj[iIndex];
int iMonsterIndex=-1;
if ( g_CastleSiege.GetCastleState() != 7 )
{
//(98175472, 1248) (4, 224)
//(98175472, 1180) (4, 156) => BASE: 1024
//(98175472, 1500) (5, 220) => 1500-1024 = 476 (220 = 476 - 256)
GCServerMsgStringSend(lMsg.Get(MSGGET(6, 109)), lpObj->m_Index, 1);
return FALSE;
}
if (lpObj->GuildStatus != GUILD_MASTER)
{
return FALSE;
}
if (lpObj->m_btCsJoinSide < 2 )
{
GCServerMsgStringSend(lMsg.Get(MSGGET(6, 105)), lpObj->m_Index, 1);
return FALSE;
}
if (lpObj->lpGuild == NULL)
return FALSE;
if (!lpObj->lpGuild->back)
return FALSE;
if (lpObj->lpGuild->back->Number > 0)
{
GCServerMsgStringSend(lMsg.Get(MSGGET(6, 106)), lpObj->m_Index, 1);
return FALSE;
}
if ( (lpObj->X > 150 && lpObj->X < 210) && (lpObj->Y > 175 && lpObj->Y < 230) )
{
GCServerMsgStringSend(lMsg.Get(MSGGET(6, 108)), lpObj->m_Index, 1);
return FALSE;
}
BYTE btMapAttr = MapC[lpObj->MapNumber].GetAttr(lpObj->X, lpObj->Y);
if ( lpObj->MapNumber != MAP_INDEX_CASTLESIEGE )
{
GCServerMsgStringSend(lMsg.Get(MSGGET(6, 91)), lpObj->m_Index, 1);
return FALSE;
}
iMonsterIndex = gObjAddMonster(lpObj->MapNumber);
if ( iMonsterIndex < 0 )
{
GCServerMsgStringSend(lMsg.Get(MSGGET(6, 111)), lpObj->m_Index, 1);
return FALSE;
}
LPMONSTER_ATTRIBUTE lpMATTR = gMAttr.GetAttr(278);
if ( !lpMATTR )
{
gObjDel(iMonsterIndex);
LogAddTD("[CastleSiege] [%s][%s] LifeStone Vanished (NextMap) - lpMATTR == NULL (SummonIndex:%d)",
lpObj->AccountID, lpObj->Name, iMonsterIndex);
return FALSE;
}
gObjSetMonster(iMonsterIndex, 278,"CLifeStone::CreateLifeStone");
gObj[iMonsterIndex].Live = TRUE;
gObj[iMonsterIndex].Life = lpMATTR->m_Hp;
gObj[iMonsterIndex].MaxLife = lpMATTR->m_Hp;
gObj[iMonsterIndex].m_PosNum = -1;
gObj[iMonsterIndex].X = lpObj->X;
gObj[iMonsterIndex].Y = lpObj->Y;
gObj[iMonsterIndex].MTX = lpObj->X;
gObj[iMonsterIndex].MTY = lpObj->Y;
gObj[iMonsterIndex].TX = lpObj->X;
gObj[iMonsterIndex].TY = lpObj->Y;
gObj[iMonsterIndex].m_OldX = lpObj->X;
gObj[iMonsterIndex].m_OldY = lpObj->Y;
gObj[iMonsterIndex].StartX = lpObj->X;
gObj[iMonsterIndex].StartY = lpObj->Y;
gObj[iMonsterIndex].MapNumber = lpObj->MapNumber;
gObj[iMonsterIndex].m_MoveRange = 0;
gObj[iMonsterIndex].Level = lpMATTR->m_Level; //*(_WORD *)(lpMATTR + 28)
gObj[iMonsterIndex].Type = OBJ_MONSTER; //2
gObj[iMonsterIndex].MaxRegenTime = 1000;
gObj[iMonsterIndex].Dir = 1;
gObj[iMonsterIndex].RegenTime = GetTickCount();
gObj[iMonsterIndex].m_Attribute = 0;
gObj[iMonsterIndex].DieRegen = 0;
gObj[iMonsterIndex].m_btCsNpcType = 3;
gObj[iMonsterIndex].m_btCsJoinSide = lpObj->m_btCsJoinSide;
gObj[iMonsterIndex].lpGuild = lpObj->lpGuild;
gObj[iMonsterIndex].m_btCreationState = 0;
lpObj->lpGuild->back->Number = gObj[iMonsterIndex].m_Index;
GCServerMsgStringSend(lMsg.Get(MSGGET(6, 105)), lpObj->m_Index, 1);
LogAddTD("[CastleSiege] LifeStone is created - [%s][%s] (Map:%d)(X:%d, Y:%d)",
lpObj->AccountID,lpObj->Name,lpObj->MapNumber,lpObj->X,lpObj->Y);
lpObj->m_btLifeStoneCount += 1;
return TRUE;
}
void TMonsterAIGroup::Init(int iGroupNumber)
{
if ( TMonsterAIGroup::s_iMonsterAIGroupMemberCount[iGroupNumber] == 0 )
return;
TMonsterAIGroup::DelGroupInstance(iGroupNumber);
for ( int j=0;j<MAX_MONSTER_AI_GROUP_MEMBER;j++)
{
TMonsterAIGroupMember & Memb = TMonsterAIGroup::s_MonsterAIGroupMemberArray[iGroupNumber][j];
if ( Memb.m_iGuid == -1 )
continue;
int iResult = gObjAddMonster(Memb.m_iMapNumber);
if ( iResult >= 0 )
{
gObj[iResult].m_PosNum = -1;
gObj[iResult].MapNumber = Memb.m_iMapNumber;
gObj[iResult].Live = TRUE;
gObjViewportListProtocolDestroy(&gObj[iResult]);
gObjViewportClose(&gObj[iResult]);
BYTE cX;
BYTE cY;
if ( Memb.m_iCreateType == 1 )
{
int iRadius = 10;
BOOL bGetPosition = FALSE;
int iCount = 100;
while ( iCount-- != 0 )
{
cX = Random(0,iRadius) * ((Random(0,1)==0)?-1:1) + Memb.m_iStartX;
cY = Random(0,iRadius) * ((Random(0,1)==0)?-1:1) + Memb.m_iStartY;
BYTE btMapAttr = MapC[Memb.m_iMapNumber].GetAttr(cX, cY);
if ( btMapAttr == 0 )
{
bGetPosition = TRUE;
break;
}
}
if ( bGetPosition == FALSE )
{
gObj[iResult].Live = FALSE;
gObj[iResult].m_State = 4;
gObj[iResult].RegenTime = GetTickCount();
gObj[iResult].DieRegen = 1;
return;
}
}
else if ( Memb.m_iCreateType == 0 )
{
cX = Memb.m_iStartX;
cY = Memb.m_iStartY;
}
gObj[iResult].X = cX;
gObj[iResult].Y = cY;
gObj[iResult].MTX = gObj[iResult].X;
gObj[iResult].MTY = gObj[iResult].Y;
gObj[iResult].TX = gObj[iResult].X;
gObj[iResult].TY = gObj[iResult].Y;
gObj[iResult].StartX = (BYTE)gObj[iResult].X;
gObj[iResult].StartY = (BYTE)gObj[iResult].Y;
gObjSetMonster(iResult, Memb.m_iClass);
gObj[iResult].m_iGroupNumber = Memb.m_iGroupNumber;
gObj[iResult].m_iGroupMemberGuid = Memb.m_iGuid;
gObj[iResult].m_iCurrentAI = Memb.m_iStartAI;
gObj[iResult].m_iBasicAI = Memb.m_iStartAI;
gObj[iResult].m_iRegenType = Memb.m_iRegenType;
gObj[iResult].Dir = Memb.m_iStartDir;
gObj[iResult].m_State = 1;
gObj[iResult].DieRegen = 0;
Memb.m_iObjIndex = iResult;
if ( Memb.m_iCreateType == -1 )
{
gObj[iResult].Live = FALSE;
gObj[iResult].m_State = 4;
gObj[iResult].RegenTime = GetTickCount();
gObj[iResult].DieRegen = 1;
continue;
}
LogAdd("[ KANTURU ][ SetAIMonster ] %s(Index:%d ObjIndex:%d) Map:%d-[%d][%d]",
gObj[iResult].Name, gObj[iResult].Class, iResult, gObj[iResult].MapNumber,
gObj[iResult].X, gObj[iResult].Y);
}
}
}
void XMasEvent::XMasEventInvade()
{
int iMapNumber = 0;
WORD wType = 0;
LPOBJ lpObj;
int iResult;
int iRegenCount = 0;
for (int iCount=0;iCount<this->m_iMaxMonsterCount;iCount++)
{
if ( this->m_SetBaseInfo[iCount].wType != 0)
{
iResult = gObjAddMonster(this->m_SetBaseInfo[iCount].btMapNumber);
if ( iResult < 0 )
{
LogAddTD("[ SANTA EVENT ][ Set Invasion Monster ] Fail - Type:%d Map[%d]-[%d][%d]",
this->m_SetBaseInfo[iCount].wType,
this->m_SetBaseInfo[iCount].btMapNumber,
this->m_SetBaseInfo[iCount].btX,
this->m_SetBaseInfo[iCount].btY);
}
else
{
lpObj = &gObj[iResult];
lpObj->m_PosNum = -1;
lpObj->X = this->m_SetBaseInfo[iCount].btX;
lpObj->Y = this->m_SetBaseInfo[iCount].btY;
lpObj->MapNumber = this->m_SetBaseInfo[iCount].btMapNumber;
/* if ( this->GetPosition(iCount, lpObj->MapNumber, lpObj->X, lpObj->Y) == FALSE )
{
gObjDel(iResult);
continue;
}*/
lpObj->TX = lpObj->X;
lpObj->TY = lpObj->Y;
lpObj->m_OldX = lpObj->X;
lpObj->m_OldY = lpObj->Y;
lpObj->StartX = lpObj->X;
lpObj->StartY = lpObj->Y;
lpObj->m_MoveRange = this->m_SetBaseInfo[iCount].btDistance;
lpObj->DieRegen = FALSE;
if ( this->m_SetBaseInfo[iCount].btDir == 0xFF )
{
lpObj->Dir = rand()%8;
}
else
{
lpObj->Dir = this->m_SetBaseInfo[iCount].btDir;
}
if ( gObjSetMonster(iResult, this->m_SetBaseInfo[iCount].wType) == FALSE )
{
gObjDel(iResult);
continue;
}
if ( gObj[iResult].Type == OBJ_MONSTER )
{
this->m_XMasMonster.AddObj(iResult);
this->m_iAliveMonsterCount++;
LogAddTD("[ SANTA EVENT ][ SetInvadeMonster ][ACTIVE]");
}
iRegenCount++;
}
}
}
LogAddTD("[XMAS EVENT] START !!!");
AllSendServerMsg("[XMAS EVENT] Start in Devias HAPPY HUNTING");
return;
}
int CLifeStone::CreateLifeStone(int iIndex)
{
LPOBJ lpObj = &gObj[iIndex];
int iMonsterIndex = -1;
unsigned char cX = lpObj->X;
unsigned char cY = lpObj->Y;
if(g_CastleSiege.GetCastleState() != CASTLESIEGE_STATE_STARTSIEGE)
{
MsgOutput(iIndex,lMsg.Get(MSGGET(6,109)));
return false;
}
if(lpObj->GuildStatus != G_MASTER)
return false;
if(lpObj->m_btCsJoinSide < 2)
{
MsgOutput(iIndex,lMsg.Get(MSGGET(6,105)));
return false;
}
if(lpObj->lpGuild->lpLifeStone != NULL)
{
MsgOutput(iIndex,lMsg.Get(MSGGET(6,106)));
return false;
}
if(cX > 150 && cX < 210 && cY > 175 && cY < 230)
{
MsgOutput(iIndex,lMsg.Get(MSGGET(6,108)));
return false;
}
unsigned char btMapAttr = MapC[lpObj->MapNumber].GetAttr(cX,cY);
if(gObj[iIndex].MapNumber != MAP_INDEX_CASTLESIEGE)
{
MsgOutput(iIndex,lMsg.Get(MSGGET(6,91)));
return false;
}
iMonsterIndex = gObjAddMonster(lpObj->MapNumber);
if(iMonsterIndex >= 0)
{
MONSTER_ATTRIBUTE * lpMATTR = gMAttr.GetAttr(278);
if(lpMATTR == NULL)
{
gObjDel(iMonsterIndex);
return false;
}
gObjSetMonster(iMonsterIndex,278);
gObj[iMonsterIndex].Live = TRUE;
gObj[iMonsterIndex].Life = (float)lpMATTR->m_Hp;
gObj[iMonsterIndex].MaxLife = (float)lpMATTR->m_Hp;
gObj[iMonsterIndex].m_PosNum = -1;
gObj[iMonsterIndex].X = cX;
gObj[iMonsterIndex].Y = cY;
gObj[iMonsterIndex].MTX = cX;
gObj[iMonsterIndex].MTY = cY;
gObj[iMonsterIndex].TX = cX;
gObj[iMonsterIndex].TY = cY;
gObj[iMonsterIndex].m_OldX = cX;
gObj[iMonsterIndex].m_OldY = cY;
gObj[iMonsterIndex].StartX = cX;
gObj[iMonsterIndex].StartY = cY;
gObj[iMonsterIndex].MapNumber = lpObj->MapNumber;
gObj[iMonsterIndex].m_MoveRange = 0;
gObj[iMonsterIndex].Level = lpMATTR->m_Level;
gObj[iMonsterIndex].Type = OBJ_MONSTER;
gObj[iMonsterIndex].MaxRegenTime = 1000;
gObj[iMonsterIndex].Dir = 1;
gObj[iMonsterIndex].RegenTime = GetTickCount();
gObj[iMonsterIndex].m_Attribute = 0;
gObj[iMonsterIndex].DieRegen = FALSE;
gObj[iMonsterIndex].m_btCsNpcType = 3;
gObj[iMonsterIndex].m_btCsJoinSide = lpObj->m_btCsJoinSide;
gObj[iMonsterIndex].lpGuild = lpObj->lpGuild;
gObj[iMonsterIndex].m_btCreationState = 0;
lpObj->lpGuild->lpLifeStone = &gObj[iMonsterIndex];
MsgOutput(iIndex,lMsg.Get(MSGGET(6,110)));
LogAddTD("[CastleSiege] LifeStone is created - [%s] [%s][%s] (Map:%d)(X:%d, Y:%d)",
lpObj->lpGuild->Name,lpObj->AccountID,lpObj->Name,lpObj->MapNumber,cX,cY);
lpObj->m_btLifeStoneCount++;
}
else
{
MsgOutput(iIndex,lMsg.Get(MSGGET(6,111)));
return false;
}
return true;
}
