示例#1
0
void CStateMachinen::DoScriptMove(CMonster& monster, eStateEvent event)
{
	StateParameter& stateParamter = monster.mStateParamter;

	switch(event)
	{
	case eSEVENT_Enter:
		{
			VECTOR3 position = {
				float(monster.GetFiniteStateMachine().GetMemory().GetVariable("__move_x__")),
				0,
				float(monster.GetFiniteStateMachine().GetMemory().GetVariable("__move_z__")),
			};
			monster.OnMove(
				&position);

			stateParamter.nextTime = gCurTime + CCharMove::GetMoveEstimateTime(
				&monster);
			break;
		}
	case eSEVENT_Process:
		{
			if( stateParamter.nextTime > gCurTime )
			{
				break;
			}

			SetState(
				&monster,
				eMA_STAND);
			break;
		}
	}
}
示例#2
0
    bool FightStateScript::CheckTracer(BaseType::EntityType *entity)
    {
        if(m_State == TRACING)
        {
            int ret = m_SkillTracer.Run(entity);
            if(ret == SkillTracer::TIMEOUT ||
                ret == SkillTracer::FAILED)
            {
                OnUseSkillEnd(ret);
            }
            if(ret == SkillTracer::Okay)
            {
                MonsterAI *ai = dynamic_cast<MonsterAI*>(entity);
                CMonster *monster = dynamic_cast<CMonster*>(entity->GetOwner());
                CServerRegion *region = dynamic_cast<CServerRegion*>(monster->GetFather());
                CMoveShape *target = AIUtils::FindShape(region, m_SkillTracer.m_TargetID);
                if(target == NULL)
                {
                    OnUseSkillEnd(SkillTracer::FAILED);
                }
                else
                {
                    ai->BeginSkill(m_SkillTracer.m_SkillID, m_SkillTracer.m_SkillLvl, target);
                    long actTime = monster->GetActModify(m_SkillTracer.m_SkillID);
                    ai->SetTimer(AIDriver::SCRIPT_EVENT, actTime);
                }
            }
            return true;
        }

        return false;
    }
示例#3
0
int _tmain(int argc, _TCHAR* argv[])
{
	// 注册错误回调函数
	FKAISystem::RegisterErrorMsgReceiver( OutPut );
	// 初始化状态机表
	FKAISystem::SetStateFilesDirectory( "Bin/Data/AIScript" );


	CMonster* pMonster = new CMonster();
	pMonster->Init("状态机表名称");
	for( ;; )
	{
		// 获取帧间隔时间
		static float lastTime = 0;
		lastTime = g_fAccumTime;
		g_fAccumTime = (float)timeGetTime() / 1000.0f;
		g_fTimeFromLastFrame = g_fAccumTime - lastTime;

		//最低帧数控制
		if (g_fTimeFromLastFrame>0.2f)
			g_fTimeFromLastFrame = 0.2f;

		// 每帧间隔CPU休眠时间
		if(g_dwSleepTime > 0) Sleep(g_dwSleepTime);

		pMonster->Update( g_fTimeFromLastFrame );
	}
	pMonster->Destory();
	return 0;
}
示例#4
0
bool CObjectManager::Start()
{
	for (int i = 0; i < MAX_MONSTER; ++i)
	{
		CMonster *pMonster = new CMonster();
		//pMonster->Initalize();			// Warning : Initalize -> Clear -> SetIndex 순서 바뀌면 안됨		
		pMonster->SetIndex(i);

		InsertMonsterToMap(i, pMonster);

		//if (0 == i)
		//{
		//	pMonster->SetMonsterType(MonsterType::MONSTER_TYPE_END);
		//	continue;			// 0은 더미 NPC라서 풀에 넣을 필요없음
		//}
		//else if (i < DEFENDER_MONSTER_START)
		//{
		//	pMonster->SetMonsterType(MonsterType::ATTACKER);
		//}
		//else if (i < SURPPORT_MONSTER_START)
		//{
		//	pMonster->SetMonsterType(MonsterType::DEFENDER);
		//}
		//else
		//{
		//	pMonster->SetMonsterType(MonsterType::SUPPORTER);
		//}
		if (0 == i) continue;

		m_monsterPool.push(pMonster);
	}

	return true;
}
示例#5
0
void CStateMachinen::DoPause(CMonster& monster, eStateEvent event)
{
	StateParameter& stateParamter = monster.mStateParamter;

	switch(event)
	{
	case eSEVENT_Enter:
		{
			const DWORD pausedTick = monster.GetFiniteStateMachine().GetMemory().GetVariable(
				"__tick__");

			stateParamter.nextTime = gCurTime + pausedTick;
			break;
		}
	case eSEVENT_Process:
		{
			if(gCurTime > stateParamter.nextTime)
			{
				const eMONSTER_ACTION pausedAction = eMONSTER_ACTION(monster.GetFiniteStateMachine().GetMemory().GetVariable(
					"__lastState__"));
                SetState(
					&monster,
					pausedAction);
			}

			break;
		}
	}
}
示例#6
0
    void SummonDeadState::Execute(BaseType::EntityType *entity)
    {
		if (entity == NULL)
		{
			LogError(AI_MODULE, "entity object is null.");
			return;
		}
        CMonster *monster = static_cast<CMonster*>(entity->GetOwner());
        monster->AddDelEvent(0);
    }
示例#7
0
文件: CPlayer.cpp 项目: hjqqq/Forever
void CPlayer::skillDamage(AdvancedAttribute targetAttr)
{
    CMonster *pTargetMonster = dynamic_cast<CMonster *>(getTargetObject());
    if(pTargetMonster != NULL)
    {
		  AdvancedAttribute monsterAdv = pTargetMonster->getAdvAttr();
        pTargetMonster->addHate(getUID(), targetAttr.iHP - monsterAdv.iHP);
    }
    CUnitObject::skillDamage(targetAttr);
}
示例#8
0
文件: Ant.cpp 项目: binji/drod-nacl
//*****************************************************************************************
void CAnt::Process(
//Process an ant for movement.
//Params:
	const int /*nLastCommand*/,   //(in) Last swordsman command.
	CCueEvents &CueEvents)  //(in/out) Accepts pointer to a cues object that will be populated
							//with codes indicating events that happened that may correspond to
							//sound or graphical effects.
{
	//If another monster has already got the player, don't move this one there too.
	if (CueEvents.HasOccurred(CID_MonsterKilledPlayer))
		return;

	//Decide where to move to.
	UINT wSX, wSY;
	if (!GetTarget(wSX,wSY))
		return;

	//If next to the target then jump out and kill it.
	//The ant is not killed, but is largely immobile out of water.
	if (abs(static_cast<int>(this->wX - wSX)) <= 1 && abs(static_cast<int>(this->wY - wSY)) <= 1)
	{
		bool bAttack = this->pCurrentGame->IsPlayerAt(wSX, wSY);
		if (!bAttack)
		{
			CMonster *pMonster = this->pCurrentGame->pRoom->GetMonsterAtSquare(wSX, wSY);
			if (pMonster && pMonster->IsAttackableTarget())
				bAttack = true;
		}

		if (bAttack)
		{
			//Move onto target if possible.
			const int dx = wSX - this->wX;
			const int dy = wSY - this->wY;
			const UINT wOSquare = this->pCurrentGame->pRoom->GetOSquare(wSX,wSY);
			if (!(bIsWall(wOSquare) || bIsCrumblyWall(wOSquare) || bIsDoor(wOSquare) ||
					DoesArrowPreventMovement(dx, dy) ||
					this->pCurrentGame->pRoom->DoesSquarePreventDiagonal(this->wX, this->wY, dx, dy)))
			{
				MakeStandardMove(CueEvents, dx, dy);
				SetOrientation(dx, dy);
				return;
			}
		}
	}

	//Get movement offsets.
	int dxFirst, dyFirst, dx, dy;
	if (!GetDirectMovement(wSX, wSY, dxFirst, dyFirst, dx, dy))
		return;

	//Move roach to new destination square.
	MakeStandardMove(CueEvents,dx,dy);
	SetOrientation(dxFirst, dyFirst);
}
示例#9
0
void CGameProc::Loaddata()
{
	int nMonsterCnt;
	nMonsterCnt=GetPrivateProfileInt("map0","monstercnt",0,"data\\map.txt");
	for (int i=0;i<nMonsterCnt;i++)
	{
		CMonster *pMonster;
		pMonster=new CMonster();
		pMonster->Create(i,m_pD3DDevice);
		m_xMonsterList.MoveCurrentToTop();
		m_xMonsterList.AddNode(pMonster);
	}
}
示例#10
0
 void FightStateScript::ReceiveEvent(BaseType::EntityType *entity, const BaseType::EventType &ev)
 {
     SelfType::ReceiveEvent(entity, ev);
     if(ev.Type() == ET_SCRIPT_USESKILL)
     {
         const ScriptUseSkillEvent &sev = (const ScriptUseSkillEvent&) ev;
         CMonster *monster = dynamic_cast<CMonster*>(entity->GetOwner());
         CServerRegion *region = dynamic_cast<CServerRegion*>(monster->GetFather());
         MonsterAI *ai = dynamic_cast<MonsterAI*>(entity);
         long id = sev.id;
         long lvl = sev.lvl;
         long actTime = monster->GetActModify(sev.id);
         if(sev.type == ScriptUseSkillEvent::SHAPE)
         {
             if(sev.trace)
             {
                 // trace the target
                 m_SkillTracer.Init(id, lvl, sev.targetId, sev.traceTime);
                 m_skillScriptID = sev.scriptId;
                 m_State = TRACING;
                 entity->Resume(0);
                 return ;
             }
             else
             {
                 CMoveShape *target = AIUtils::FindShape(region, sev.targetId);
                 if(target == NULL)
                 {
                     OnUseSkillEnd(SkillTracer::FAILED);
                     return ;
                 }
                 ai->BeginSkill(id, lvl, target);
             }
         }
         else if(sev.type == ScriptUseSkillEvent::CELL)
         {
             ai->BeginSkill(id, lvl, sev.x, sev.y);
         }
         m_skillScriptID = sev.scriptId;
         // register act time timer
         ai->SetTimer(AIDriver::SCRIPT_EVENT, actTime);
     }
     else if(ev.Type() == ET_SCRIPT_SKILLEND)
     {
         OnUseSkillEnd(SkillTracer::Okay);
     }
     else if(ev.Type() == ET_KILL)
     {
         entity->ChangeState(ST_DEAD);
     }
 }
void CMonsterGen::OnLoop() {
	if(MeatGen(rate) && monsterCount < monsterMax) {
		CMonster* monsterPiece = new CMonster();
		if (monsterPiece->OnLoad("monster.png", 64, 64, 8) == false) {
			return;
		}
		monsterPiece->X = SDL_GetTicks()%624 + (rand()%500);
		monsterPiece->Y = SDL_GetTicks()%300 +  (rand()%400);
		monsterPiece->ID = 1337*(monsterType) + meatID;
		meatID++;
		monsterCount++;
		CEntity::EntityList.push_back(monsterPiece);
	}
}
示例#12
0
void CObjectManager::DeleteMonster(const UINT id)
{
	CMonster* pMon = FindMonster(id);

	if (m_monsterMappingHashMap.erase(id))
	{
//#ifdef _DEBUG
		//cout << "CObjectManager Mapping HashMap -> Monster Erase : " << id << endl;
//#endif
	}
	InsertMonsterToPool(pMon);

	pMon->Clear();
}
示例#13
0
	void MonsterAI::EscapeSpring()
	{
		CMonster *monster = static_cast<CMonster*>(GetOwner());
		if (monster == NULL)
		{
			LogError(AI_MODULE, "MosterAI has no owner object...");
			return;
		}
		if(monster->GetHP() * 100.0f / monster->GetMaxHP() <= monster->GetEscapePoint())
		{
			// change to escape state
			ChangeState(ST_ESCAPE);
		}
	}
示例#14
0
//LMA: moving to long long...
//void CMonster::AddDamage( CCharacter* enemy, long long hitpower)
void CMonster::AddDamage( CCharacter* enemy, long long hitpower)
{
    //Log(MSG_INFO,"In CMonster::AddDamage");

    CPlayer* player = NULL;
    if(enemy->IsMonster( ))
    {
        CMonster* monster = (CMonster*) enemy;
        if(!enemy->IsSummon( )) return;
        player = monster->GetOwner( );
        if(player==NULL) return;
    }
    else
    {
        player = (CPlayer*) enemy;
    }
    if(MonsterDrop->firsthit==0 && hitpower > 0)
    {
        MonsterDrop->firsthit = player->CharInfo->charid;
        MonsterDrop->firstlevel = player->Stats->Level;
        if( player->Party->party!=NULL )
            thisparty = player->Party->party;
        else
            thisparty = NULL;
    }
    for(UINT i=0;i<PlayersDamage.size();i++)
    {
        MonsterDamage* thisplayer = PlayersDamage.at(i);
        if(thisplayer->charid == player->CharInfo->charid)
        {
            if( hitpower > Stats->HP )
            {
                //hitpower += (long int)Stats->HP + (long int)( Stats->HP * 0.10 );
                hitpower += Stats->HP + (long long) ( Stats->HP * 0.10 );
            }

            thisplayer->damage += hitpower;
            return;
        }
    }
    MonsterDamage* newplayer = new MonsterDamage;
    newplayer->charid = player->CharInfo->charid;
    if( hitpower > Stats->HP )
    {
        //hitpower += (long int)Stats->HP + (long int)( Stats->HP  * 0.10 );
        hitpower += Stats->HP + (long long)( Stats->HP  * 0.10 );
    }
    newplayer->damage = hitpower;
    PlayersDamage.push_back( newplayer );
}
示例#15
0
	static int IsValidOper( CShopManager *pShopMgr, CMessage *pMsg, const CGUID &npcID, long lShopID )
	{
		CPlayer *pPlayer = pMsg->GetPlayer();
		CServerRegion *pRegion = pMsg->GetRegion();
		if( pPlayer == NULL || pRegion == NULL )
		{
			return -2;
		}

		if( pPlayer->IsDied() )
		{
			return -1;
		}

		if( pPlayer->GetCurrentProgress() != CPlayer::PROGRESS_FBUSINESS )
		{
			PutoutLog( LOG_FILE, LT_WARNING, "The Player [%s] is not in PROGRESS_FBUSINESS state.",
				pPlayer->GetName() );
			return -1;
		}

		SetPlayerState( pPlayer, true );

		CMonster *pNPC = (CMonster*) pRegion->FindAroundObject( pPlayer, TYPE_MONSTER, npcID );
		if( pNPC == NULL )
		{
			return -1;
		}

		CShop *pShop = pShopMgr->GetShop( lShopID );
		if( pShop == NULL )
		{
			return -1;
		}

		// NPC是否与商店对应
		if( strcmp( pNPC->GetOriginName(), pShop->GetNpcOrigName() ) != 0 )
		{
			return -1;
		}

		if( pNPC->Distance( pPlayer ) > 10 )
		{
			return -1;
		}

		return 0;
	}
示例#16
0
BOOL Guard::CanAttackCurrent()
{
	if( !HasTarget() )
	{
		return FALSE;
	}

	CMoveShape *pTarget = GetTarget();
	long dis = m_pOwner->Distance( pTarget );
	long attack_range = static_cast<CMonster*>( m_pOwner )->GetAttribute( string( "C_GuardRange" ) );

	if( dis > attack_range )
	{
		return FALSE;
	}

	CMonster *pSelf = static_cast<CMonster*>( m_pOwner );
	DWORD ai_ref = 0;
	
	if( pTarget->GetType() == TYPE_PLAYER )
	{
		CPlayer *pPlayer = static_cast<CPlayer*>( pTarget );
		// ai reference 1
		ai_ref = pSelf->GetAIReferrence( 0 );
		if( ai_ref >= 0 )
		{
			if( pPlayer->GetPVPValue() >= ai_ref && !IsSameCamp( pPlayer, pSelf ) )
			{
				return TRUE;
			}
		}
		// ai reference 2
		ai_ref = pSelf->GetAIReferrence( 1 );
		if( ai_ref > 0 )
		{
			if( pPlayer->GetPkValue() >= ai_ref )
			{
				return TRUE;
			}
		}
	}
	
	// actually, it's not necessary to judge monsters, that because the property for the monsters will
	// not changed .So ignored here.
	// ...

	return FALSE;
}
示例#17
0
void test_derived_archive() {
	CMonster monster;
	monster.mod_hp(10000);
	monster.mod_mp(500);
	std::string name("test");
	monster.set_name(name);

	std::stringstream ss;
	boost::archive::binary_oarchive oa(ss);
	oa << monster;

	CMonster monster2;
	boost::archive::binary_iarchive ia(ss);
	ia >> monster2;

	std::cout << "hp is " << monster2.get_hp() << " mp is " << monster2.get_mp() << std::endl;
	std::cout << "name is " << monster2.get_name() << std::endl;
}
示例#18
0
    void MonsterAI::GBHSpring(long hurt)
    {
		CMonster *monster = static_cast<CMonster*>(GetOwner());
		if (monster == NULL)
		{
			LogError(AI_MODULE, "MosterAI has no owner object...");
			return;
		}
        int hurtProportionHp= (int) (monster->GetMaxHP() * monster->GetHurtProportion() / 100);

        int hp= monster->GetHP();
        int lastHp= hp + hurt;

        if(hurtProportionHp < lastHp && hurtProportionHp >= hp)
        {
            //RunScript(monster->GetGBHScriptName().c_str());
        }
    }
示例#19
0
bool CLaser::HitMonster(vec2 From, vec2 To)
{
	vec2 At;
	CCharacter *pOwnerChar = GameServer()->GetPlayerChar(m_Owner);
	if (!pOwnerChar)
		return false;
	
	CMonster *pHit = GameServer()->m_World.IntersectMonster(m_Pos, To, 8.0f, At);
	if(!pHit)
		return false;
	
	m_From = From;
	m_Pos = At;
	m_Energy = -1;

	pHit->TakeDamage(normalize(To-From)*0.1f, m_Damage, m_Owner, At);
	return true;
}
示例#20
0
	bool MonsterAI::BeginSkill(long skillId, long skillLvl, long x, long y, CMoveShape* target)
	{
		if (target == NULL)
		{
			LogError(AI_MODULE, "Target object is null.");
			return false;
		}

		LogDebug(AI_MODULE, "skillId=%d, skillLvl=%d, x=%d, y=%d, target=%s",
			skillId, skillLvl, x, y, target->GetExID().tostring());
		CMonster *monster = static_cast<CMonster*>(GetOwner());
		monster->InitSkillInstance(skillId, skillLvl, 0, 0, 0, NULL_GUID, 5);
		if(!BaseAI::BeginSkill(monster->GetInstanceSkill(), x, y, target))
		{
			Resume(OPER_FAILED_TIME);
			return false;
		}
		return true;
	}
示例#21
0
CMoveShape *Guard::SearchByAIRef4( const ShapeListType &monster_list, DWORD ai_ref )
{
	LONG min_distance = 0x7ffffff;	
	CMoveShape *pTarget = NULL;
	for( ShapeListType::const_iterator it = monster_list.begin(); it != monster_list.end(); ++ it )
	{
		CMonster *pMonster = MONSTER_CASTC( *it );
		LONG distance = m_pOwner->Distance( pMonster );
		if( pMonster->GetNpcType() == NT_Guard && 
			_ai_ref4_helper( static_cast<CMonster*>( m_pOwner ), pMonster, ai_ref ) &&
			distance < min_distance )
		{
			min_distance = distance;
			pTarget = pMonster;
		}		
	}

	return pTarget;
}
示例#22
0
void CStateMachinen::DoRunAway(CMonster& monster, eStateEvent evt)
{
	StateParameter& stateParamter = monster.mStateParamter;
	
	if( monster.GetAbnormalStatus()->IsStun ||
		monster.GetAbnormalStatus()->IsFreezing ||
		monster.GetAbnormalStatus()->IsStone ||
		monster.GetAbnormalStatus()->IsSlip ||
		monster.GetAbnormalStatus()->IsMoveStop ||
		monster.GetAbnormalStatus()->IsParalysis )
	{
		return;
	}

	switch(evt)
	{
	case eSEVENT_Enter:
		{
			monster.RemoveAllAggro();
			monster.SetTObject(0);

			VECTOR3 position = {0};
			position.x = float(monster.GetFiniteStateMachine().GetMemory().GetVariable(
				"__runaway_x__"));
			position.z = float(monster.GetFiniteStateMachine().GetMemory().GetVariable(
				"__runaway_z__"));
			monster.OnMove(
				&position);

			stateParamter.nextTime = gCurTime + CCharMove::GetMoveEstimateTime(&monster) + 1000;
			break;
		}
	case eSEVENT_Process:
		{
			if(gCurTime > stateParamter.nextTime)
			{
				SetState(
					&monster,
					eMA_STAND);
				break;
			}

			break;
		}
	}
}
示例#23
0
    void SummonDeadState::Enter(BaseType::EntityType *entity, const AITransition &tran)
    {
		if (entity == NULL)
		{
			LogError(AI_MODULE, "entity object is null.");
			return;
		}
        CMonster *monster = static_cast<CMonster*>(entity->GetOwner());
        entity->Stop();
        entity->Resume(GlobalSetup::GetSetup()->dwMonsterKeepDeadTime);

        SKILL::SummVine *vine = dynamic_cast<SKILL::SummVine*>(monster->GetSummmon());
		if (vine == NULL)
		{
			LogError(AI_MODULE, "monster->GetSummon() error: vine is null.");
		}
        assert(vine);
        if (vine != NULL)
        {
            //GetInst(SKILL::SummonMan).RemoveSummon(vine);
        }
    }
示例#24
0
    void SummonPeaceState::Execute(BaseType::EntityType *entity)
    {
		if (entity == NULL)
		{
			LogError(AI_MODULE, "entity is null.");
			return;
		}
        if(SearchEnemy(entity))
        {
            return;
        }

        /// Stand ... Don't move
        MonsterAI *ai = static_cast<MonsterAI*>(entity);
        CMonster  *monster = static_cast<CMonster*>(entity->GetOwner());
		if (monster == NULL)
		{
			LogError(AI_MODULE, "MonsterAI do not have owner.");
		}
        assert(ai && monster);
        ai->Stand(monster->GetStopFrame());
    }
	bool  OnGS2C_MonsterStopMove(GS2C_MonsterStopMove *value)
	{
		if ( !gMap )
		{
			return true;
		}

		CMonster* pMonster = GetMapMonster(value->id);
		if ( pMonster)
		{
			////just for test
			//if(pMonster->GetPropertyInt(RoleProperty_Cloth) == 9006)
			//{
			//	CCLOG("stopmove,cur:(%d,%d),step:(%d,%d), posX:%d,posY:%d",	pMonster->GetCellX(),pMonster->GetCellY(),
			//		pMonster->GetStepX(),pMonster->GetStepY(), 
			//		value->posX,value->posY);
			//}

			pMonster->StopTo(value->posX,value->posY);
		}
		return true;
	}
	bool  OnGS2C_MonsterMoveInfo(GS2C_MonsterMoveInfo *value)
	{
		CMonster* pMonster = GetMapMonster(value->id);

		if ( pMonster )
		{
			////just for test
			//if(pMonster->GetPropertyInt(RoleProperty_Cloth) == 9006)
			//{
			//	CCLOG("move info,cur posX:%d,posY:%d", value->posX,value->posY);
			//	for ( size_t i = 0;i<value->posInfos.size();++i )
			//	{
			//		pk::PosInfo pt = value->posInfos[i];
			//		CCLOG("		path,(%d,%d)", pt.x,pt.y);				
			//	}
			//}

			APath path;
			CHero::PosInfoToPath(value->posX,value->posY,value->posInfos,path);
			pMonster->Move(path);
		}
		return true;
	}
示例#27
0
void CMap::CheckForMonster()
{
	// In this function we go through all of the monsters and see if we
	// hit any of them.  If so, we want to attack them.
	for(int i = 0; i < (int)m_vMonsters.size(); i++)
	{
		CMonster *pMonster = &m_vMonsters[i];
		
		// Go through every player in the party to see if any attacked the monster
		for(int i = 0; i < g_Player.GetPartySize(); i++)
		{
			CPlayer *pPlayer = g_Player.GetPartyMember(i);
			
			POINT position = pPlayer->GetPosition();

			// Check if the current player's position is the same as the monster
			if(position.x == pMonster->GetIndex().x && position.y == pMonster->GetIndex().y)
			{
				// Have the player attack the monster
				pPlayer->Attack(pMonster);
			}
		}
	}
}
示例#28
0
	bool MonsterAI::RandomRun()
	{
		CMonster *monster = static_cast<CMonster*>(GetOwner());
		if (monster == NULL)
		{
			LogError(AI_MODULE, "MosterAI has no owner object...");
		}
		assert(monster);
		if(random(10000) < monster->GetMoveRandomValue())
		{
			long dir = 0;
			long curX = monster->GetTileX();
			long curY = monster->GetTileY();
			long dis = monster->Distance(curX, curY, m_BornPos.x, m_BornPos.y);
			if(dis > monster->GetPeaceMoveRange())
			{
				dir = GetLineDir(curX, curY, m_BornPos.x, m_BornPos.y);
				long gdir = (8 - dir) % 8;
				if(gdir >= 2 || gdir <= 6)
				{
					dir = (dir + random(3) - 1 + 8) % 8;
				}
			}
			else
			{
				dir = random(8);
			}

			long maxRunTimes = monster->GetMaxRunTimes();
			long minRunTimes = monster->GetMinRunTimes();

			AI_EVENT_SENDER(this).MoveByStep(dir, random(maxRunTimes - minRunTimes) + minRunTimes);
			// drive the ai
			Resume(0);
		}
		else
		{
			Stand(monster->GetStopFrame());
		}
		return true;
	}
示例#29
0
LRESULT CGameProc::OnRButtonDown(WPARAM wParam, LPARAM lParam)
{
	m_bRCapture=true;
	m_Oldpt.x = LOWORD(lParam);
	m_Oldpt.y = HIWORD(lParam);

	if (Pick(m_Oldpt))
	{
		if (g_pPlayer->CalculateTagDistanceSquece()<50*50&&g_pPlayer->m_pTargetInfo->TaskIndex!=0)
		{
			//判断任务怪死亡没有
			if (g_pChatPopWnd->m_nTaskState==2)
			{
				m_xMonsterList.MoveCurrentToTop();
				for (int nCnt=0;nCnt<m_xMonsterList.GetCounter();nCnt++)
				{
					CMonster *pMonster;
					pMonster=m_xMonsterList.GetCurrentData();
					
					if (pMonster->m_xMonsterInfo.Id==2)
					{
						if (!pMonster->IsDead())
						{
							g_pChatPopWnd->m_nTaskState=1;
						}
					}
					m_xMonsterList.MoveNextNode();
				}
			}

			g_pChatPopWnd->Open();
			m_xTaskScript.CallFun(g_pPlayer->m_pTargetInfo->TaskIndex);
		}
	}
	return true;
}
示例#30
0
    void GuardSearch::Execute( BaseType::EntityType *entity )
    {
        CMonster *pSelf = dynamic_cast<CMonster*>( entity->GetOwner() );
        ShapeListType player_list;
        ShapeListType monster_list;
        CServerRegion *pRegion = static_cast<CServerRegion*>( pSelf->GetFather() );
        CMoveShape *pTarget = NULL;

        if( CanAttackCurrent( pSelf, entity ) )
        {
            return;
        }

        // find the around players
        pRegion->FindAroundObject( pSelf, TYPE_PLAYER, player_list );
        // find the around monsters including the guards.
        pRegion->FindAroundObject( pSelf, TYPE_MONSTER, monster_list );

        // filter the result
        Filter filter( static_cast<CMonster*>( pSelf ) );
        filter_shape( player_list, filter );
        filter_shape( monster_list, filter );


        // retrieve the ai reference
        DWORD ai_ref = pSelf->GetAIReferrence( 0 );
        if( ai_ref >= 0 )
        {
            pTarget = SearchByAIRef1( pSelf, player_list, ai_ref );
        }

        if( pTarget == NULL && ( ai_ref = pSelf->GetAIReferrence( 1 ) ) > 0 )
        {
            pTarget = SearchByAIRef2( pSelf, player_list, ai_ref );
        }	

        if( pTarget == NULL && ( ai_ref = pSelf->GetAIReferrence( 2 ) ) > 0 )
        {
            pTarget = SearchByAIRef3( pSelf, monster_list, ai_ref );
        }

        if( pTarget == NULL && ( ai_ref = pSelf->GetAIReferrence( 3 ) ) > 0 )
        {
            pTarget = SearchByAIRef4( pSelf, monster_list, ai_ref );
        }

        if( pTarget != NULL )
        {
            // search successfully
            entity->SetTarget( pTarget->GetExID(), pTarget->GetType() );
        }
        else if( entity->HasTarget() )
        {
            AI_EVENT_SENDER( entity ).ReturnPeace();
        }
    }