/// <summary>
/// Refraction RenderTexture
/// </summary>
private void DrawRefractionRenderTexture(Camera cam)
{
CreateRenderTexAndCam(cam, ref _refractionRenderTex, ref _refractionCamera);
WaterHelper.CloneCameraModes(cam, _refractionCamera);
Vector3 pos = transform.position;
Vector3 normal = transform.up;
Matrix4x4 projection = cam.worldToCameraMatrix;
projection *= Matrix4x4.Scale(new Vector3(1, Mathf.Clamp(1 - RefractionAngle, 0.001f, 1), 1));
_refractionCamera.worldToCameraMatrix = projection;
Vector4 clipPlane = WaterHelper.CameraSpacePlane(_refractionCamera, pos, normal, -1.0f, 0);
projection = cam.projectionMatrix;
/*projection[2] = clipPlane.x + projection[3];//x
* projection[6] = clipPlane.y + projection[7];//y
* projection[10] = clipPlane.z + projection[11];//z
* projection[14] = clipPlane.w + projection[15];//w*
* _refractionCamera.projectionMatrix = projection;*/
_refractionCamera.projectionMatrix = WaterHelper.CalculateObliqueMatrix(projection, clipPlane);
_refractionCamera.cullingMask = ~(1 << 4) & Layers.value; // never render water layer
_refractionCamera.targetTexture = _refractionRenderTex;
_refractionCamera.transform.position = cam.transform.position;
_refractionCamera.transform.eulerAngles = cam.transform.eulerAngles;
_refractionCamera.Render();
}
public void AddWaterHelper(WaterHelper help)
{
if (waterHelpers == null)
{
waterHelpers = new List <WaterHelper>();
}
if (!WaterAlreadyAdded(help))
{
waterHelpers.Add(help);
}
}
public bool WaterAlreadyAdded(WaterHelper check)
{
if (waterHelpers == null)
{
return(false);
}
if (waterHelpers.Contains(check))
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// 解析详细页面并插入数据库
/// </summary>
/// <param name="pageUrl"></param>
/// <returns></returns>
public static int ParserPage(string pageUrl)
{
//获取目标url
string targetUrl = CommonParserBusiness.GetUrl(pageUrl);
//返回结果
int result = 0;
//如果目标地址解析成功
if (targetUrl != "failed")
{
bool exist = WaterHelper.QueryUrlExist(targetUrl);
if (!exist)
{
//获取解析的页面数据
string[] waterlevel = new string[6];
waterlevel = CommonParserBusiness.GetDataFromTable(targetUrl);
if (waterlevel[5] != "failed")
{
bool sql = WaterHelper.SaveToWaterLevelInfo(waterlevel[0], waterlevel[1], waterlevel[2], waterlevel[3], waterlevel[4]);
if (sql)
{
result = 2;//解析成功，已成功导入到数据库！
}
else
{
result = 5;//插入到数据库出错！
}
}
else
{
result = 4;//详细信息页面解析出错！
}
}
else
{
result = 1;//"尚未更新！"
}
}
else
{
result = 3;//列表信息页面解析出错！
}
return(result);
}
public override void OnInspectorGUI()
{
if (!isVisible)
{
base.OnInspectorGUI();
return;
}
Material targetMat = target as Material;
var sourceMaterial = (Material)EditorGUILayout.ObjectField("Copy From", null, typeof(Material), false);
if (sourceMaterial)
{
WaterHelper.CopyWaterProperties(sourceMaterial, targetMat);
}
base.OnInspectorGUI();
}
private void DrawReflectionRenderTexture(Camera cam)
{
Vector3 pos = transform.position;
Vector3 normal = transform.up;
CreateRenderTexAndCam(cam, ref _reflectionRenderTex, ref _reflectionCamera);
WaterHelper.CloneCameraModes(cam, _reflectionCamera);
float d = -Vector3.Dot(normal, pos) - reflectClipPlaneOffset;
Vector4 reflectionPlane = new Vector4(normal.x, normal.y, normal.z, d);
Matrix4x4 reflection = WaterHelper.CalculateReflectionMatrix(Matrix4x4.zero, reflectionPlane);
Vector3 oldpos = cam.transform.position;
Vector3 newpos = reflection.MultiplyPoint(oldpos);
_reflectionCamera.worldToCameraMatrix = cam.worldToCameraMatrix * reflection;
// Setup oblique projection matrix so that near plane is our reflection
// plane. This way we clip everything below/above it for free.
Vector4 clipPlane = WaterHelper.CameraSpacePlane(_reflectionCamera, pos, normal, 1.0f, reflectClipPlaneOffset);
Matrix4x4 projection = cam.projectionMatrix;
projection = WaterHelper.CalculateObliqueMatrix(projection, clipPlane);
//Matrix4x4 projection = cam.CalculateObliqueMatrix(clipPlane);
_reflectionCamera.projectionMatrix = projection;
_reflectionCamera.cullingMask = ~(1 << 4) & Layers.value; // never render water layer
_reflectionCamera.targetTexture = _reflectionRenderTex;
GL.invertCulling = true;
_reflectionCamera.transform.position = newpos;
Vector3 euler = cam.transform.eulerAngles;
_reflectionCamera.transform.eulerAngles = new Vector3(0, euler.y, euler.z);
_reflectionCamera.Render();
_reflectionCamera.transform.position = oldpos;
GL.invertCulling = false;
}
public bool AreConditionsMets()
{
if (!_gotWatchedBlocks)
{
SetupWatchedBlocks();
}
if (UseConditions == false)
{
return(true);
}
int usedConditions = 0;
int satisfiedConditions = 0;
if (_behavior == null)
{
_behavior = BehaviorManager.GetBehavior(_remoteControl);
if (_behavior == null)
{
return(false);
}
}
if (CheckAllLoadedModIDs == true)
{
usedConditions++;
bool missingMod = false;
foreach (var mod in AllModIDsToCheck)
{
if (Utilities.ModIDs.Contains(mod) == false)
{
Logger.MsgDebug(ProfileSubtypeId + ": Mod ID Not Present", DebugTypeEnum.Condition);
missingMod = true;
break;
}
}
if (!missingMod)
{
satisfiedConditions++;
}
}
if (CheckAnyLoadedModIDs == true)
{
usedConditions++;
foreach (var mod in AllModIDsToCheck)
{
if (Utilities.ModIDs.Contains(mod))
{
Logger.MsgDebug(ProfileSubtypeId + ": A Mod ID was Found: " + mod.ToString(), DebugTypeEnum.Condition);
satisfiedConditions++;
break;
}
}
}
if (CheckTrueBooleans == true)
{
usedConditions++;
bool failedCheck = false;
foreach (var boolName in TrueBooleans)
{
if (!_settings.GetCustomBoolResult(boolName))
{
Logger.MsgDebug(ProfileSubtypeId + ": Boolean Not True: " + boolName, DebugTypeEnum.Condition);
failedCheck = true;
break;
}
}
if (!failedCheck)
{
satisfiedConditions++;
}
}
if (CheckCustomCounters == true)
{
usedConditions++;
bool failedCheck = false;
if (CustomCounters.Count == CustomCountersTargets.Count)
{
for (int i = 0; i < CustomCounters.Count; i++)
{
try {
var compareType = CounterCompareEnum.GreaterOrEqual;
if (i <= CounterCompareTypes.Count - 1)
{
compareType = CounterCompareTypes[i];
}
if (_settings.GetCustomCounterResult(CustomCounters[i], CustomCountersTargets[i], compareType) == false)
{
Logger.MsgDebug(ProfileSubtypeId + ": Counter Amount Condition Not Satisfied: " + CustomCounters[i], DebugTypeEnum.Condition);
failedCheck = true;
break;
}
} catch (Exception e) {
Logger.MsgDebug("Exception: ", DebugTypeEnum.Condition);
Logger.MsgDebug(e.ToString(), DebugTypeEnum.Condition);
}
}
}
else
{
Logger.MsgDebug(ProfileSubtypeId + ": Counter Names and Targets List Counts Don't Match. Check Your Condition Profile", DebugTypeEnum.Condition);
failedCheck = true;
}
if (!failedCheck)
{
satisfiedConditions++;
}
}
if (CheckTrueSandboxBooleans == true)
{
usedConditions++;
bool failedCheck = false;
for (int i = 0; i < TrueSandboxBooleans.Count; i++)
{
try {
bool output = false;
var result = MyAPIGateway.Utilities.GetVariable(TrueSandboxBooleans[i], out output);
if (!result || !output)
{
Logger.MsgDebug(ProfileSubtypeId + ": Sandbox Boolean False: " + TrueSandboxBooleans[i], DebugTypeEnum.Condition);
failedCheck = true;
break;
}
} catch (Exception e) {
Logger.MsgDebug("Exception: ", DebugTypeEnum.Condition);
Logger.MsgDebug(e.ToString(), DebugTypeEnum.Condition);
}
}
if (!failedCheck)
{
satisfiedConditions++;
}
}
if (CheckCustomSandboxCounters == true)
{
usedConditions++;
bool failedCheck = false;
if (CustomSandboxCounters.Count == CustomSandboxCountersTargets.Count)
{
for (int i = 0; i < CustomSandboxCounters.Count; i++)
{
try {
int counter = 0;
var result = MyAPIGateway.Utilities.GetVariable(CustomSandboxCounters[i], out counter);
var compareType = CounterCompareEnum.GreaterOrEqual;
if (i <= SandboxCounterCompareTypes.Count - 1)
{
compareType = SandboxCounterCompareTypes[i];
}
bool counterResult = false;
if (compareType == CounterCompareEnum.GreaterOrEqual)
{
counterResult = (counter >= CustomSandboxCountersTargets[i]);
}
if (compareType == CounterCompareEnum.Greater)
{
counterResult = (counter > CustomSandboxCountersTargets[i]);
}
if (compareType == CounterCompareEnum.Equal)
{
counterResult = (counter == CustomSandboxCountersTargets[i]);
}
if (compareType == CounterCompareEnum.NotEqual)
{
counterResult = (counter != CustomSandboxCountersTargets[i]);
}
if (compareType == CounterCompareEnum.Less)
{
counterResult = (counter < CustomSandboxCountersTargets[i]);
}
if (compareType == CounterCompareEnum.LessOrEqual)
{
counterResult = (counter <= CustomSandboxCountersTargets[i]);
}
if (!result || !counterResult)
{
Logger.MsgDebug(ProfileSubtypeId + ": Sandbox Counter Amount Condition Not Satisfied: " + CustomSandboxCounters[i], DebugTypeEnum.Condition);
failedCheck = true;
break;
}
} catch (Exception e) {
Logger.MsgDebug("Exception: ", DebugTypeEnum.Condition);
Logger.MsgDebug(e.ToString(), DebugTypeEnum.Condition);
}
}
}
else
{
Logger.MsgDebug(ProfileSubtypeId + ": Sandbox Counter Names and Targets List Counts Don't Match. Check Your Condition Profile", DebugTypeEnum.Condition);
failedCheck = true;
}
if (!failedCheck)
{
satisfiedConditions++;
}
}
if (CheckGridSpeed == true)
{
usedConditions++;
float speed = (float)_remoteControl.GetShipSpeed();
if ((MinGridSpeed == -1 || speed >= MinGridSpeed) && (MaxGridSpeed == -1 || speed <= MaxGridSpeed))
{
Logger.MsgDebug(ProfileSubtypeId + ": Grid Speed High Enough", DebugTypeEnum.Condition);
satisfiedConditions++;
}
else
{
Logger.MsgDebug(ProfileSubtypeId + ": Grid Speed Not High Enough", DebugTypeEnum.Condition);
}
}
if (MESApi.MESApiReady && CheckMESBlacklistedSpawnGroups)
{
var blackList = MESApi.GetSpawnGroupBlackList();
if (SpawnGroupBlacklistContainsAll.Count > 0)
{
usedConditions++;
bool failedCheck = false;
foreach (var group in SpawnGroupBlacklistContainsAll)
{
if (blackList.Contains(group) == false)
{
Logger.MsgDebug(ProfileSubtypeId + ": A Spawngroup was not on MES BlackList: " + group, DebugTypeEnum.Condition);
failedCheck = true;
break;
}
}
if (!failedCheck)
{
satisfiedConditions++;
}
}
if (SpawnGroupBlacklistContainsAny.Count > 0)
{
usedConditions++;
foreach (var group in SpawnGroupBlacklistContainsAll)
{
if (blackList.Contains(group))
{
Logger.MsgDebug(ProfileSubtypeId + ": A Spawngroup was on MES BlackList: " + group, DebugTypeEnum.Condition);
satisfiedConditions++;
break;
}
}
}
}
if (UseAccumulatedDamageWatcher)
{
usedConditions++;
bool failedCheck = false;
if (MinAccumulatedDamage >= 0 && MinAccumulatedDamage < _settings.TotalDamageAccumulated)
{
failedCheck = true;
}
if (MaxAccumulatedDamage >= 0 && MaxAccumulatedDamage > _settings.TotalDamageAccumulated)
{
failedCheck = true;
}
if (!failedCheck)
{
satisfiedConditions++;
}
}
if (UseRequiredFunctionalBlocks)
{
if (_watchingAllBlocks)
{
usedConditions++;
if (_watchedAllBlocksResult)
{
satisfiedConditions++;
}
}
if (_watchingAnyBlocks)
{
usedConditions++;
if (_watchedAnyBlocksResult)
{
satisfiedConditions++;
}
}
if (_watchingNoneBlocks)
{
usedConditions++;
if (_watchedNoneBlocksResult)
{
satisfiedConditions++;
}
}
}
if (CheckTargetAltitudeDifference)
{
usedConditions++;
if (_behavior.AutoPilot.Targeting.HasTarget() && _behavior.AutoPilot.InGravity())
{
var planetPos = _behavior.AutoPilot.CurrentPlanet.PositionComp.WorldAABB.Center;
var targetCoreDist = _behavior.AutoPilot.Targeting.Target.Distance(planetPos);
var myCoreDist = Vector3D.Distance(planetPos, _remoteControl.GetPosition());
var difference = targetCoreDist - myCoreDist;
if (difference >= this.MinTargetAltitudeDifference && difference <= this.MaxTargetAltitudeDifference)
{
satisfiedConditions++;
}
}
}
if (CheckTargetDistance)
{
usedConditions++;
if (_behavior.AutoPilot.Targeting.HasTarget())
{
var dist = _behavior.AutoPilot.Targeting.Target.Distance(_remoteControl.GetPosition());
if ((this.MinTargetDistance == -1 || dist >= this.MinTargetDistance) && (this.MaxTargetDistance == -1 || dist <= this.MaxTargetDistance))
{
satisfiedConditions++;
}
}
}
if (CheckTargetAngleFromForward)
{
usedConditions++;
if (_behavior.AutoPilot.Targeting.HasTarget())
{
var dirToTarget = Vector3D.Normalize(_behavior.AutoPilot.Targeting.GetTargetCoords() - _remoteControl.GetPosition());
var myForward = _behavior.AutoPilot.RefBlockMatrixRotation.Forward;
var angle = VectorHelper.GetAngleBetweenDirections(dirToTarget, myForward);
if ((this.MinTargetAngle == -1 || angle >= this.MinTargetAngle) && (this.MaxTargetAngle == -1 || angle <= this.MaxTargetAngle))
{
satisfiedConditions++;
}
}
}
if (CheckIfTargetIsChasing)
{
usedConditions++;
if (_behavior.AutoPilot.Targeting.HasTarget())
{
var dirFromTarget = Vector3D.Normalize(_remoteControl.GetPosition() - _behavior.AutoPilot.Targeting.GetTargetCoords());
var targetVelocity = Vector3D.Normalize(_behavior.AutoPilot.Targeting.Target.CurrentVelocity());
if (targetVelocity.IsValid() && targetVelocity.Length() > 0)
{
var angle = VectorHelper.GetAngleBetweenDirections(dirFromTarget, targetVelocity);
if ((this.MinTargetChaseAngle == -1 || angle >= this.MinTargetChaseAngle) && (this.MaxTargetChaseAngle == -1 || angle <= this.MaxTargetChaseAngle))
{
satisfiedConditions++;
}
}
}
}
if (CheckIfGridNameMatches)
{
usedConditions++;
if (!string.IsNullOrWhiteSpace(_remoteControl.SlimBlock.CubeGrid.CustomName))
{
bool pass = false;
foreach (var name in GridNamesToCheck)
{
if (AllowPartialGridNameMatches)
{
if (_remoteControl.SlimBlock.CubeGrid.CustomName.Contains(name))
{
pass = true;
}
}
else
{
if (_remoteControl.SlimBlock.CubeGrid.CustomName == name)
{
pass = true;
}
}
}
if (pass)
{
satisfiedConditions++;
}
}
}
if (UnderwaterCheck)
{
usedConditions++;
if (WaterHelper.UnderwaterAndDepthCheck(_remoteControl.GetPosition(), _behavior.AutoPilot.CurrentWater, IsUnderwater, MinDistanceUnderwater, MaxDistanceUnderwater))
{
satisfiedConditions++;
}
}
if (TargetUnderwaterCheck)
{
usedConditions++;
if (WaterHelper.UnderwaterAndDepthCheck(_remoteControl.GetPosition(), _behavior.AutoPilot.CurrentWater, TargetIsUnderwater, MinTargetDistanceUnderwater, MaxTargetDistanceUnderwater))
{
satisfiedConditions++;
}
}
if (BehaviorModeCheck)
{
usedConditions++;
if (_behavior.Mode == CurrentBehaviorMode)
{
satisfiedConditions++;
}
}
if (MatchAnyCondition == false)
{
bool result = satisfiedConditions >= usedConditions;
Logger.MsgDebug(ProfileSubtypeId + ": All Condition Satisfied: " + result.ToString(), DebugTypeEnum.Condition);
Logger.MsgDebug(string.Format("Used Conditions: {0} // Satisfied Conditions: {1}", usedConditions, satisfiedConditions), DebugTypeEnum.Condition);
return(result);
}
else
{
bool result = satisfiedConditions > 0;
Logger.MsgDebug(ProfileSubtypeId + ": Any Condition(s) Satisfied: " + result.ToString(), DebugTypeEnum.Condition);
Logger.MsgDebug(string.Format("Used Conditions: {0} // Satisfied Conditions: {1}", usedConditions, satisfiedConditions), DebugTypeEnum.Condition);
return(result);
}
}
private void CreateWaterObjects(Camera currentCamera, out Camera reflectionCamera, out Camera refractionCamera)
{
SceneRenderingQuality mode = GetWaterMode();
reflectionCamera = null;
refractionCamera = null;
if (mode >= SceneRenderingQuality.High)
{
// 反射相机
m_ReflectionCameras.TryGetValue(currentCamera, out reflectionCamera);
if (!reflectionCamera)
{
GameObject go = new GameObject("Water Refl Camera id" + GetInstanceID() + " for " + currentCamera.GetInstanceID(), typeof(Camera));
reflectionCamera = go.GetComponent <Camera>();
reflectionCamera.transform.SetPosition(transform.position);
reflectionCamera.transform.rotation = transform.rotation;
reflectionCamera.gameObject.AddComponent <FlareLayer>();
reflectionCamera.renderingPath = RenderingPath.VertexLit;
WaterHelper helper = reflectionCamera.gameObject.AddComponent <WaterHelper>();
helper.hostWater = this;
helper.hostCamera = reflectionCamera;
WaterCullLayer = 0;
WaterCullLayer |= 1 << WaterObjLayer; //反射水物体
WaterCullLayer |= 1 << LayerMask.NameToLayer(Config.LayerPlayerEnemy); //反射友方玩家
WaterCullLayer |= 1 << LayerMask.NameToLayer(Config.LayerPlayerFriend); //反射敌方玩家
WaterCullLayer |= 1 << LayerMask.NameToLayer(Config.LayerHero); //反射主角玩家
reflectionCamera.cullingMask = WaterCullLayer;
int layer = currentCamera.cullingMask;
layer = layer & ~(1 << WaterObjLayer);
currentCamera.cullingMask = layer;
reflectionCamera.targetTexture = m_ReflectionTexture;
go.hideFlags = HideFlags.HideAndDontSave;
m_ReflectionCameras[currentCamera] = reflectionCamera;
}
//反射RT
if (!m_ReflectionTexture || m_OldReflectionTextureSize != m_TextureSize)
{
if (m_ReflectionTexture)
{
DestroyImmediate(m_ReflectionTexture);
}
m_ReflectionTexture = new RenderTexture(m_TextureSize, m_TextureSize, 16);
m_ReflectionTexture.name = "__WaterReflection" + GetInstanceID();
m_ReflectionTexture.isPowerOfTwo = true;
m_ReflectionTexture.hideFlags = HideFlags.DontSave;
m_OldReflectionTextureSize = m_TextureSize;
reflectionCamera.targetTexture = m_ReflectionTexture;
}
}
if (mode >= SceneRenderingQuality.Best)
{
// 折射相机
m_RefractionCameras.TryGetValue(currentCamera, out refractionCamera);
if (!refractionCamera)
{
GameObject go = new GameObject("Water Refr Camera id" + GetInstanceID() + " for " + currentCamera.GetInstanceID(), typeof(Camera));
refractionCamera = go.GetComponent <Camera>();
refractionCamera.transform.SetPosition(transform.position);
refractionCamera.transform.rotation = transform.rotation;
refractionCamera.gameObject.AddComponent <FlareLayer>();
refractionCamera.renderingPath = RenderingPath.VertexLit;
WaterHelper helper = refractionCamera.gameObject.AddComponent <WaterHelper>();
helper.hostWater = this;
helper.hostCamera = refractionCamera;
refractionCamera.targetTexture = m_RefractionTexture;
WaterCullLayer = 0;
WaterCullLayer |= 1 << WaterObjLayer; //反射水物体
WaterCullLayer |= 1 << LayerMask.NameToLayer(Config.LayerPlayerEnemy); //反射友方玩家
WaterCullLayer |= 1 << LayerMask.NameToLayer(Config.LayerPlayerFriend); //反射敌方玩家
WaterCullLayer |= 1 << LayerMask.NameToLayer(Config.LayerHero); //反射主角玩家
refractionCamera.cullingMask = WaterCullLayer;
int layer = currentCamera.cullingMask;
layer = layer & ~(1 << WaterObjLayer);;
currentCamera.cullingMask = layer;
go.hideFlags = HideFlags.HideAndDontSave;
m_RefractionCameras[currentCamera] = refractionCamera;
}
// 折射RT
if (!m_RefractionTexture || m_OldRefractionTextureSize != m_TextureSize)
{
if (m_RefractionTexture)
{
DestroyImmediate(m_RefractionTexture);
}
m_RefractionTexture = new RenderTexture(m_TextureSize, m_TextureSize, 16);
m_RefractionTexture.name = "__WaterRefraction" + GetInstanceID();
m_RefractionTexture.isPowerOfTwo = true;
m_RefractionTexture.hideFlags = HideFlags.DontSave;
m_OldRefractionTextureSize = m_TextureSize;
refractionCamera.targetTexture = m_RefractionTexture;
}
}
}
public void VoxelCheckRequest(bool useAsteroidAABB = false)
{
if (_collisionSystem.AutoPilot.InGravity())
{
var stepList = _collisionSystem.AutoPilot.GetPlanetPathSteps(StartPosition, DirectionVector, Distance, true);
var planet = _collisionSystem.AutoPilot.GetCurrentPlanet();
var planetCenter = planet.PositionComp.WorldAABB.Center;
int index = -1;
bool underwater = false;
for (int i = 0; i < stepList.Count; i++)
{
var step = stepList[i];
var stepToCore = Vector3D.Distance(planetCenter, step);
var stepSurfaceToCore = Vector3D.Distance(planetCenter, WaterHelper.GetClosestSurface(step, planet, _collisionSystem.AutoPilot.CurrentWater));
if (stepToCore < stepSurfaceToCore)
{
//Logger.MsgDebug("Planet Voxel Found: ", DebugTypeEnum.Collision);
index = i == 0 ? 0 : i - 1;
break;
}
}
if (index >= 0)
{
CollisionIsWater = WaterHelper.IsPositionUnderwater(stepList[index], _collisionSystem.AutoPilot.CurrentWater);
VoxelEntity = planet;
VoxelCoords = stepList[index];
VoxelDistance = Vector3D.Distance(StartPosition, stepList[index]);
}
}
else
{
MyVoxelBase closestVoxel = null;
double closestDistance = -1;
/*
* //Temp Debug Code Start
* _voxelScanList.Clear();
* var startCorner = StartPosition + new Vector3D(-2000, -2000, -2000);
* var endCorner = StartPosition + new Vector3D(2000, 2000, 2000);
* var box = new BoundingBoxD(startCorner, endCorner);
* MyGamePruningStructure.GetAllVoxelMapsInBox(ref box, _voxelScanList);
*/
foreach (var voxel in _voxelScanList)
{
var planet = voxel as MyPlanet;
if (planet != null)
{
continue;
}
if (!useAsteroidAABB)
{
double minDist = 0;
double maxDist = 0;
bool boxCheckResult = voxel.PositionComp.WorldAABB.Intersect(ref Ray, out minDist, out maxDist);
Vector3D startBox = boxCheckResult ? (minDist - 5) * DirectionVector + StartPosition : StartPosition;
Vector3D endBox = boxCheckResult ? (maxDist + 5) * DirectionVector + StartPosition : EndPosition;
Vector3D?hitPosition = null;
LineD voxelLine = new LineD(startBox, endBox);
bool gotHit = false;
try {
using (voxel.Pin()) {
gotHit = voxel.GetIntersectionWithLine(ref voxelLine, out hitPosition);
}
} catch (Exception e) {
Logger.WriteLog("Supressed Exception While Checking Voxel Collision");
Logger.WriteLog(e.ToString());
}
if (hitPosition.HasValue)
{
var hitDist = Vector3D.Distance((Vector3D)hitPosition, StartPosition);
if (closestVoxel == null || closestVoxel != null && hitDist < closestDistance)
{
closestVoxel = voxel;
closestDistance = hitDist;
}
}
}
else
{
if (voxel.PositionComp.WorldAABB.Contains(StartPosition) == ContainmentType.Contains)
{
var hitDist = Vector3D.Distance(StartPosition, StartPosition + DirectionVector);
if (closestVoxel == null || closestVoxel != null && hitDist < closestDistance)
{
closestVoxel = voxel;
closestDistance = hitDist;
}
}
else
{
double hitDist = 0;
voxel.PositionComp.WorldAABB.Intersects(ref Line, out hitDist);
if (closestVoxel == null || closestVoxel != null && hitDist < closestDistance)
{
closestVoxel = voxel;
closestDistance = hitDist;
}
}
}
}
if (closestDistance == -1)
{
return;
}
VoxelEntity = closestVoxel;
VoxelDistance = closestDistance;
VoxelCoords = closestDistance * DirectionVector + StartPosition;
}
}
public bool EvaluateTarget(ITarget target, TargetProfile data, bool skipExpensiveChecks = false)
{
if (target == null)
{
Logger.MsgDebug("Target Is Null, Cannot Evaluate", DebugTypeEnum.TargetEvaluation);
return(false);
}
if (!target.ActiveEntity())
{
Logger.MsgDebug("Target Invalid, Cannot Evaluate", DebugTypeEnum.TargetEvaluation);
return(false);
}
Logger.MsgDebug(string.Format(" - Evaluating Target: {0} using profile {1}", target.Name(), data.ProfileSubtypeId), DebugTypeEnum.TargetEvaluation);
if (!data.BuiltUniqueFilterList)
{
foreach (var filter in data.MatchAllFilters)
{
if (!data.AllUniqueFilters.Contains(filter))
{
data.AllUniqueFilters.Add(filter);
}
}
foreach (var filter in data.MatchAnyFilters)
{
if (!data.AllUniqueFilters.Contains(filter))
{
data.AllUniqueFilters.Add(filter);
}
}
foreach (var filter in data.MatchNoneFilters)
{
if (!data.AllUniqueFilters.Contains(filter))
{
data.AllUniqueFilters.Add(filter);
}
}
data.BuiltUniqueFilterList = true;
}
List <TargetFilterEnum> FilterHits = new List <TargetFilterEnum>();
//Distance
var distance = target.Distance(RemoteControl.GetPosition());
if (distance > data.MaxDistance)
{
return(false);
}
//Altitude
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Altitude))
{
var altitude = target.CurrentAltitude();
if (altitude == -1000000 || (altitude >= data.MinAltitude && altitude <= data.MaxAltitude))
{
FilterHits.Add(TargetFilterEnum.Altitude);
}
Logger.MsgDebug(string.Format(" - Evaluated Altitude: {0}", altitude), DebugTypeEnum.TargetEvaluation);
}
//Broadcasting
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Broadcasting))
{
var range = target.BroadcastRange(data.BroadcastOnlyAntenna);
if (range > distance || distance < data.NonBroadcastVisualRange)
{
FilterHits.Add(TargetFilterEnum.Broadcasting);
}
Logger.MsgDebug(string.Format(" - Evaluated Broadcast Range vs Distance: {0} / {1}", range, distance), DebugTypeEnum.TargetEvaluation);
}
//Faction
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Faction))
{
var faction = target.FactionOwner() ?? "";
if (data.PrioritizeSpecifiedFactions || data.FactionTargets.Contains(faction))
{
FilterHits.Add(TargetFilterEnum.Faction);
}
Logger.MsgDebug(string.Format(" - Evaluated Faction: {0}", faction), DebugTypeEnum.TargetEvaluation);
}
//Gravity
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Gravity))
{
var gravity = target.CurrentGravity();
if (gravity >= data.MinGravity && gravity <= data.MaxGravity)
{
FilterHits.Add(TargetFilterEnum.Gravity);
}
Logger.MsgDebug(string.Format(" - Evaluated Gravity: {0}", gravity), DebugTypeEnum.TargetEvaluation);
}
//LineOfSight
if (!skipExpensiveChecks && data.AllUniqueFilters.Contains(TargetFilterEnum.LineOfSight) && _behavior.AutoPilot.Collision.TargetResult.HasTarget())
{
bool targetMatch = (target.GetParentEntity().EntityId == _behavior.AutoPilot.Collision.TargetResult.GetCollisionEntity().EntityId);
if (targetMatch)
{
FilterHits.Add(TargetFilterEnum.MovementScore);
}
}
//MovementScore
if (data.AllUniqueFilters.Contains(TargetFilterEnum.MovementScore))
{
if (distance < data.MaxMovementDetectableDistance || data.MaxMovementDetectableDistance < 0)
{
var score = target.MovementScore();
if ((data.MinMovementScore == -1 || score >= data.MinMovementScore) && (data.MaxMovementScore == -1 || score <= data.MaxMovementScore))
{
FilterHits.Add(TargetFilterEnum.MovementScore);
}
}
}
//Name
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Name))
{
var name = target.Name();
string successName = "N/A";
foreach (var allowedName in data.Names)
{
if (string.IsNullOrWhiteSpace(allowedName))
{
continue;
}
if (data.UsePartialNameMatching)
{
if (name.Contains(allowedName))
{
successName = allowedName;
break;
}
}
else
{
if (name == allowedName)
{
successName = allowedName;
break;
}
}
}
if (successName != "N/A")
{
FilterHits.Add(TargetFilterEnum.Name);
}
Logger.MsgDebug(string.Format(" - Evaluated Name: {0} // {1}", name, successName), DebugTypeEnum.TargetEvaluation);
}
//OutsideOfSafezone
if (data.AllUniqueFilters.Contains(TargetFilterEnum.OutsideOfSafezone))
{
bool inZone = target.InSafeZone();
if (!inZone)
{
FilterHits.Add(TargetFilterEnum.OutsideOfSafezone);
}
Logger.MsgDebug(string.Format(" - Evaluated Outside Safezone: {0}", !inZone), DebugTypeEnum.TargetEvaluation);
}
//Owner
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Owner))
{
var owners = target.OwnerTypes(data.OnlyGetFromEntityOwner, data.GetFromMinorityGridOwners);
bool gotRelation = false;
var values = Enum.GetValues(typeof(OwnerTypeEnum)).Cast <OwnerTypeEnum>();
foreach (var ownerType in values)
{
if (ownerType == OwnerTypeEnum.None)
{
continue;
}
if (owners.HasFlag(ownerType) && data.Owners.HasFlag(ownerType))
{
gotRelation = true;
break;
}
}
if (gotRelation)
{
FilterHits.Add(TargetFilterEnum.Owner);
}
Logger.MsgDebug(string.Format(" - Evaluated Owners: Required: {0}", data.Owners.ToString()), DebugTypeEnum.TargetEvaluation);
Logger.MsgDebug(string.Format(" - Evaluated Owners: Found: {0}", owners.ToString()), DebugTypeEnum.TargetEvaluation);
Logger.MsgDebug(string.Format(" - Evaluated Target Owners: {0} / Passed: {1}", owners.ToString(), gotRelation), DebugTypeEnum.TargetEvaluation);
}
//PlayerControlled
if (data.AllUniqueFilters.Contains(TargetFilterEnum.PlayerControlled))
{
var controlled = target.PlayerControlled();
if (data.PrioritizePlayerControlled || controlled)
{
FilterHits.Add(TargetFilterEnum.PlayerControlled);
}
Logger.MsgDebug(string.Format(" - Evaluated Player Controlled: {0}", controlled), DebugTypeEnum.TargetEvaluation);
}
//PlayerKnownLocation
if (data.AllUniqueFilters.Contains(TargetFilterEnum.PlayerKnownLocation))
{
bool inKnownLocation = false;
if (MESApi.MESApiReady)
{
if (MESApi.IsPositionInKnownPlayerLocation(target.GetPosition(), true, string.IsNullOrWhiteSpace(data.PlayerKnownLocationFactionOverride) ? _behavior.Owner.Faction?.Tag : data.PlayerKnownLocationFactionOverride))
{
;
}
FilterHits.Add(TargetFilterEnum.PlayerKnownLocation);
}
Logger.MsgDebug(string.Format(" - Evaluated Player Known Location: {0}", inKnownLocation), DebugTypeEnum.TargetEvaluation);
}
//Powered
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Powered))
{
bool powered = target.IsPowered();
if (powered)
{
FilterHits.Add(TargetFilterEnum.Powered);
}
Logger.MsgDebug(string.Format(" - Evaluated Power: {0}", powered), DebugTypeEnum.TargetEvaluation);
}
//Relation
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Relation))
{
var relations = target.RelationTypes(RemoteControl.OwnerId, data.OnlyGetFromEntityOwner, data.GetFromMinorityGridOwners);
bool gotRelation = false;
var values = Enum.GetValues(typeof(RelationTypeEnum)).Cast <RelationTypeEnum>();
foreach (var relationType in values)
{
if (relationType == RelationTypeEnum.None)
{
continue;
}
if (relations.HasFlag(relationType) && data.Relations.HasFlag(relationType))
{
gotRelation = true;
break;
}
}
if (gotRelation)
{
FilterHits.Add(TargetFilterEnum.Relation);
}
Logger.MsgDebug(string.Format(" - Evaluated Relations: Required: {0}", data.Relations.ToString()), DebugTypeEnum.TargetEvaluation);
Logger.MsgDebug(string.Format(" - Evaluated Relations: Found: {0}", relations.ToString()), DebugTypeEnum.TargetEvaluation);
Logger.MsgDebug(string.Format(" - Evaluated Relations: {0} / Passed: {1}", relations.ToString(), gotRelation), DebugTypeEnum.TargetEvaluation);
}
//Shielded
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Shielded))
{
bool shielded = target.ProtectedByShields();
if (shielded)
{
FilterHits.Add(TargetFilterEnum.Shielded);
}
Logger.MsgDebug(string.Format(" - Evaluated Shields: {0}", shielded), DebugTypeEnum.TargetEvaluation);
}
//Speed
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Speed))
{
var speed = target.CurrentSpeed();
if ((data.MinSpeed < 0 || speed >= data.MinSpeed) && (data.MaxSpeed < 0 || speed <= data.MaxSpeed))
{
FilterHits.Add(TargetFilterEnum.Speed);
}
Logger.MsgDebug(string.Format(" - Evaluated Speed: {0}", speed), DebugTypeEnum.TargetEvaluation);
}
//Static
if (data.IsStatic != CheckEnum.Ignore && data.AllUniqueFilters.Contains(TargetFilterEnum.Static))
{
var staticGrid = target.IsStatic();
if ((staticGrid && data.IsStatic == CheckEnum.Yes) || (!staticGrid && data.IsStatic == CheckEnum.No))
{
FilterHits.Add(TargetFilterEnum.Static);
}
Logger.MsgDebug(string.Format(" - Evaluated Static Grid: {0}", staticGrid), DebugTypeEnum.TargetEvaluation);
}
//TargetValue
if (data.AllUniqueFilters.Contains(TargetFilterEnum.TargetValue))
{
var targetValue = target.TargetValue();
if (targetValue >= data.MinTargetValue && targetValue <= data.MaxTargetValue)
{
FilterHits.Add(TargetFilterEnum.TargetValue);
}
Logger.MsgDebug(string.Format(" - Evaluated Target Value: {0}", targetValue), DebugTypeEnum.TargetEvaluation);
}
//Underwater
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Underwater))
{
bool result = false;
if (WaterHelper.Enabled)
{
result = WaterHelper.UnderwaterAndDepthCheck(target.GetPosition(), _behavior.AutoPilot.CurrentWater, true, Data.MinUnderWaterDepth, Data.MaxUnderWaterDepth);
}
if (result)
{
FilterHits.Add(TargetFilterEnum.Underwater);
}
Logger.MsgDebug(string.Format(" - Evaluated Underwater: {0}", result), DebugTypeEnum.TargetEvaluation);
}
//Any Conditions Check
bool anyConditionPassed = false;
if (data.MatchAnyFilters.Count > 0)
{
foreach (var filter in data.MatchAnyFilters)
{
if (FilterHits.Contains(filter))
{
anyConditionPassed = true;
break;
}
}
}
else
{
anyConditionPassed = true;
}
if (!anyConditionPassed)
{
Logger.MsgDebug(" - Evaluation Condition -Any- Failed", DebugTypeEnum.TargetEvaluation);
return(false);
}
//All Condition Checks
foreach (var filter in data.MatchAllFilters)
{
if (!FilterHits.Contains(filter))
{
Logger.MsgDebug(" - Evaluation Condition -All- Failed", DebugTypeEnum.TargetEvaluation);
return(false);
}
}
//None Condition Checks
foreach (var filter in data.MatchNoneFilters)
{
if (FilterHits.Contains(filter))
{
Logger.MsgDebug(" - Evaluation Condition -None- Failed", DebugTypeEnum.TargetEvaluation);
return(false);
}
}
Logger.MsgDebug(" - Evaluation Passed", DebugTypeEnum.TargetEvaluation);
TargetLastKnownCoords = target.GetPosition();
return(true);
}
public static void ProcessBehaviors()
{
if (DebugDraw)
{
for (int i = Behaviors.Count - 1; i >= 0; i--)
{
if (Behaviors[i] == null)
{
continue;
}
if (!Behaviors[i].IsClosed() && Behaviors[i].IsAIReady())
{
Behaviors[i].DebugDrawWaypoints();
}
}
}
if (WaterHelper.RequiresUpdate)
{
WaterHelper.RefreshWater();
}
if (AiNeedsReset)
{
AiNeedsReset = false;
if (ResetAiBlocks.Count > 0)
{
for (int j = ResetAiBlocks.Count - 1; j >= 0; j--)
{
var behavior = GetBehavior(ResetAiBlocks[j]);
if (behavior == null)
{
continue;
}
behavior.BehaviorTerminated = true;
if (ResetAiBlocks[j].Storage != null && ResetAiBlocks[j].Storage.ContainsKey(new Guid("FF814A67-AEC3-4DF0-ADC4-A9B239FA954F")))
{
ResetAiBlocks[j].Storage[new Guid("FF814A67-AEC3-4DF0-ADC4-A9B239FA954F")] = "";
}
Logger.MsgDebug("AI ModStorageComponent Wiped", DebugTypeEnum.BehaviorSetup);
}
MyAPIGateway.Parallel.Start(() => {
for (int i = ResetAiBlocks.Count - 1; i >= 0; i--)
{
Logger.MsgDebug("Re-Registering AI", DebugTypeEnum.BehaviorSetup);
RegisterBehaviorFromRemoteControl(ResetAiBlocks[i]);
}
ResetAiBlocks.Clear();
});
}
}
_barrageCounter++;
if (Mode != BehaviorManagerMode.None)
{
try {
ProcessParallelMethods();
ProcessMainThreadMethods();
} catch (Exception e) {
Logger.MsgDebug("Exception in Main Behavior Processing", DebugTypeEnum.General);
Logger.MsgDebug(e.ToString(), DebugTypeEnum.General);
}
}
else
{
_behaviorCounter++;
}
if ((_barrageCounter % 10) == 0)
{
ProcessWeaponsBarrage();
_barrageCounter = 0;
}
if (_behaviorCounter == 15)
{
for (int i = Behaviors.Count - 1; i >= 0; i--)
{
if (Behaviors[i] == null || Behaviors[i].IsClosed() || Behaviors[i].BehaviorTerminated)
{
Behaviors.RemoveAt(i);
continue;
}
}
//Logger.MsgDebug("Start Parallel For All Behaviors", DebugTypeEnum.General);
Mode = BehaviorManagerMode.Parallel;
_behaviorCounter = 0;
}
}
private void CalculateAreaAndPath()
{
//Reset Existing Values
_closestNodeToStart = null;
_closestNodeToEnd = null;
_endPath = false;
_goodNodes.Clear();
_badNodes.Clear();
_pathWaypoints.Clear();
_shorelineNodes.Clear();
if (!EnablePathGeneration)
{
_endPath = true;
return;
}
//Create The Grid Of Nodes
var up = _behavior.AutoPilot.UpDirectionFromPlanet;
var forward = Vector3D.CalculatePerpendicularVector(up);
var myPos = _behavior.RemoteControl.GetPosition();
var myMatrix = MatrixD.CreateWorld(myPos, forward, up);
double distanceOffsetHalf = (_worldStepDistance * _steps) / 2;
var startOffset = new Vector3D(-distanceOffsetHalf, 0, -distanceOffsetHalf);
var startGridCoords = Vector3D.Transform(startOffset, myMatrix);
_targetCoords = _behavior.AutoPilot.GetPendingWaypoint();
for (int x = 0; x <= _steps; x++)
{
for (int y = 0; y <= _steps; y++)
{
var gridWorldCellOffset = startOffset;
gridWorldCellOffset.X += (x * _worldStepDistance);
gridWorldCellOffset.Z += (y * _worldStepDistance);
var gridWorldCoords = Vector3D.Transform(gridWorldCellOffset, myMatrix);
double distAboveWater = 0;
var surfaceCoords = WaterHelper.GetClosestSurface(gridWorldCoords, _behavior.AutoPilot.CurrentPlanet, _behavior.AutoPilot.CurrentWater, ref distAboveWater);
if (x == 0 & y == 0)
{
_gridStartCoords = surfaceCoords;
}
if (x == _steps - 1 & y == _steps - 1)
{
_gridEndCoords = surfaceCoords;
}
var node = new PathNode(surfaceCoords, x, y);
if (distAboveWater > -_minimumDepth)
{
_badNodes.Add(node);
continue;
}
_goodNodes.Add(node);
node.DistanceFromStart = Vector3D.Distance(myPos, surfaceCoords);
node.DistanceFromEnd = Vector3D.Distance(surfaceCoords, _targetCoords);
if (_closestNodeToStart == null || node.DistanceFromStart < _closestNodeToStart.DistanceFromStart)
{
_closestNodeToStart = node;
}
if (_closestNodeToEnd == null || node.DistanceFromEnd < _closestNodeToEnd.DistanceFromEnd)
{
_closestNodeToEnd = node;
}
}
}
for (int i = _goodNodes.Count - 1; i >= 0; i--)
{
if (GetNeighbours(_goodNodes[i], true).Count > 0)
{
_shorelineNodes.Add(_goodNodes[i]);
_goodNodes.RemoveAt(i);
}
}
if (_shorelineNodes.Contains(_closestNodeToStart))
{
_closestNodeToStart = null;
foreach (var node in _goodNodes)
{
if (_closestNodeToStart == null || node.DistanceFromStart < _closestNodeToStart.DistanceFromStart)
{
_closestNodeToStart = node;
}
}
}
if (_shorelineNodes.Contains(_closestNodeToEnd))
{
_closestNodeToEnd = null;
foreach (var node in _goodNodes)
{
if (_closestNodeToEnd == null || node.DistanceFromEnd < _closestNodeToEnd.DistanceFromEnd)
{
_closestNodeToEnd = node;
}
}
}
//Logger.MsgDebug("Total Nodes Calculated: " + _goodNodes.Count, DebugTypeEnum.AutoPilot);
//Calculate the Path
_pathWaypoints = new List <Vector3D>(FindPath());
}
