void UEnvQueryTest_Distance::RunTest(struct FEnvQueryInstance& QueryInstance)
{
float ThresholdValue = 0.0f;
if (!QueryInstance.GetParamValue(FloatFilter, ThresholdValue, TEXT("FloatFilter")))
{
return;
}
// don't support context Item here, it doesn't make any sense
TArray<FVector> ContextLocations;
if (!QueryInstance.PrepareContext(DistanceTo, ContextLocations))
{
return;
}
switch (TestMode)
{
case EEnvTestDistance::Distance3D:
for (FEnvQueryInstance::ItemIterator It(QueryInstance); It; ++It)
{
const FVector ItemLocation = GetItemLocation(QueryInstance, *It);
for (int32 iContext = 0; iContext < ContextLocations.Num(); iContext++)
{
const float Distance = CalcDistance3D(ItemLocation, ContextLocations[iContext]);
It.SetScore(Condition, Distance, ThresholdValue);
}
}
break;
case EEnvTestDistance::Distance2D:
for (FEnvQueryInstance::ItemIterator It(QueryInstance); It; ++It)
{
const FVector ItemLocation = GetItemLocation(QueryInstance, *It);
for (int32 iContext = 0; iContext < ContextLocations.Num(); iContext++)
{
const float Distance = CalcDistance2D(ItemLocation, ContextLocations[iContext]);
It.SetScore(Condition, Distance, ThresholdValue);
}
}
break;
case EEnvTestDistance::DistanceZ:
for (FEnvQueryInstance::ItemIterator It(QueryInstance); It; ++It)
{
const FVector ItemLocation = GetItemLocation(QueryInstance, *It);
for (int32 iContext = 0; iContext < ContextLocations.Num(); iContext++)
{
const float Distance = CalcDistanceZ(ItemLocation, ContextLocations[iContext]);
It.SetScore(Condition, Distance, ThresholdValue);
}
}
break;
default:
return;
}
}
UnitAny* FindItemByPosition(DWORD x, DWORD y, DWORD Location) {
for(UnitAny* pItem = D2COMMON_GetItemFromInventory(D2CLIENT_GetPlayerUnit()->pInventory); pItem; pItem = D2COMMON_GetNextItemFromInventory(pItem)) {
if((DWORD)GetItemLocation(pItem) == Location && InArea(x,y,pItem->pObjectPath->dwPosX,pItem->pObjectPath->dwPosY,D2COMMON_GetItemText(pItem->dwTxtFileNo)->xSize,D2COMMON_GetItemText(pItem->dwTxtFileNo)->ySize))
return pItem;
}
return NULL;
}
bool UEnvQueryItemType_VectorBase::StoreInBlackboard(FBlackboardKeySelector& KeySelector, UBlackboardComponent* Blackboard, const uint8* RawData) const
{
bool bStored = false;
if (KeySelector.SelectedKeyType == UBlackboardKeyType_Vector::StaticClass())
{
const FVector MyLocation = GetItemLocation(RawData);
Blackboard->SetValue<UBlackboardKeyType_Vector>(KeySelector.GetSelectedKeyID(), MyLocation);
bStored = true;
}
return bStored;
}
void UEnvQueryTest_Trace::RunTest(FEnvQueryInstance& QueryInstance) const
{
UObject* DataOwner = QueryInstance.Owner.Get();
BoolValue.BindData(DataOwner, QueryInstance.QueryID);
TraceFromContext.BindData(DataOwner, QueryInstance.QueryID);
ItemHeightOffset.BindData(DataOwner, QueryInstance.QueryID);
ContextHeightOffset.BindData(DataOwner, QueryInstance.QueryID);
bool bWantsHit = BoolValue.GetValue();
bool bTraceToItem = TraceFromContext.GetValue();
float ItemZ = ItemHeightOffset.GetValue();
float ContextZ = ContextHeightOffset.GetValue();
TArray<FVector> ContextLocations;
if (!QueryInstance.PrepareContext(Context, ContextLocations))
{
return;
}
FCollisionQueryParams TraceParams(TEXT("EnvQueryTrace"), TraceData.bTraceComplex);
TraceParams.bTraceAsyncScene = true;
TArray<AActor*> IgnoredActors;
if (QueryInstance.PrepareContext(Context, IgnoredActors))
{
TraceParams.AddIgnoredActors(IgnoredActors);
}
ECollisionChannel TraceCollisionChannel = UEngineTypes::ConvertToCollisionChannel(TraceData.TraceChannel);
FVector TraceExtent(TraceData.ExtentX, TraceData.ExtentY, TraceData.ExtentZ);
FRunTraceSignature TraceFunc;
switch (TraceData.TraceShape)
{
case EEnvTraceShape::Line:
TraceFunc.BindUObject(this, bTraceToItem ? &UEnvQueryTest_Trace::RunLineTraceTo : &UEnvQueryTest_Trace::RunLineTraceFrom);
break;
case EEnvTraceShape::Box:
TraceFunc.BindUObject(this, bTraceToItem ? &UEnvQueryTest_Trace::RunBoxTraceTo : &UEnvQueryTest_Trace::RunBoxTraceFrom);
break;
case EEnvTraceShape::Sphere:
TraceFunc.BindUObject(this, bTraceToItem ? &UEnvQueryTest_Trace::RunSphereTraceTo : &UEnvQueryTest_Trace::RunSphereTraceFrom);
break;
case EEnvTraceShape::Capsule:
TraceFunc.BindUObject(this, bTraceToItem ? &UEnvQueryTest_Trace::RunCapsuleTraceTo : &UEnvQueryTest_Trace::RunCapsuleTraceFrom);
break;
default:
return;
}
for (int32 ContextIndex = 0; ContextIndex < ContextLocations.Num(); ContextIndex++)
{
ContextLocations[ContextIndex].Z += ContextZ;
}
for (FEnvQueryInstance::ItemIterator It(this, QueryInstance); It; ++It)
{
const FVector ItemLocation = GetItemLocation(QueryInstance, It.GetIndex()) + FVector(0, 0, ItemZ);
AActor* ItemActor = GetItemActor(QueryInstance, It.GetIndex());
for (int32 ContextIndex = 0; ContextIndex < ContextLocations.Num(); ContextIndex++)
{
const bool bHit = TraceFunc.Execute(ItemLocation, ContextLocations[ContextIndex], ItemActor, QueryInstance.World, TraceCollisionChannel, TraceParams, TraceExtent);
It.SetScore(TestPurpose, FilterType, bHit, bWantsHit);
}
}
}
void UEnvQueryTest_Project::RunTest(FEnvQueryInstance& QueryInstance) const
{
BoolValue.BindData(QueryInstance.Owner.Get(), QueryInstance.QueryID);
bool bWantsProjected = BoolValue.GetValue();
UEnvQueryItemType_Point* ItemTypeCDO = QueryInstance.ItemType->GetDefaultObject<UEnvQueryItemType_Point>();
if (ItemTypeCDO == nullptr)
{
return;
}
if (ProjectionData.TraceMode == EEnvQueryTrace::Navigation)
{
const ANavigationData* NavData = FEQSHelpers::FindNavigationDataForQuery(QueryInstance);
if (NavData)
{
TSharedPtr<const FNavigationQueryFilter> NavigationFilter = UNavigationQueryFilter::GetQueryFilter(*NavData, ProjectionData.NavigationFilter);
TArray<FNavigationProjectionWork> Workload;
Workload.Reserve(QueryInstance.Items.Num());
const FVector VerticalOffset = (ProjectionData.ProjectDown == ProjectionData.ProjectUp) ?
FVector::ZeroVector : FVector(0, 0, (ProjectionData.ProjectUp - ProjectionData.ProjectDown) / 2);
for (int32 Idx = 0; Idx < QueryInstance.Items.Num(); Idx++)
{
if (QueryInstance.Items[Idx].IsValid())
{
const FVector& ItemLocation = GetItemLocation(QueryInstance, Idx);
Workload.Add(FNavigationProjectionWork(ItemLocation + VerticalOffset));
}
}
const FVector ProjectionExtent(ProjectionData.ExtentX, ProjectionData.ExtentX, (ProjectionData.ProjectDown + ProjectionData.ProjectUp) / 2);
NavData->BatchProjectPoints(Workload, ProjectionExtent, NavigationFilter);
int32 Idx = 0;
for (FEnvQueryInstance::ItemIterator It(this, QueryInstance); It; ++It, Idx++)
{
const bool bProjected = Workload[Idx].bResult;
if (bProjected)
{
ItemTypeCDO->SetItemNavLocation(It.GetItemData(), Workload[Idx].OutLocation);
}
It.SetScore(TestPurpose, FilterType, bProjected, bWantsProjected);
}
}
}
else if (ProjectionData.TraceMode == EEnvQueryTrace::Geometry)
{
TArray<FNavLocation> Workload;
TArray<uint8> TraceHits;
Workload.Reserve(QueryInstance.Items.Num());
for (int32 Idx = 0; Idx < QueryInstance.Items.Num(); Idx++)
{
if (QueryInstance.Items[Idx].IsValid())
{
const FVector& ItemLocation = GetItemLocation(QueryInstance, Idx);
Workload.Add(FNavLocation(ItemLocation));
}
}
FEQSHelpers::RunPhysProjection(QueryInstance.World, ProjectionData, Workload, TraceHits);
int32 Idx = 0;
for (FEnvQueryInstance::ItemIterator It(this, QueryInstance); It; ++It, Idx++)
{
const bool bProjected = TraceHits.IsValidIndex(Idx) && TraceHits[Idx];
if (bProjected)
{
ItemTypeCDO->SetItemNavLocation(It.GetItemData(), Workload[Idx]);
}
It.SetScore(TestPurpose, FilterType, bProjected, bWantsProjected);
}
}
}
void UEnvQueryTest_Dot::RunTest(struct FEnvQueryInstance& QueryInstance)
{
float ThresholdValue = 0.0f;
if (!QueryInstance.GetParamValue(FloatFilter, ThresholdValue, TEXT("FloatFilter")))
{
return;
}
// gather all possible directions: for contexts different than Item
TArray<FVector> LineADirs;
const bool bUpdateLineAPerItem = RequiresPerItemUpdates(LineAFrom, LineATo, LineADirection, LineA == EEnvTestDot::Direction);
if (!bUpdateLineAPerItem)
{
GatherLineDirections(LineADirs, QueryInstance, LineAFrom, LineATo, LineADirection, LineA == EEnvTestDot::Direction);
if (LineADirs.Num() == 0)
{
return;
}
}
TArray<FVector> LineBDirs;
const bool bUpdateLineBPerItem = RequiresPerItemUpdates(LineBFrom, LineBTo, LineBDirection, LineB == EEnvTestDot::Direction);
if (!bUpdateLineBPerItem)
{
GatherLineDirections(LineBDirs, QueryInstance, LineBFrom, LineBTo, LineBDirection, LineB == EEnvTestDot::Direction);
if (LineBDirs.Num() == 0)
{
return;
}
}
// loop through all items
for (FEnvQueryInstance::ItemIterator It(QueryInstance); It; ++It)
{
// update lines for contexts using current item
if (bUpdateLineAPerItem || bUpdateLineBPerItem)
{
const FVector ItemLocation = (LineA == EEnvTestDot::Direction && LineB == EEnvTestDot::Direction) ? FVector::ZeroVector : GetItemLocation(QueryInstance, *It);
const FRotator ItemRotation = (LineA == EEnvTestDot::Direction || LineB == EEnvTestDot::Direction) ? GetItemRotation(QueryInstance, *It) : FRotator::ZeroRotator;
if (bUpdateLineAPerItem)
{
LineADirs.Reset();
GatherLineDirections(LineADirs, QueryInstance, LineAFrom, LineATo, LineADirection, LineA == EEnvTestDot::Direction, ItemLocation, ItemRotation);
}
if (bUpdateLineBPerItem)
{
LineBDirs.Reset();
GatherLineDirections(LineBDirs, QueryInstance, LineBFrom, LineBTo, LineBDirection, LineB == EEnvTestDot::Direction, ItemLocation, ItemRotation);
}
}
// perform test for each line pair
for (int32 iLineA = 0; iLineA < LineADirs.Num(); iLineA++)
{
for (int32 iLineB = 0; iLineB < LineBDirs.Num(); iLineB++)
{
const float DotValue = FVector::DotProduct(LineADirs[iLineA], LineBDirs[iLineB]);
It.SetScore(Condition, DotValue, ThresholdValue);
}
}
}
}
void UEnvQueryTest_PathfindingBatch::RunTest(FEnvQueryInstance& QueryInstance) const
{
UObject* QueryOwner = QueryInstance.Owner.Get();
BoolValue.BindData(QueryOwner, QueryInstance.QueryID);
PathFromContext.BindData(QueryOwner, QueryInstance.QueryID);
SkipUnreachable.BindData(QueryOwner, QueryInstance.QueryID);
FloatValueMin.BindData(QueryOwner, QueryInstance.QueryID);
FloatValueMax.BindData(QueryOwner, QueryInstance.QueryID);
ScanRangeMultiplier.BindData(QueryOwner, QueryInstance.QueryID);
bool bWantsPath = BoolValue.GetValue();
bool bPathToItem = PathFromContext.GetValue();
bool bDiscardFailed = SkipUnreachable.GetValue();
float MinThresholdValue = FloatValueMin.GetValue();
float MaxThresholdValue = FloatValueMax.GetValue();
float RangeMultiplierValue = ScanRangeMultiplier.GetValue();
UNavigationSystem* NavSys = QueryInstance.World->GetNavigationSystem();
if (NavSys == nullptr)
{
return;
}
ANavigationData* NavData = FindNavigationData(*NavSys, QueryOwner);
ARecastNavMesh* NavMeshData = Cast<ARecastNavMesh>(NavData);
if (NavMeshData == nullptr)
{
return;
}
TArray<FVector> ContextLocations;
if (!QueryInstance.PrepareContext(Context, ContextLocations))
{
return;
}
TArray<FNavigationProjectionWork> TestPoints;
TArray<float> CollectDistanceSq;
CollectDistanceSq.Init(0.0f, ContextLocations.Num());
FSharedNavQueryFilter NavigationFilter = FilterClass != nullptr
? UNavigationQueryFilter::GetQueryFilter(*NavMeshData, FilterClass)->GetCopy()
: NavMeshData->GetDefaultQueryFilter()->GetCopy();
NavigationFilter->SetBacktrackingEnabled(!bPathToItem);
const dtQueryFilter* NavQueryFilter = ((const FRecastQueryFilter*)NavigationFilter->GetImplementation())->GetAsDetourQueryFilter();
{
// scope for perf timers
// can't use FEnvQueryInstance::ItemIterator yet, since it has built in scoring functionality
for (int32 ItemIdx = 0; ItemIdx < QueryInstance.Items.Num(); ItemIdx++)
{
if (QueryInstance.Items[ItemIdx].IsValid())
{
const FVector ItemLocation = GetItemLocation(QueryInstance, ItemIdx);
TestPoints.Add(FNavigationProjectionWork(ItemLocation));
for (int32 ContextIdx = 0; ContextIdx < ContextLocations.Num(); ContextIdx++)
{
const float TestDistanceSq = FVector::DistSquared(ItemLocation, ContextLocations[ContextIdx]);
CollectDistanceSq[ContextIdx] = FMath::Max(CollectDistanceSq[ContextIdx], TestDistanceSq);
}
}
}
NavMeshData->BatchProjectPoints(TestPoints, NavMeshData->GetDefaultQueryExtent(), NavigationFilter);
}
TArray<FRecastDebugPathfindingData> NodePoolData;
NodePoolData.SetNum(ContextLocations.Num());
{
// scope for perf timer
TArray<NavNodeRef> Polys;
for (int32 ContextIdx = 0; ContextIdx < ContextLocations.Num(); ContextIdx++)
{
const float MaxPathDistance = FMath::Sqrt(CollectDistanceSq[ContextIdx]) * RangeMultiplierValue;
Polys.Reset();
NodePoolData[ContextIdx].Flags = ERecastDebugPathfindingFlags::PathLength;
NavMeshData->GetPolysWithinPathingDistance(ContextLocations[ContextIdx], MaxPathDistance, Polys, NavigationFilter, nullptr, &NodePoolData[ContextIdx]);
}
}
int32 ProjectedItemIdx = 0;
if (GetWorkOnFloatValues())
{
NodePoolHelpers::PathParamFunc Func[] = { nullptr, NodePoolHelpers::GetPathCost, NodePoolHelpers::GetPathLength };
FEnvQueryInstance::ItemIterator It(this, QueryInstance);
for (It.IgnoreTimeLimit(); It; ++It, ProjectedItemIdx++)
{
for (int32 ContextIndex = 0; ContextIndex < ContextLocations.Num(); ContextIndex++)
{
const float PathValue = Func[TestMode](NodePoolData[ContextIndex], TestPoints[ProjectedItemIdx], NavQueryFilter);
It.SetScore(TestPurpose, FilterType, PathValue, MinThresholdValue, MaxThresholdValue);
if (bDiscardFailed && PathValue >= BIG_NUMBER)
{
It.ForceItemState(EEnvItemStatus::Failed);
}
}
}
}
else
{
FEnvQueryInstance::ItemIterator It(this, QueryInstance);
for (It.IgnoreTimeLimit(); It; ++It, ProjectedItemIdx++)
{
for (int32 ContextIndex = 0; ContextIndex < ContextLocations.Num(); ContextIndex++)
{
const bool bFoundPath = NodePoolHelpers::HasPath(NodePoolData[ContextIndex], TestPoints[ProjectedItemIdx]);
It.SetScore(TestPurpose, FilterType, bFoundPath, bWantsPath);
}
}
}
}
void UEnvQueryTest_Distance::RunTest(FEnvQueryInstance& QueryInstance) const
{
UObject* QueryOwner = QueryInstance.Owner.Get();
if (QueryOwner == nullptr)
{
return;
}
FloatValueMin.BindData(QueryOwner, QueryInstance.QueryID);
float MinThresholdValue = FloatValueMin.GetValue();
FloatValueMax.BindData(QueryOwner, QueryInstance.QueryID);
float MaxThresholdValue = FloatValueMax.GetValue();
// don't support context Item here, it doesn't make any sense
TArray<FVector> ContextLocations;
if (!QueryInstance.PrepareContext(DistanceTo, ContextLocations))
{
return;
}
switch (TestMode)
{
case EEnvTestDistance::Distance3D:
for (FEnvQueryInstance::ItemIterator It(this, QueryInstance); It; ++It)
{
const FVector ItemLocation = GetItemLocation(QueryInstance, It.GetIndex());
for (int32 ContextIndex = 0; ContextIndex < ContextLocations.Num(); ContextIndex++)
{
const float Distance = CalcDistance3D(ItemLocation, ContextLocations[ContextIndex]);
It.SetScore(TestPurpose, FilterType, Distance, MinThresholdValue, MaxThresholdValue);
}
}
break;
case EEnvTestDistance::Distance2D:
for (FEnvQueryInstance::ItemIterator It(this, QueryInstance); It; ++It)
{
const FVector ItemLocation = GetItemLocation(QueryInstance, It.GetIndex());
for (int32 ContextIndex = 0; ContextIndex < ContextLocations.Num(); ContextIndex++)
{
const float Distance = CalcDistance2D(ItemLocation, ContextLocations[ContextIndex]);
It.SetScore(TestPurpose, FilterType, Distance, MinThresholdValue, MaxThresholdValue);
}
}
break;
case EEnvTestDistance::DistanceZ:
for (FEnvQueryInstance::ItemIterator It(this, QueryInstance); It; ++It)
{
const FVector ItemLocation = GetItemLocation(QueryInstance, It.GetIndex());
for (int32 ContextIndex = 0; ContextIndex < ContextLocations.Num(); ContextIndex++)
{
const float Distance = CalcDistanceZ(ItemLocation, ContextLocations[ContextIndex]);
It.SetScore(TestPurpose, FilterType, Distance, MinThresholdValue, MaxThresholdValue);
}
}
break;
case EEnvTestDistance::DistanceAbsoluteZ:
for (FEnvQueryInstance::ItemIterator It(this, QueryInstance); It; ++It)
{
const FVector ItemLocation = GetItemLocation(QueryInstance, It.GetIndex());
for (int32 ContextIndex = 0; ContextIndex < ContextLocations.Num(); ContextIndex++)
{
const float Distance = CalcDistanceAbsoluteZ(ItemLocation, ContextLocations[ContextIndex]);
It.SetScore(TestPurpose, FilterType, Distance, MinThresholdValue, MaxThresholdValue);
}
}
break;
default:
checkNoEntry();
return;
}
}
void UEnvQueryTest_Trace::RunTest(struct FEnvQueryInstance& QueryInstance)
{
bool bWantsHit = false;
bool bTraceToItem = false;
bool bTraceComplex = true;
float ExtentX = 0.0f;
float ExtentY = 0.0f;
float ExtentZ = 0.0f;
float ItemZ = 0.0f;
float ContextZ = 0.0f;
if (!QueryInstance.GetParamValue(BoolFilter, bWantsHit, TEXT("BoolFilter")) ||
!QueryInstance.GetParamValue(TraceToItem, bTraceToItem, TEXT("TraceToItem")) ||
!QueryInstance.GetParamValue(TraceComplex, bTraceComplex, TEXT("TraceComplex")) ||
!QueryInstance.GetParamValue(TraceExtentX, ExtentX, TEXT("TraceExtentX")) ||
!QueryInstance.GetParamValue(TraceExtentY, ExtentY, TEXT("TraceExtentY")) ||
!QueryInstance.GetParamValue(TraceExtentZ, ExtentZ, TEXT("TraceExtentY")) ||
!QueryInstance.GetParamValue(ItemOffsetZ, ItemZ, TEXT("ItemOffsetZ")) ||
!QueryInstance.GetParamValue(ContextOffsetZ, ContextZ, TEXT("ContextOffsetZ"))
)
{
return;
}
TArray<FVector> ContextLocations;
if (!QueryInstance.PrepareContext(Context, ContextLocations))
{
return;
}
FCollisionQueryParams TraceParams(TEXT("EnvQueryTrace"), bTraceComplex);
TraceParams.bTraceAsyncScene = true;
TArray<AActor*> IgnoredActors;
if (QueryInstance.PrepareContext(Context, IgnoredActors))
{
TraceParams.AddIgnoredActors(IgnoredActors);
}
ECollisionChannel TraceCollisionChannel = UEngineTypes::ConvertToCollisionChannel(TraceChannel);
FRunTraceSignature TraceFunc;
switch (TraceMode)
{
case EEnvTestTrace::Line:
TraceFunc.BindUObject(this, bTraceToItem ? &UEnvQueryTest_Trace::RunLineTraceTo : &UEnvQueryTest_Trace::RunLineTraceFrom);
break;
case EEnvTestTrace::Box:
TraceFunc.BindUObject(this, bTraceToItem ? &UEnvQueryTest_Trace::RunBoxTraceTo : &UEnvQueryTest_Trace::RunBoxTraceFrom);
break;
case EEnvTestTrace::Sphere:
TraceFunc.BindUObject(this, bTraceToItem ? &UEnvQueryTest_Trace::RunSphereTraceTo : &UEnvQueryTest_Trace::RunSphereTraceFrom);
break;
case EEnvTestTrace::Capsule:
TraceFunc.BindUObject(this, bTraceToItem ? &UEnvQueryTest_Trace::RunCapsuleTraceTo : &UEnvQueryTest_Trace::RunCapsuleTraceFrom);
break;
default:
return;
}
for (int32 iContext = 0; iContext < ContextLocations.Num(); iContext++)
{
ContextLocations[iContext].Z += ContextZ;
}
for (FEnvQueryInstance::ItemIterator It(QueryInstance); It; ++It)
{
const FVector ItemLocation = GetItemLocation(QueryInstance, *It) + FVector(0,0,ItemZ);
AActor* ItemActor = GetItemActor(QueryInstance, *It);
for (int32 iContext = 0; iContext < ContextLocations.Num(); iContext++)
{
const bool bHit = TraceFunc.Execute(ItemLocation, ContextLocations[iContext], ItemActor, QueryInstance.World, TraceCollisionChannel, TraceParams, FVector(ExtentX, ExtentY, ExtentZ));
It.SetScore(Condition, bHit, bWantsHit);
}
}
}
INT unit_interact(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
CDebug cDbg("unit interact");
if(!GameReady())
return JS_TRUE;
myUnit* lpUnit = (myUnit*)JS_GetPrivate(cx, obj);
*rval = JSVAL_FALSE;
if(!lpUnit || IsBadReadPtr(lpUnit, sizeof(myUnit)) || lpUnit->_dwPrivateType != PRIVATE_UNIT)
return JS_TRUE;
UnitAny* pUnit = D2CLIENT_FindUnit(lpUnit->dwUnitId, lpUnit->dwType);
if(!pUnit)
return JS_TRUE;
if(pUnit->dwType == UNIT_ITEM && pUnit->dwMode != ITEM_MODE_ON_GROUND && pUnit->dwMode != ITEM_MODE_BEING_DROPPED)
{
INT nLocation = GetItemLocation(pUnit);
BYTE aPacket[13] = {NULL};
if(nLocation == STORAGE_INVENTORY)
{
aPacket[0] = 0x20;
*(DWORD*)&aPacket[1] = pUnit->dwUnitId;
*(DWORD*)&aPacket[5] = D2CLIENT_GetPlayerUnit()->pPath->xPos;
*(DWORD*)&aPacket[9] = D2CLIENT_GetPlayerUnit()->pPath->yPos;
D2NET_SendPacket(13, 1, aPacket);
return JS_TRUE;
}
else if(nLocation == STORAGE_BELT)
{
aPacket[0] = 0x26;
*(DWORD*)&aPacket[1] = pUnit->dwUnitId;
*(DWORD*)&aPacket[5] = 0;
*(DWORD*)&aPacket[9] = 0;
D2NET_SendPacket(13, 1, aPacket);
return JS_TRUE;
}
}
if(pUnit->dwType == UNIT_OBJECT && argc == 1 && JSVAL_IS_INT(argv[0]))
{
// TODO: check the range on argv[0] to make sure it won't crash the game
D2CLIENT_TakeWaypoint(pUnit->dwUnitId, JSVAL_TO_INT(argv[0]));
// D2CLIENT_TakeWP(pUnit->dwUnitId, JSVAL_TO_INT(argv[0]));
*rval = JSVAL_TRUE;
return JS_TRUE;
}
else if(pUnit->dwType == UNIT_PLAYER && argc == 1 && JSVAL_IS_INT(argv[0]) && JSVAL_TO_INT(argv[0]) == 1)
{
// Accept Trade
}
else
{
*rval = JSVAL_TRUE;
ClickMap(0, GetUnitX(pUnit), GetUnitY(pUnit), FALSE, pUnit);
//D2CLIENT_Interact(pUnit, 0x45);
}
return JS_TRUE;
}
FString UEnvQueryItemType_VectorBase::GetDescription(const uint8* RawData) const
{
FVector PointLocation = GetItemLocation(RawData);
return FString::Printf(TEXT("(X=%.0f,Y=%.0f,Z=%.0f)"), PointLocation.X, PointLocation.Y, PointLocation.Z);
}
void UEnvQueryTest_Dot::RunTest(FEnvQueryInstance& QueryInstance) const
{
FloatValueMin.BindData(QueryInstance.Owner.Get(), QueryInstance.QueryID);
float MinThresholdValue = FloatValueMin.GetValue();
FloatValueMax.BindData(QueryInstance.Owner.Get(), QueryInstance.QueryID);
float MaxThresholdValue = FloatValueMax.GetValue();
// gather all possible directions: for contexts different than Item
TArray<FVector> LineADirs;
const bool bUpdateLineAPerItem = RequiresPerItemUpdates(LineA.LineFrom, LineA.LineTo, LineA.Rotation, LineA.DirMode == EEnvDirection::Rotation);
if (!bUpdateLineAPerItem)
{
GatherLineDirections(LineADirs, QueryInstance, LineA.LineFrom, LineA.LineTo, LineA.Rotation, LineA.DirMode == EEnvDirection::Rotation);
if (LineADirs.Num() == 0)
{
return;
}
}
TArray<FVector> LineBDirs;
const bool bUpdateLineBPerItem = RequiresPerItemUpdates(LineB.LineFrom, LineB.LineTo, LineB.Rotation, LineB.DirMode == EEnvDirection::Rotation);
if (!bUpdateLineBPerItem)
{
GatherLineDirections(LineBDirs, QueryInstance, LineB.LineFrom, LineB.LineTo, LineB.Rotation, LineB.DirMode == EEnvDirection::Rotation);
if (LineBDirs.Num() == 0)
{
return;
}
}
// loop through all items
for (FEnvQueryInstance::ItemIterator It(this, QueryInstance); It; ++It)
{
// update lines for contexts using current item
if (bUpdateLineAPerItem || bUpdateLineBPerItem)
{
const FVector ItemLocation = (LineA.DirMode == EEnvDirection::Rotation && LineB.DirMode == EEnvDirection::Rotation) ? FVector::ZeroVector : GetItemLocation(QueryInstance, *It);
const FRotator ItemRotation = (LineA.DirMode == EEnvDirection::Rotation || LineB.DirMode == EEnvDirection::Rotation) ? GetItemRotation(QueryInstance, *It) : FRotator::ZeroRotator;
if (bUpdateLineAPerItem)
{
LineADirs.Reset();
GatherLineDirections(LineADirs, QueryInstance, LineA.LineFrom, LineA.LineTo, LineA.Rotation, LineA.DirMode == EEnvDirection::Rotation, ItemLocation, ItemRotation);
}
if (bUpdateLineBPerItem)
{
LineBDirs.Reset();
GatherLineDirections(LineBDirs, QueryInstance, LineB.LineFrom, LineB.LineTo, LineB.Rotation, LineB.DirMode == EEnvDirection::Rotation, ItemLocation, ItemRotation);
}
}
// perform test for each line pair
for (int32 LineAIndex = 0; LineAIndex < LineADirs.Num(); LineAIndex++)
{
for (int32 LineBIndex = 0; LineBIndex < LineBDirs.Num(); LineBIndex++)
{
float DotValue = 0.f;
switch (TestMode)
{
case EEnvTestDot::Dot3D:
DotValue = FVector::DotProduct(LineADirs[LineAIndex], LineBDirs[LineBIndex]);
break;
case EEnvTestDot::Dot2D:
DotValue = LineADirs[LineAIndex].CosineAngle2D(LineBDirs[LineBIndex]);
break;
default:
UE_LOG(LogEQS, Error, TEXT("Invalid TestMode in EnvQueryTest_Dot in query %s!"), *QueryInstance.QueryName);
break;
}
if (bAbsoluteValue)
{
DotValue = FMath::Abs(DotValue);
}
It.SetScore(TestPurpose, FilterType, DotValue, MinThresholdValue, MaxThresholdValue);
}
}
}
}
