virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
  {
    switch (event)
    {    
    case eFE_Activate:
      {
        IActor* pActor = GetAIActor(pActInfo);
        if (!pActor)
          break;
        
        IEntity* pEnt = pActor->GetEntity();
        if (!pEnt)
          break;
        
        HSCRIPTFUNCTION func = 0;
        int ret = 0;
        IScriptTable* pTable = pEnt->GetScriptTable();
        if (!pTable)
          break;

        if (IsPortActive(pActInfo, 1) && pTable->GetValue("GrabObject", func))
        {                   
          IEntity* pObj = gEnv->pEntitySystem->GetEntity( GetPortEntityId(pActInfo, 0) );
          if (pObj)
          {
            IScriptTable* pObjTable = pObj->GetScriptTable();
            Script::CallReturn(gEnv->pScriptSystem, func, pTable, pObjTable, ret);
          }
          ActivateOutput(pActInfo, 0, ret);
        }  
        else if (IsPortActive(pActInfo, 2) && pTable->GetValue("DropObject", func))
        {
          bool bThrow = GetPortBool(pActInfo, 3);
          Script::CallReturn(gEnv->pScriptSystem, func, pTable, bThrow, ret);
          ActivateOutput(pActInfo, 0, ret);
        }
        
        if (pTable->GetValue("GetGrabbedObject", func))
        {          
          ScriptHandle sH(0);
          Script::CallReturn(gEnv->pScriptSystem, func, pTable, sH);
          ActivateOutput(pActInfo, 1, EntityId(sH.n));
        }
        
				if(func)
					gEnv->pScriptSystem->ReleaseFunc(func);

        break;
      }
    }
  }
Esempio n. 2
0
void loop() {
    lBreak();
    sM();
    sE();
    sR();
    sR();
    sY();
    wBreak();
    sC();
    sH();
    sR();
    sI();
    sS();
    sT();
    sM();
    sA();
    sS();
    lBreak();
}
Esempio n. 3
0
/**
Calculates the segments joining nav polygons at a link. For example, the walk link
between two polygons will contain the edge segment where they meet. Note that this
function implicitly calculates whether there is a link between two polygons, since
that is dependent on whether or not an appropriate edge segment can be found.

@param s1			One of the 2D endpoints of the source edge in the plane
@param s2			The other 2D endpoint of the source edge in the plane
@param d1			One of the 2D endpoints of the destination edge in the plane
@param d2			The other 2D endpoint of the destination edge in the plane
@param xOverlap		The horizontal overlap interval between the 2D edges in the plane
*/
NavMeshGenerator::LinkSegments
NavMeshGenerator::calculate_link_segments(const Vector2d& s1, const Vector2d& s2, const Vector2d& d1, const Vector2d& d2,
										  const Interval& xOverlap) const
{
	LinkSegments linkSegments;

	// Calculate the line equations yS = mS.x + cS and yD = mD.x + cD.
	assert(fabs(s2.x - s1.x) > EPSILON);
	assert(fabs(d2.x - d1.x) > EPSILON);

	double mS = (s2.y - s1.y) / (s2.x - s1.x);
	double mD = (d2.y - d1.y) / (d2.x - d1.x);
	double cS = s1.y - mS * s1.x;
	double cD = d1.y - mD * d1.x;

	double deltaM = mD - mS;
	double deltaC = cD - cS;

	if(fabs(deltaM) > EPSILON)
	{
		// If the gradients of the source and destination edges are different, then we get
		// a combination of step up/step down links.

		// We want to find:
		// (a) The point walkX at which yD = yS
		// (b) The point stepUpX at which yD - yS = MAX_HEIGHT_DIFFERENCE (this is the furthest point at which you can step up)
		// (c) The point stepDownX at which yS - yD = MAX_HEIGHT_DIFFERENCE (this is the furthest point at which you can step down)

		// (a) deltaM . walkX + deltaC = 0
		double walkX = -deltaC / deltaM;

		// (b) deltaM . stepUpX + deltaC = MAX_HEIGHT_DIFFERENCE
		double stepUpX = (m_maxHeightDifference - deltaC) / deltaM;

		// (c) deltaM . stepDownX + deltaC = -MAX_HEIGHT_DIFFERENCE
		double stepDownX = (-m_maxHeightDifference - deltaC) / deltaM;

		// Now construct the link intervals and clip them to the known x overlap interval.
		Interval stepDownInterval(std::min(walkX,stepDownX), std::max(walkX,stepDownX));
		Interval stepUpInterval(std::min(walkX,stepUpX), std::max(walkX,stepUpX));
		stepDownInterval = stepDownInterval.intersect(xOverlap);
		stepUpInterval = stepUpInterval.intersect(xOverlap);

		// Finally, construct the link segments from the link intervals.
		if(!stepDownInterval.empty())
		{
			Vector2d sL(stepDownInterval.low(), mS*stepDownInterval.low()+cS);
			Vector2d sH(stepDownInterval.high(), mS*stepDownInterval.high()+cS);
			linkSegments.stepDownSourceToDestSegment.reset(new LineSegment2d(sL,sH));

			Vector2d dL(stepDownInterval.low(), mD*stepDownInterval.low()+cD);
			Vector2d dH(stepDownInterval.high(), mD*stepDownInterval.high()+cD);
			linkSegments.stepUpDestToSourceSegment.reset(new LineSegment2d(dL,dH));
		}

		if(!stepUpInterval.empty())
		{
			Vector2d sL(stepUpInterval.low(), mS*stepUpInterval.low()+cS);
			Vector2d sH(stepUpInterval.high(), mS*stepUpInterval.high()+cS);
			linkSegments.stepUpSourceToDestSegment.reset(new LineSegment2d(sL,sH));

			Vector2d dL(stepUpInterval.low(), mD*stepUpInterval.low()+cD);
			Vector2d dH(stepUpInterval.high(), mD*stepUpInterval.high()+cD);
			linkSegments.stepDownDestToSourceSegment.reset(new LineSegment2d(dL,dH));
		}
	}
	else
	{
		// If the gradients of the source and destination edges are the same (i.e. the edges are parallel),
		// then we either get a step up/step down combination, or a walk link in either direction.
		if(fabs(deltaC) <= m_maxHeightDifference)
		{
			Vector2d s1(xOverlap.low(), mS*xOverlap.low()+cS);
			Vector2d s2(xOverlap.high(), mS*xOverlap.high()+cS);
			Vector2d d1(xOverlap.low(), mD*xOverlap.low()+cD);
			Vector2d d2(xOverlap.high(), mD*xOverlap.high()+cD);

			// There's a link between the lines, but we need to check the sign of deltaC to see which type.
			if(deltaC > SMALL_EPSILON)
			{
				// The destination is higher than the source: step up.
				linkSegments.stepUpSourceToDestSegment.reset(new LineSegment2d(s1,s2));
				linkSegments.stepDownDestToSourceSegment.reset(new LineSegment2d(d1,d2));
			}
			else if(deltaC < -SMALL_EPSILON)
			{
				// The destination is lower than the source: step down.
				linkSegments.stepDownSourceToDestSegment.reset(new LineSegment2d(s1,s2));
				linkSegments.stepUpDestToSourceSegment.reset(new LineSegment2d(d1,d2));
			}
			else	// |deltaC| < SMALL_EPSILON
			{
				// The destination and source are at the same level: just walk across.
				linkSegments.walkSegment.reset(new LineSegment2d(s1,s2));
			}
		}
	}

	return linkSegments;
}