Beispiel #1
0
        private void BlockTest(AeroCell currentData, ref Vector3I currentCell, ref Vector3 targetCellAvg)
        {
            float  gridSize      = m_grid.GridSize;
            double minLineLength = gridSize * 1.4d;

            int tries;

            for (tries = 0; tries < 100; ++tries)
            {
                if (currentData.CurVelocity.AbsMax() < 0.1f)
                {
                    Log.TraceLog("Air is stopped at " + currentCell + ", " + currentData);
                    break;
                }

                // check for blocks between here and target
                Vector3 targetLocalAvg; Vector3.Multiply(ref targetCellAvg, gridSize, out targetLocalAvg);
                LineD   line = new LineD(currentCell * (double)gridSize, targetLocalAvg);
                if (line.Length < minLineLength)
                {
                    line.Length = minLineLength;
                    Vector3D disp; Vector3D.Multiply(ref line.Direction, minLineLength, out disp);
                    Vector3D.Add(ref line.From, ref disp, out line.To);
                }

                MyIntersectionResultLineTriangleEx?result;
                if (m_grid.Intersects(ref line, m_rayCastCells, out result, IntersectionFlags.ALL_TRIANGLES))
                {
                    Vector3 normal = result.Value.NormalInObjectSpace;
                    if (result.Value.Entity != m_grid)
                    {
                        Matrix localMatrix = result.Value.Entity.LocalMatrix.GetOrientation();
                        Vector3.Transform(ref normal, ref localMatrix, out normal);
                    }
                    BlockTest_ApplyNormal(currentData, ref currentCell, ref normal, ref targetCellAvg);
                    continue;
                }
                else
                {
                    Vector3I bestTarget;
                    bestTarget.X = (int)Math.Round(targetCellAvg.X);
                    bestTarget.Y = (int)Math.Round(targetCellAvg.Y);
                    bestTarget.Z = (int)Math.Round(targetCellAvg.Z);
                    if (m_grid.CubeExists(bestTarget))
                    {
                        Vector3 hitNormal;
                        if (BlockTest_Multi(ref line, out hitNormal))
                        {
                            BlockTest_ApplyNormal(currentData, ref currentCell, ref hitNormal, ref targetCellAvg);
                            continue;
                        }
                    }
                    break;
                }
            }
            Log.DebugLog("Too many tries", Logger.severity.WARNING, condition: tries >= 100);
            currentData.BlockTest = true;
        }
Beispiel #2
0
        public Vector3D?GetMemoryTargetPosition(MyBBMemoryTarget targetMemory)
        {
            if (targetMemory == null)
            {
                return(null);
            }
            switch (targetMemory.TargetType)
            {
            case MyAiTargetEnum.CHARACTER:
            case MyAiTargetEnum.ENTITY:
            case MyAiTargetEnum.GRID:
            {
                MyCharacter target = null;
                if (MyEntities.TryGetEntityById(targetMemory.EntityId.Value, out target))
                {
                    return(target.PositionComp.GetPosition());
                }
                else
                {
                    return(null);
                }
            }

            case MyAiTargetEnum.CUBE:
            case MyAiTargetEnum.COMPOUND_BLOCK:
            {
                MyCubeGrid target = null;
                if (MyEntities.TryGetEntityById(targetMemory.EntityId.Value, out target) &&
                    target.CubeExists(targetMemory.BlockPosition))
                {
                    return(target.GridIntegerToWorld(targetMemory.BlockPosition));
                }
                else
                {
                    return(null);
                }
            }

            case MyAiTargetEnum.POSITION:
            case MyAiTargetEnum.VOXEL:
            case MyAiTargetEnum.ENVIRONMENT_ITEM:
                // CH: This seems wrong, but GetGotoPosition does the same weird thing.
                // I should look at this later and fix it if possible...
                return(m_targetPosition);

            case MyAiTargetEnum.NO_TARGET:
            default:
                return(null);
            }
        }
Beispiel #3
0
        public Vector3D?GetMemoryTargetPosition(MyBBMemoryTarget targetMemory)
        {
            if (targetMemory != null)
            {
                switch (targetMemory.TargetType)
                {
                case MyAiTargetEnum.GRID:
                case MyAiTargetEnum.CHARACTER:
                case MyAiTargetEnum.ENTITY:
                {
                    MyCharacter entity = null;
                    if (Sandbox.Game.Entities.MyEntities.TryGetEntityById <MyCharacter>(targetMemory.EntityId.Value, out entity, false))
                    {
                        return(new Vector3D?(entity.PositionComp.GetPosition()));
                    }
                    return(null);
                }

                case MyAiTargetEnum.CUBE:
                case MyAiTargetEnum.COMPOUND_BLOCK:
                {
                    MyCubeGrid entity = null;
                    if (Sandbox.Game.Entities.MyEntities.TryGetEntityById <MyCubeGrid>(targetMemory.EntityId.Value, out entity, false) && entity.CubeExists(targetMemory.BlockPosition))
                    {
                        return(new Vector3D?(entity.GridIntegerToWorld(targetMemory.BlockPosition)));
                    }
                    return(null);
                }

                case MyAiTargetEnum.POSITION:
                case MyAiTargetEnum.ENVIRONMENT_ITEM:
                case MyAiTargetEnum.VOXEL:
                    return(new Vector3D?(this.m_targetPosition));
                }
            }
            return(null);
        }
Beispiel #4
0
        /// <summary>
        /// Сброс лимитов и перезаргрузка с учетом изменившихся аддонов
        /// </summary>
        private void UpdateAddons()
        {
            ShowMessageInGame("dbg", "UpdateAddons start");
            addonschanged = false;
            SetUpDefaultLimits();// слева справа сверху снизу ссади


            if (m_mycubegrid.CubeExists(addonsPositions[3]) &&
                ((m_mycubegrid.GetCubeBlock(addonsPositions[3]) as IMySlimBlock).BlockDefinition.Id.SubtypeId == AllLimits.namelistaddonsreverse[AllLimits.Addons.Сooler]))
            {
                var a = m_mycubegrid.GetCubeBlock(addonsPositions[3]) as IMySlimBlock;

                ShowMessageInGame("dbg", "UpdateAddons ShipCore_Add04"
                                  + (m_mycubegrid.CubeExists(addonsPositions[3]).ToString()
                                     + a.BlockDefinition.Id.SubtypeId.String) + (m_mycubegrid.GetCubeBlock(addonsPositions[3]) as IMySlimBlock).IsFullIntegrity);

                if (MyLimitsSettings.installedAddons.ContainsKey(AllLimits.Addons.Сooler))
                {
                    MyLimitsSettings.installedAddons[AllLimits.Addons.Сooler]++;
                    ShowMessageInGame("dbg", "UpdateAddons installedAddons +1 Сooler" + MyLimitsSettings.installedAddons.Count);
                }

                else
                {
                    MyLimitsSettings.installedAddons.Add(AllLimits.Addons.Сooler, 1);
                }
            }  //снизу .Охладитель


            if (m_mycubegrid.CubeExists(addonsPositions[0]))//слева
            {
                if ((m_mycubegrid.GetCubeBlock(addonsPositions[0]) as IMySlimBlock).IsFullIntegrity)
                {
                    LoadAddon(m_mycubegrid.GetCubeBlock(addonsPositions[0]));
                }
            }
            if (m_mycubegrid.CubeExists(addonsPositions[1]) && (m_mycubegrid.GetCubeBlock(addonsPositions[1]) as IMySlimBlock).IsFullIntegrity)//справа
            {
                LoadAddon(m_mycubegrid.GetCubeBlock(addonsPositions[1]));
            }
            if (m_mycubegrid.CubeExists(addonsPositions[2]) && (m_mycubegrid.GetCubeBlock(addonsPositions[2]) as IMySlimBlock).IsFullIntegrity)//сверху
            {
                LoadAddon(m_mycubegrid.GetCubeBlock(addonsPositions[2]));
            }

            if (m_mycubegrid.CubeExists(addonsPositions[4]) && (m_mycubegrid.GetCubeBlock(addonsPositions[4]) as IMySlimBlock).IsFullIntegrity)//ссади
            {
                LoadAddon(m_mycubegrid.GetCubeBlock(addonsPositions[4]));
            }


            ShowMessageInGame("dbg", "UpdateAddons end");
        }
Beispiel #5
0
        public override void Received(ref RelayMode relay)
        {
            if (Main.IsServer && !Main.IgnoreAmmoConsumption) // ammo consumption, only needed server side
            {
                IMyInventory inv = Utils.GetCharacterInventoryOrError(this, Utils.GetCharacterOrError(this, Utils.GetPlayerOrError(this, OriginalSenderSteamId)));
                if (inv != null)
                {
                    inv.RemoveItemsOfType(1, Main.Constants.PAINT_MAG_ITEM, false);
                }
            }

            MyCubeGrid grid = Utils.GetEntityOrError <MyCubeGrid>(this, GridEntId, Constants.NETWORK_DESYNC_ERROR_LOGGING);

            if (grid == null)
            {
                return;
            }

            if (Main.IsServer)
            {
                // ensure server side if safezone permissions are respected
                if (!Utils.SafeZoneCanPaint(grid.GetCubeBlock(BlockPosition), OriginalSenderSteamId))
                {
                    if (Constants.NETWORK_DESYNC_ERROR_LOGGING)
                    {
                        IMySlimBlock block = (IMySlimBlock)grid.GetCubeBlock(BlockPosition);
                        Log.Error($"{GetType().Name} :: Can't paint inside no-build safe zone! Sender={OriginalSenderSteamId.ToString()}; Grid={grid} ({grid.EntityId.ToString()}); block={block.BlockDefinition.Id.ToString()} ({block.Position.ToString()})", Log.PRINT_MESSAGE);
                    }

                    Main.NetworkLibHandler.PacketWarningMessage.Send(OriginalSenderSteamId, "Failed to paint server side, denied by safe zone.");
                    return;
                }

                long identity = MyAPIGateway.Players.TryGetIdentityId(OriginalSenderSteamId);
                if (!Utils.AllowedToPaintGrid(grid, identity))
                {
                    if (Constants.NETWORK_DESYNC_ERROR_LOGGING)
                    {
                        Log.Error($"{GetType().Name} :: Can't paint non-allied grids! Sender={OriginalSenderSteamId.ToString()}; Grid={grid} ({grid.EntityId.ToString()})", Log.PRINT_MESSAGE);
                    }

                    Main.NetworkLibHandler.PacketWarningMessage.Send(OriginalSenderSteamId, "Failed to paint server side, ship not allied.");
                    return;
                }

                if (!grid.CubeExists(BlockPosition))
                {
                    if (Constants.NETWORK_DESYNC_ERROR_LOGGING)
                    {
                        Log.Error($"{GetType().Name} :: Can't paint inexistent blocks! Sender={OriginalSenderSteamId.ToString()}; Grid={grid} ({grid.EntityId.ToString()}) at GridPosition={BlockPosition.ToString()}", Log.PRINT_MESSAGE);
                    }

                    Main.NetworkLibHandler.PacketWarningMessage.Send(OriginalSenderSteamId, "Failed to paint server side, block no longer exists.");
                    return;
                }
            }

            if (DoAction(grid))
            {
                relay = RelayMode.RelayWithChanges;
            }
        }