public void FaceDataYNegative(CubeBlock block, Vector3 pos, bool dropItem = false) { float half_block_size = block.blockSize / 2.0f; this.AddVertex(new Vector3(pos.x - half_block_size, pos.y - half_block_size, pos.z - half_block_size)); this.AddVertex(new Vector3(pos.x + half_block_size, pos.y - half_block_size, pos.z - half_block_size)); this.AddVertex(new Vector3(pos.x + half_block_size, pos.y - half_block_size, pos.z + half_block_size)); this.AddVertex(new Vector3(pos.x - half_block_size, pos.y - half_block_size, pos.z + half_block_size)); // add normals Vector3 down = Vector3.down; this.normals.Add(down); this.normals.Add(down); this.normals.Add(down); this.normals.Add(down); // add triangles this.AddQuadTriangles(); // add textures BlockTile blockTile = dropItem ? block.getDropBlockTile() : block.getBlockTile(); Vector2 _00 = blockTile.bottom_00; Vector2 _10 = blockTile.bottom_10; Vector2 _01 = blockTile.bottom_01; Vector2 _11 = blockTile.bottom_11; this.uvs.Add(_11); this.uvs.Add(_01); this.uvs.Add(_00); this.uvs.Add(_10); }
private void LockAndShoot() { if (m_onCooldown || m_onGameCooldown) { Log.TraceLog("on cooldown"); return; } if (!_shootCluster) { InitialTargetStatus initial = GetInitialTarget(); if (initial != _initial || _initialTarget != m_weaponTarget.CurrentTarget) { Log.TraceLog("Updating custom info"); _initial = initial; _initialTarget = m_weaponTarget.CurrentTarget; CubeBlock.UpdateCustomInfo(); } if (m_weaponTarget.CurrentTarget is NoTarget && !m_weaponTarget.FireWithoutLock) { Log.TraceLog("Cannot fire, no target found", Logger.severity.TRACE); return; } } Log.TraceLog("Shooting from terminal"); _isShooting = true; ((MyUserControllableGun)CubeBlock).ShootFromTerminal(m_weaponTarget.Facing()); Log.TraceLog("Back from shoot"); }
public GuidedMissileLauncher(WeaponTargeting weapon) { m_weaponTarget = weapon; m_relayPart = RelayClient.GetOrCreateRelayPart(m_weaponTarget.CubeBlock); this._initialTarget = NoTarget.Instance; MyWeaponBlockDefinition defn = (MyWeaponBlockDefinition)CubeBlock.GetCubeBlockDefinition(); Vector3[] points = new Vector3[3]; Vector3 forwardAdjust = Vector3.Forward * WeaponDescription.GetFor(CubeBlock).MissileSpawnForward; points[0] = CubeBlock.LocalAABB.Min + forwardAdjust; points[1] = CubeBlock.LocalAABB.Max + forwardAdjust; points[2] = CubeBlock.LocalAABB.Min + Vector3.Up * defn.Size.Y * CubeBlock.CubeGrid.GridSize + forwardAdjust; MissileSpawnBox = BoundingBox.CreateFromPoints(points); if (m_weaponTarget.myTurret != null) { Log.TraceLog("original box: " + MissileSpawnBox); MissileSpawnBox.Inflate(CubeBlock.CubeGrid.GridSize * 2f); } Log.TraceLog("MissileSpawnBox: " + MissileSpawnBox); myInventory = ((MyEntity)CubeBlock).GetInventoryBase(0); Registrar.Add(weapon.CubeBlock, this); m_weaponTarget.GuidedLauncher = true; m_gameCooldownTime = TimeSpan.FromSeconds(60d / MyDefinitionManager.Static.GetWeaponDefinition(defn.WeaponDefinitionId).WeaponAmmoDatas[(int)MyAmmoType.Missile].RateOfFire); Log.TraceLog("m_gameCooldownTime: " + m_gameCooldownTime); CubeBlock.AppendingCustomInfo += CubeBlock_AppendingCustomInfo; }
public void FaceDataZPositive(CubeBlock block, Vector3 pos, bool dropItem = false) { float half_block_size = block.blockSize / 2.0f; this.AddVertex(new Vector3(pos.x - half_block_size, pos.y - half_block_size, pos.z - half_block_size)); this.AddVertex(new Vector3(pos.x - half_block_size, pos.y + half_block_size, pos.z - half_block_size)); this.AddVertex(new Vector3(pos.x + half_block_size, pos.y + half_block_size, pos.z - half_block_size)); this.AddVertex(new Vector3(pos.x + half_block_size, pos.y - half_block_size, pos.z - half_block_size)); // add normals Vector3 front = Vector3.forward; this.normals.Add(front); this.normals.Add(front); this.normals.Add(front); this.normals.Add(front); // add triangles this.AddQuadTriangles(); // add textures BlockTile blockTile = dropItem ? block.getDropBlockTile() : block.getBlockTile(); Vector2 _00 = blockTile.front_00; Vector2 _10 = blockTile.front_10; Vector2 _01 = blockTile.front_01; Vector2 _11 = blockTile.front_11; this.uvs.Add(_10); this.uvs.Add(_11); this.uvs.Add(_01); this.uvs.Add(_00); }
public void FaceDataYNegative(CubeBlock block, Vector3 pos, bool dropItem = false){ float half_block_size = block.blockSize / 2.0f; this.AddVertex(new Vector3(pos.x - half_block_size, pos.y - half_block_size, pos.z - half_block_size)); this.AddVertex(new Vector3(pos.x + half_block_size, pos.y - half_block_size, pos.z - half_block_size)); this.AddVertex(new Vector3(pos.x + half_block_size, pos.y - half_block_size, pos.z + half_block_size)); this.AddVertex(new Vector3(pos.x - half_block_size, pos.y - half_block_size, pos.z + half_block_size)); // add normals Vector3 down = Vector3.down; this.normals.Add (down); this.normals.Add (down); this.normals.Add (down); this.normals.Add (down); // add triangles this.AddQuadTriangles(); // add textures BlockTile blockTile = dropItem ? block.getDropBlockTile() : block.getBlockTile(); Vector2 _00 = blockTile.bottom_00; Vector2 _10 = blockTile.bottom_10; Vector2 _01 = blockTile.bottom_01; Vector2 _11 = blockTile.bottom_11; this.uvs.Add (_11); this.uvs.Add (_01); this.uvs.Add (_00); this.uvs.Add (_10); }
private static void BuildFace(CubeFace face, CubeBlock cube, BlockDirection direction, Vector3 localPos, MeshBuilder mesh) { int iFace = (int)face; mesh.AddFaceIndices(cube.GetAtlasID()); mesh.AddVertices(vertices[iFace], localPos); mesh.AddNormals(normals[iFace]); mesh.AddTexCoords(cube.GetFaceUV(face, direction)); }
/// <summary> /// Called before update loop begins /// </summary> public virtual void Start() { WeaponDefinition = CubeBlock.BlockDefinition.Id; State = new NetSync <WeaponState>(ControlLayer, TransferType.Both, WeaponState.None); State.ValueChanged += StateChanged; Reloading = new NetSync <bool>(ControlLayer, TransferType.ServerToClient, false); DeviationIndex = new NetSync <sbyte>(ControlLayer, TransferType.ServerToClient, (sbyte)MyRandom.Instance.Next(0, sbyte.MaxValue)); InventoryComponent.GetOrAddComponent(CubeBlock.CubeGrid); Inventory = CubeBlock.GetInventory(); }
public void Set(CubeBlock block) { workObject = block; workObject.SetWorksite(this); GameMaster.colonyController.SendWorkers(START_WORKERS_COUNT, this); if (!worksitesList.Contains(this)) { worksitesList.Add(this); } if (!subscribedToUpdate) { GameMaster.realMaster.labourUpdateEvent += WorkUpdate; subscribedToUpdate = true; } }
public static MeshBuilder Build(CubeBlock cube) { MeshBuilder mesh = new MeshBuilder(); for (int i = 0; i < vertices.Length; i++) { mesh.AddFaceIndices(0); mesh.AddVertices(vertices[i], Vector3.zero); mesh.AddNormals(normals[i]); Vector2[] texCoords = cube.GetFaceUV((CubeFace)i, BlockDirection.Z_PLUS); mesh.AddTexCoords(texCoords); //mesh.AddFaceColor( new Color(0,0,0,1) ); } return(mesh); }
public void Set(CubeBlock block, bool work_is_dig) { workObject = block; workObject.SetWorksite(this); dig = work_is_dig; if (dig) { Block b = GameMaster.mainChunk.GetBlock(block.pos.x, block.pos.y + 1, block.pos.z); if (b != null && (b.type == BlockType.Surface & b.worksite == null)) { CleanSite cs = b.gameObject.AddComponent <CleanSite>(); TransferWorkers(this, cs); cs.Set(b as SurfaceBlock, true); if (showOnGUI) { cs.ShowOnGUI(); showOnGUI = false; } StopWork(); return; } sign = Instantiate(Resources.Load <GameObject> ("Prefs/DigSign")).GetComponent <WorksiteSign>(); } else { sign = Instantiate(Resources.Load <GameObject>("Prefs/PourInSign")).GetComponent <WorksiteSign>(); } sign.worksite = this; sign.transform.position = workObject.transform.position + Vector3.up * Block.QUAD_SIZE; //FollowingCamera.main.cameraChangedEvent += SignCameraUpdate; mainResource = ResourceType.GetResourceTypeById(workObject.material_id); if (workersCount < START_WORKERS_COUNT) { GameMaster.colonyController.SendWorkers(START_WORKERS_COUNT, this); } if (!worksitesList.Contains(this)) { worksitesList.Add(this); } if (!subscribedToUpdate) { GameMaster.realMaster.labourUpdateEvent += WorkUpdate; subscribedToUpdate = true; } }
override public void SetBasement(SurfaceBlock b, PixelPosByte pos) { if (b == null) { return; } SetBuildingData(b, pos); if (!subscribedToUpdate) { GameMaster.realMaster.labourUpdateEvent += LabourUpdate; subscribedToUpdate = true; } Block bb = basement.myChunk.GetBlock(basement.pos.x, basement.pos.y - 1, basement.pos.z); workObject = bb as CubeBlock; lastWorkObjectPos = bb.pos; }
public void UpdateAfterSimulation100() { try { if (!myLaserAntenna.IsWorking) { return; } //Showoff.doShowoff(CubeBlock, myLastSeen.Values.GetEnumerator(), myLastSeen.Count); // stage 5 is the final stage. It is possible for one to be in stage 5, while the other is not MyObjectBuilder_LaserAntenna builder = CubeBlock.getSlim().GetObjectBuilder() as MyObjectBuilder_LaserAntenna; if (builder.targetEntityId != null) { foreach (LaserAntenna lAnt in value_registry) { if (lAnt.CubeBlock.EntityId == builder.targetEntityId) { if (builder.State == 5 && (lAnt.CubeBlock.getSlim().GetObjectBuilder() as MyObjectBuilder_LaserAntenna).State == 5) { //log("Laser " + CubeBlock.gridBlockName() + " connected to " + lAnt.CubeBlock.gridBlockName(), "UpdateAfterSimulation100()", Logger.severity.DEBUG); foreach (LastSeen seen in myLastSeen.Values) { lAnt.receive(seen); } foreach (Message mes in myMessages) { lAnt.receive(mes); } break; } } } } // send to attached receivers Receiver.sendToAttached(CubeBlock, myLastSeen); Receiver.sendToAttached(CubeBlock, myMessages); UpdateEnemyNear(); } catch (Exception e) { myLogger.log("Exception: " + e, "UpdateAfterSimulation100()", Logger.severity.ERROR); } }
public void AddCube() { if (cubes.Count == maxHeight) { return; } CubeBlock newCubeBlock = Instantiate(cubeBlockPrefab) as CubeBlock; newCubeBlock.transform.parent = this.transform; newCubeBlock.transform.localRotation = Quaternion.identity; if (cubes.Count == 0) { newCubeBlock.transform.localPosition = new Vector3(0f, .55f, 0f); } else { newCubeBlock.transform.localPosition = cubes.Last.Value.transform.localPosition + new Vector3(0f, cubeLength, 0f); cubes.Last.Value.UnhighlightCube(); } cubes.AddLast(newCubeBlock); cubes.Last.Value.HighlightCube(); }
override public void StopWork() { if (destroyed) { return; } else { destroyed = true; } if (workersCount > 0) { GameMaster.colonyController.AddWorkers(workersCount); workersCount = 0; } if (sign != null) { Destroy(sign.gameObject); } if (worksitesList.Contains(this)) { worksitesList.Remove(this); } if (subscribedToUpdate) { GameMaster.realMaster.labourUpdateEvent -= WorkUpdate; subscribedToUpdate = false; } if (workObject != null) { if (workObject.worksite == this) { workObject.ResetWorksite(); } workObject = null; } if (showOnGUI) { observer.SelfShutOff(); showOnGUI = false; } Destroy(this); }
public void generate3DMeshFromCubeBlock(CubeBlock block) { meshData = new MeshData (); block.generateMesh (meshData, Vector3.zero, null, false, true); MeshFilter filter = GetComponent<MeshFilter> (); // transform.gameObject.AddComponent< MeshFilter >() as MeshFilter; Mesh mesh = filter.mesh; mesh.Clear(); mesh.vertices = meshData.vertices.ToArray(); mesh.triangles = meshData.triangles.ToArray(); // mesh.normals = meshData.normals.ToArray (); mesh.uv = meshData.uvs.ToArray(); mesh.RecalculateBounds(); mesh.Optimize(); Material material = GetComponent<Renderer>().material as Material; material.mainTexture = GameObject.Find ("Chunk").GetComponent<Renderer> ().material.mainTexture; }
public static void Build(Vector3i localPos, Vector3i worldPos, Map map, MeshBuilder mesh, bool onlyLight) { BlockData block = map.GetBlock(worldPos); CubeBlock cube = (CubeBlock)block.block; BlockDirection direction = block.GetDirection(); for (int i = 0; i < 6; i++) { CubeFace face = faces[i]; Vector3i dir = directions[i]; Vector3i nearPos = worldPos + dir; if (IsFaceVisible(map, nearPos)) { if (!onlyLight) { BuildFace(face, cube, direction, localPos, mesh); } BuildFaceLight(face, map, worldPos, mesh); } } }
protected void UpdateEnemyNear() { Vector3D myPosition = CubeBlock.GetPosition(); EnemyNear = false; foreach (LastSeen seen in myLastSeen.Values) { IMyCubeGrid seenAsGrid = seen.Entity as IMyCubeGrid; if (seenAsGrid != null) { //myLogger.debugLog("testing grid: " + seenAsGrid.DisplayName + ", recent = " + seen.isRecent() + ", hostile = " + CubeBlock.canConsiderHostile(seenAsGrid) + ", distance squared = " + (seen.LastKnownPosition - myPosition).LengthSquared(), "UpdateEnemyNear()"); if (seen.isRecent() && CubeBlock.canConsiderHostile(seenAsGrid) && (seen.LastKnownPosition - myPosition).LengthSquared() < 9000000) // 3km, squared = 9Mm { //myLogger.debugLog("nearby enemy: " + seen.Entity.getBestName(), "UpdateEnemyNear()"); EnemyNear = true; return; } } } //myLogger.debugLog("no enemy nearby", "UpdateEnemyNear()"); }
public void generate3DMeshFromCubeBlock(CubeBlock block) { meshData = new MeshData(); block.generateMesh(meshData, Vector3.zero, null, false, true); MeshFilter filter = GetComponent <MeshFilter> (); // transform.gameObject.AddComponent< MeshFilter >() as MeshFilter; Mesh mesh = filter.mesh; mesh.Clear(); mesh.vertices = meshData.vertices.ToArray(); mesh.triangles = meshData.triangles.ToArray(); // mesh.normals = meshData.normals.ToArray (); mesh.uv = meshData.uvs.ToArray(); mesh.RecalculateBounds(); mesh.Optimize(); Material material = GetComponent <Renderer>().material as Material; material.mainTexture = GameObject.Find("Chunk").GetComponent <Renderer> ().material.mainTexture; }
public Turret(IMyCubeBlock block) : base(block) { // definition limits MyLargeTurretBaseDefinition definition = CubeBlock.GetCubeBlockDefinition() as MyLargeTurretBaseDefinition; if (definition == null) { throw new NullReferenceException("definition"); } minElevation = Math.Max(MathHelper.ToRadians(definition.MinElevationDegrees), -0.6f); maxElevation = MathHelper.ToRadians(definition.MaxElevationDegrees); minAzimuth = MathHelper.ToRadians(definition.MinAzimuthDegrees); maxAzimuth = MathHelper.ToRadians(definition.MaxAzimuthDegrees); Can360 = Math.Abs(definition.MaxAzimuthDegrees - definition.MinAzimuthDegrees) >= 360; // speeds are in rads per ms (from S.E. source) speedElevation = definition.ElevationSpeed * 100f / 6f; speedAzimuth = definition.RotationSpeed * 100f / 6f; setElevation = myTurret.Elevation; setAzimuth = myTurret.Azimuth; // subparts for turrets form a chain var subparts = ((MyCubeBlock)CubeBlock).Subparts; while (subparts.Count != 0) { m_barrel = subparts.FirstPair().Value; subparts = m_barrel.Subparts; } //Log.DebugLog("definition limits = " + definition.MinElevationDegrees + ", " + definition.MaxElevationDegrees + ", " + definition.MinAzimuthDegrees + ", " + definition.MaxAzimuthDegrees, "Turret()"); //Log.DebugLog("radian limits = " + minElevation + ", " + maxElevation + ", " + minAzimuth + ", " + maxAzimuth, "Turret()"); }
override public void LevelUp(bool returnToUI) { Block b = basement.myChunk.GetBlock(lastWorkObjectPos.x, lastWorkObjectPos.y - 1, lastWorkObjectPos.z); if (b != null && b.type == BlockType.Cube) { if (!GameMaster.realMaster.weNeedNoResources) { ResourceContainer[] cost = GetUpgradeCost(); if (cost != null && cost.Length != 0) { if (!GameMaster.colonyController.storage.CheckBuildPossibilityAndCollectIfPossible(cost)) { UIController.current.MakeAnnouncement(Localization.GetAnnouncementString(GameAnnouncements.NotEnoughResources)); return; } } } workObject = b as CubeBlock; lastWorkObjectPos = b.pos; workFinished = false; UpgradeMine((byte)(level + 1)); } }
/// <summary> /// Updates m_stage if guidance starts or stops. /// </summary> private void CheckGuidance() { switch (m_stage) { case Stage.Rail: double minDist = (MyEntity.WorldAABB.Max - MyEntity.WorldAABB.Min).AbsMax(); minDist *= 2; if (CubeBlock.WorldAABB.DistanceSquared(MyEntity.GetPosition()) >= minDist * minDist) { myGuidanceEnds = Globals.ElapsedTime.Add(TimeSpan.FromSeconds(myDescr.GuidanceSeconds)); m_rail = null; if (myDescr.SemiActiveLaser) { Log.DebugLog("past arming range, semi-active.", Logger.severity.INFO); m_stage = Stage.SemiActive; return; } if (CurrentTarget is GolisTarget) { Log.DebugLog("past arming range, golis active", Logger.severity.INFO); m_stage = Stage.Golis; return; } if (myAmmo.Description.BoostDistance > 1f) { Log.DebugLog("past arming range, starting boost stage", Logger.severity.INFO); StartGravity(); m_stage = Stage.Boost; if (m_gravData == null) { Log.DebugLog("no gravity, terminating", Logger.severity.WARNING); m_stage = Stage.Terminated; } } else { Log.DebugLog("past arming range, starting guidance.", Logger.severity.INFO); m_stage = Stage.Guided; } } return; case Stage.Boost: if (Vector3D.DistanceSquared(CubeBlock.GetPosition(), MyEntity.GetPosition()) >= myAmmo.Description.BoostDistance * myAmmo.Description.BoostDistance) { Log.DebugLog("completed boost stage, starting mid course stage", Logger.severity.INFO); m_stage = Stage.MidCourse; } return; case Stage.MidCourse: Target t = CurrentTarget; if (t.Entity == null) { return; } double toTarget = Vector3D.Distance(MyEntity.GetPosition(), t.GetPosition()); double toLaunch = Vector3D.Distance(MyEntity.GetPosition(), CubeBlock.GetPosition()); if (toTarget < toLaunch) { Log.DebugLog("closer to target(" + toTarget + ") than to launch(" + toLaunch + "), starting guidance", Logger.severity.INFO); m_stage = Stage.Guided; myGuidanceEnds = Globals.ElapsedTime.Add(TimeSpan.FromSeconds(myDescr.GuidanceSeconds)); m_gravData = null; } return; case Stage.SemiActive: case Stage.Golis: case Stage.Guided: if (Globals.ElapsedTime >= myGuidanceEnds) { Log.DebugLog("finished guidance", Logger.severity.INFO); m_stage = Stage.Ballistic; } return; } }
private void Update_OnThread() { try { m_nearbyEntities.Clear(); m_nearbyRange = 0f; myLastSeen.Clear(); detectedObjects_list.Clear(); if (detectedObjects_hash != null) { detectedObjects_hash.Clear(); } if (!IsWorking) { if (PowerLevel_Current > 0) { PowerLevel_Current += myDefinition.PowerDecrease; } ClearJamming(); return; } UpdatePowerLevel(); if (IsJammer) { JamRadar(); } if (IsRadar) { ActiveDetection(); } if (myDefinition.PassiveDetect_Jamming > 0) { PassiveDetection(false); } if (myDefinition.PassiveDetect_Radar > 0) { PassiveDetection(true); } if (detectedObjects_list.Count > 0) { detectedObjects_list.Sort(); int transmit = Math.Min(detectedObjects_list.Count, myDefinition.MaxTargets_Tracking); for (int i = 0; i < transmit; i++) { DetectedInfo detFo = detectedObjects_list[i]; myLastSeen.Add(new LastSeen(detFo.Entity, detFo.Times, detFo.Info)); //Log.DebugLog("created last seen for: " + detFo.Entity.getBestName()); } //Log.DebugLog("sending to storage: " + myLastSeen.Count); m_node.Storage.Receive(myLastSeen); } } catch (Exception ex) { Log.AlwaysLog("Exception: " + ex, Logger.severity.ERROR); CubeBlock.EnableGameThread(false); } finally { myLock.ReleaseExclusive(); } }
void Load() { Dictionary <int, BlockData> blockData = new Dictionary <int, BlockData>(); using (TextReader reader = AssetUtils.LoadText(Application.streamingAssetsPath + Path.DirectorySeparatorChar + blocksDataFile)) { reader.ReadLine(); string line; while ((line = reader.ReadLine()) != null) { BlockData data = new BlockData(line); blockData[data.Index] = data; } } Dictionary <string, System.Type> definedBlocks = new Dictionary <string, System.Type>(); foreach (System.Type t in System.Reflection.Assembly.GetAssembly(typeof(Block)).GetTypes()) { if (t.IsSubclassOf(typeof(Block))) { definedBlocks.Add(t.Name, t); } } List <Block> b = new List <Block>(); int i = 0; int count = blockData.Count; while (i < count) { if (blockData.ContainsKey(i)) { Block block = (Block)System.Activator.CreateInstance(definedBlocks[blockData[i].BlockType]); InitializeBlock(block, blockData[i]); b.Add(block); i++; } else { Block block = new CubeBlock(); InitializeBlock(block, blockData[0]); b.Add(block); } } Blocks = b.ToArray(); StandardCubeBlocks = new IStandardCubeBlock[Blocks.Length]; NormalBlocks = new INormalBlock[Blocks.Length]; IsTransparent = new bool[Blocks.Length]; for (int k = 0; k < Blocks.Length; k++) { var standard = Blocks[k] as IStandardCubeBlock; var normal = Blocks[k] as INormalBlock; if (standard == null && normal == null) { Debug.LogErrorFormat("block {0} does not define GenerateTerrain", Blocks[k].GetType().Name); } StandardCubeBlocks[k] = standard; NormalBlocks[k] = normal; IsTransparent[k] = standard == null; } }
public void CalculateOutput(float production, CubeBlock workObject, Storage storage) { if (workObject == null) { return; } if (workObject.naturalFossils > 0) { float v = Random.value - GameMaster.LUCK_COEFFICIENT; float m = 0; switch (workObject.material_id) { case ResourceType.STONE_ID: if (metalK_abundance >= v) { m = metalK_abundance * production * (Random.value + 1 + GameMaster.LUCK_COEFFICIENT); storage.AddResource(ResourceType.metal_K_ore, m); production -= m; } if (metalM_abundance >= v) { m = metalM_abundance * production * (Random.value + 1 + GameMaster.LUCK_COEFFICIENT); storage.AddResource(ResourceType.metal_M_ore, m); production -= m; } if (metalE_abundance >= v) { m = metalE_abundance * production * (Random.value + 1 + GameMaster.LUCK_COEFFICIENT); storage.AddResource(ResourceType.metal_E_ore, m); production -= m; } if (metalN_abundance >= v) { m = metalN_abundance * production * (Random.value + 1 + GameMaster.LUCK_COEFFICIENT); storage.AddResource(ResourceType.metal_N_ore, m); production -= m; } if (metalP_abundance >= v) { m = metalP_abundance * production * (Random.value + 1 + GameMaster.LUCK_COEFFICIENT); storage.AddResource(ResourceType.metal_P_ore, m); production -= m; } if (metalS_abundance >= v) { m = metalS_abundance * production * (Random.value + 1 + GameMaster.LUCK_COEFFICIENT); storage.AddResource(ResourceType.metal_S_ore, m); production -= m; } if (mineralF_abundance >= v) { m = mineralF_abundance * production * (Random.value + 1 + GameMaster.LUCK_COEFFICIENT); storage.AddResource(ResourceType.mineral_F, m); production -= m; } if (mineralL_abundance >= v) { m = mineralL_abundance * production * (Random.value + 1 + GameMaster.LUCK_COEFFICIENT); storage.AddResource(ResourceType.mineral_L, m); production -= m; } if (production > 0) { GameMaster.colonyController.storage.AddResource(ResourceType.Stone, production); } break; case ResourceType.DIRT_ID: if (metalK_abundance >= v) { m = metalK_abundance / 2f * production * (Random.value + 1 + GameMaster.LUCK_COEFFICIENT); GameMaster.colonyController.storage.AddResource(ResourceType.metal_K_ore, m); production -= m; } if (metalP_abundance >= v) { m = metalP_abundance / 2f * production * (Random.value + 1 + GameMaster.LUCK_COEFFICIENT); GameMaster.colonyController.storage.AddResource(ResourceType.metal_P, m); production -= m; } if (mineralL_abundance >= v) { m = mineralL_abundance / 2f * production * (Random.value + 1 + GameMaster.LUCK_COEFFICIENT); GameMaster.colonyController.storage.AddResource(ResourceType.mineral_L, m); production -= m; } if (production > 0) { GameMaster.colonyController.storage.AddResource(ResourceType.Dirt, production); } break; default: GameMaster.colonyController.storage.AddResource(ResourceType.GetResourceTypeById(workObject.material_id), production); break; } workObject.naturalFossils -= production; } else // no fossils { GameMaster.colonyController.storage.AddResource(ResourceType.GetResourceTypeById(workObject.material_id), production); } }
public void ChangeChosenObject(ChosenObjectType newChosenType) { if (hospitalPanel.activeSelf) { DeactivateHospitalPanel(); } else { if (expeditionCorpusPanel.activeSelf) { DeactivateExpeditionCorpusPanel(); } else { if (rollingShopPanel.activeSelf) { DeactivateRollingShopPanel(); } } } //отключение предыдущего observer if (workingObserver != null) { workingObserver.ShutOff(); workingObserver = null; } bool disableCubeMenuButtons = true, changeFrameColor = true; if (newChosenType == ChosenObjectType.None) { rightPanel.SetActive(false); selectionFrame.gameObject.SetActive(false); chosenObjectType = ChosenObjectType.None; chosenWorksite = null; chosenStructure = null; chosenCube = null; chosenSurface = null; faceIndex = 10; changeFrameColor = false; } else { chosenObjectType = newChosenType; rightPanel.transform.SetAsLastSibling(); rightPanel.SetActive(true); disableCubeMenuButtons = true; selectionFrame.gameObject.SetActive(true); if (showMenuWindow) { MenuButton(); } } Vector3 sframeColor = Vector3.one; switch (chosenObjectType) { case ChosenObjectType.Surface: { faceIndex = 10; // вспомогательная дата для chosenCube selectionFrame.position = chosenSurface.transform.position + Vector3.down * Block.QUAD_SIZE / 2f; selectionFrame.rotation = Quaternion.identity; selectionFrame.localScale = new Vector3(SurfaceBlock.INNER_RESOLUTION, 1, SurfaceBlock.INNER_RESOLUTION); sframeColor = new Vector3(140f / 255f, 1, 1); workingObserver = chosenSurface.ShowOnGUI(); FollowingCamera.main.SetLookPoint(chosenSurface.transform.position); } break; case ChosenObjectType.Cube: { selectionFrame.position = chosenCube.faces[faceIndex].transform.position; switch (faceIndex) { case 0: selectionFrame.transform.rotation = Quaternion.Euler(90, 0, 0); break; case 1: selectionFrame.transform.rotation = Quaternion.Euler(0, 0, -90); break; case 2: selectionFrame.transform.rotation = Quaternion.Euler(-90, 0, 0); break; case 3: selectionFrame.transform.rotation = Quaternion.Euler(0, 0, 90); break; case 4: selectionFrame.transform.rotation = Quaternion.identity; break; case 5: selectionFrame.transform.rotation = Quaternion.Euler(-180, 0, 0); break; } selectionFrame.localScale = new Vector3(SurfaceBlock.INNER_RESOLUTION, 1, SurfaceBlock.INNER_RESOLUTION); sframeColor = new Vector3(140f / 255f, 1, 0.9f); FollowingCamera.main.SetLookPoint(chosenCube.transform.position); Transform t = rightPanel.transform; t.GetChild(RPANEL_CUBE_DIG_BUTTON_INDEX).gameObject.SetActive(true); if (chosenCube.excavatingStatus != 0) { t.GetChild(RPANEL_CUBE_DIG_BUTTON_INDEX + 1).gameObject.SetActive(true); } else { t.GetChild(RPANEL_CUBE_DIG_BUTTON_INDEX + 1).gameObject.SetActive(false); } disableCubeMenuButtons = false; } break; case ChosenObjectType.Structure: faceIndex = 10; // вспомогательная дата для chosenCube selectionFrame.position = chosenStructure.transform.position; selectionFrame.rotation = chosenStructure.transform.rotation; selectionFrame.localScale = new Vector3(chosenStructure.innerPosition.size, 1, chosenStructure.innerPosition.size); sframeColor = new Vector3(1, 0, 1); workingObserver = chosenStructure.ShowOnGUI(); FollowingCamera.main.SetLookPoint(chosenStructure.transform.position); break; case ChosenObjectType.Worksite: faceIndex = 10; // вспомогательная дата для chosenCube selectionFrame.gameObject.SetActive(false); changeFrameColor = false; workingObserver = chosenWorksite.ShowOnGUI(); FollowingCamera.main.SetLookPoint(chosenWorksite.sign.transform.position); break; } if (disableCubeMenuButtons) { Transform t = rightPanel.transform; t.GetChild(RPANEL_CUBE_DIG_BUTTON_INDEX).gameObject.SetActive(false); t.GetChild(RPANEL_CUBE_DIG_BUTTON_INDEX + 1).gameObject.SetActive(false); } if (changeFrameColor) { selectionFrameMaterial.SetColor("_TintColor", Color.HSVToRGB(sframeColor.x, sframeColor.y, sframeColor.z)); selectionFrame.gameObject.SetActive(true); } }
public void Raycasting() { if (GameMaster.colonyController == null || GameMaster.colonyController.hq == null) { return; } // кастует луч, проверяет, выделен ли уже этот объект, если нет - меняет режим через ChabgeChosenObject Vector2 mpos = Input.mousePosition; RaycastHit rh; if (Physics.Raycast(FollowingCamera.cam.ScreenPointToRay(Input.mousePosition), out rh)) { GameObject collided = rh.collider.gameObject; switch (collided.tag) { case "Structure": { Structure s = collided.transform.parent.GetComponent <Structure>(); if (s == null) { ChangeChosenObject(ChosenObjectType.None); } else { if (chosenStructure == s) { return; } else { chosenStructure = s; chosenSurface = s.basement; chosenCube = null; chosenWorksite = null; ChangeChosenObject(ChosenObjectType.Structure); } } break; } case "BlockCollider": { Block b = collided.transform.parent.GetComponent <Block>(); if (b == null) { b = collided.transform.parent.parent.GetComponent <Block>(); // cave block } if (b == null) { ChangeChosenObject(ChosenObjectType.None); } switch (b.type) { case BlockType.Cave: case BlockType.Surface: SurfaceBlock sb = b as SurfaceBlock; if (sb == chosenSurface) { return; } else { chosenSurface = sb; chosenStructure = null; chosenCube = null; chosenWorksite = sb.worksite; ChangeChosenObject(ChosenObjectType.Surface); } break; case BlockType.Cube: CubeBlock cb = b as CubeBlock; if (cb == chosenCube) { return; } else { chosenCube = cb; chosenSurface = null; chosenStructure = null; chosenWorksite = cb.worksite; faceIndex = 10; for (byte i = 0; i < 6; i++) { if (chosenCube.faces[i] == null) { continue; } if (chosenCube.faces[i].GetComponent <Collider>() == rh.collider) { faceIndex = i; break; } } if (faceIndex < 6) { ChangeChosenObject(ChosenObjectType.Cube); } else { ChangeChosenObject(ChosenObjectType.None); } } break; } } break; case "WorksiteSign": { WorksiteSign ws = collided.GetComponent <WorksiteSign>(); if (ws != null) { if (ws.worksite == chosenWorksite) { return; } else { chosenCube = null; chosenSurface = null; chosenStructure = null; chosenWorksite = ws.worksite; ChangeChosenObject(ChosenObjectType.Worksite); } } else { ChangeChosenObject(ChosenObjectType.None); } } break; default: if (collided.transform.parent != null) { if (collided.transform.parent.gameObject.GetInstanceID() == interceptingConstructPlaneID) { UISurfacePanelController.current.ConstructingPlaneTouch(rh.point); } } break; } } else { SelectedObjectLost(); } }
public void UpdateAfterSimulation100() { try { if (!myRadioAntenna.IsWorking) { return; } //Showoff.doShowoff(CubeBlock, myLastSeen.Values.GetEnumerator(), myLastSeen.Count); float radiusSquared; MyObjectBuilder_RadioAntenna antBuilder = CubeBlock.GetObjectBuilderCubeBlock() as MyObjectBuilder_RadioAntenna; if (!antBuilder.EnableBroadcasting) { radiusSquared = 0; } else { radiusSquared = myRadioAntenna.Radius * myRadioAntenna.Radius; } // send antenna self to radio antennae LinkedList <RadioAntenna> canSeeMe = new LinkedList <RadioAntenna>(); // friend and foe alike foreach (RadioAntenna ant in RadioAntenna.registry) { if (CubeBlock.canSendTo(ant.CubeBlock, false, radiusSquared, true)) { canSeeMe.AddLast(ant); } } LastSeen self = new LastSeen(CubeBlock.CubeGrid); foreach (RadioAntenna ant in canSeeMe) { ant.receive(self); } // relay information to friendlies foreach (RadioAntenna ant in value_registry) { if (CubeBlock.canSendTo(ant.CubeBlock, true, radiusSquared, true)) { foreach (LastSeen seen in myLastSeen.Values) { ant.receive(seen); } foreach (Message mes in myMessages) { ant.receive(mes); } } } Receiver.sendToAttached(CubeBlock, myLastSeen); Receiver.sendToAttached(CubeBlock, myMessages); UpdateEnemyNear(); } catch (Exception e) { myLogger.log("Exception: " + e, "UpdateAfterSimulation100()", Logger.severity.ERROR); } }
public void FaceDataZPositive(CubeBlock block, Vector3 pos, bool dropItem = false){ float half_block_size = block.blockSize / 2.0f; this.AddVertex(new Vector3(pos.x - half_block_size, pos.y - half_block_size, pos.z - half_block_size)); this.AddVertex(new Vector3(pos.x - half_block_size, pos.y + half_block_size, pos.z - half_block_size)); this.AddVertex(new Vector3(pos.x + half_block_size, pos.y + half_block_size, pos.z - half_block_size)); this.AddVertex(new Vector3(pos.x + half_block_size, pos.y - half_block_size, pos.z - half_block_size)); // add normals Vector3 front = Vector3.forward; this.normals.Add (front); this.normals.Add (front); this.normals.Add (front); this.normals.Add (front); // add triangles this.AddQuadTriangles(); // add textures BlockTile blockTile = dropItem ? block.getDropBlockTile() : block.getBlockTile(); Vector2 _00 = blockTile.front_00; Vector2 _10 = blockTile.front_10; Vector2 _01 = blockTile.front_01; Vector2 _11 = blockTile.front_11; this.uvs.Add (_10); this.uvs.Add (_11); this.uvs.Add (_01); this.uvs.Add (_00); }
/// <summary> /// target priority /// missiles - not implementing due to keen /// suites, decoys /// closest terminal block /// meteor /// </summary> private MyEntity TargetAcquisition() { MyGridTargeting targetingSystem = Block.CubeGrid.Components.Get <MyGridTargeting>(); if (targetingSystem == null) { return(null); } List <MyEntity> targetSet = targetingSystem.TargetRoots; double likelyTargetDistanceSqrd = double.MaxValue; MyEntity likelyTarget = null; foreach (MyEntity ent in targetSet) { if (ent.Physics == null || !ent.Physics.Enabled) { continue; } if (IsValidCharacter(ent as IMyCharacter)) { Vector3D characterPosition = ent.PositionComp.WorldVolume.Center + (ent.WorldMatrix.Up * 0.5f); double rangeSqrd = (CubeBlock.WorldMatrix.Translation - characterPosition).LengthSquared(); if (rangeSqrd < MaximumRangeSqrd && rangeSqrd < likelyTargetDistanceSqrd && // is closest IsPositionInTurretArch(characterPosition) && // is in arch IsTargetVisible(ent, characterPosition)) // is visible { likelyTarget = ent; likelyTargetDistanceSqrd = rangeSqrd; } } if (likelyTarget is IMyCharacter) { continue; } MyCubeGrid grid = ent as MyCubeGrid; if (grid != null) { if (grid.GridSizeEnum == MyCubeSize.Large) { if (!TargetLargeShips || (grid.IsStatic && !TargetStations)) { continue; } } else { if (!TargetSmallShips) { continue; } } bool foundEnemyGrid = false; if (grid.BigOwners.Count == 0 && TargetNeutrals) { foundEnemyGrid = true; } foreach (long owner in grid.BigOwners) { MyRelationsBetweenPlayerAndBlock relation = CubeBlock.GetUserRelationToOwner(owner); if (relation == MyRelationsBetweenPlayerAndBlock.Enemies || TargetNeutrals && (relation == MyRelationsBetweenPlayerAndBlock.Neutral || relation == MyRelationsBetweenPlayerAndBlock.NoOwnership)) { foundEnemyGrid = true; } } if (!foundEnemyGrid) { continue; } foreach (MyCubeBlock block in grid.GetFatBlocks()) { if (likelyTarget is IMyDecoy) { break; } if (likelyTarget != null && !(block is IMyDecoy)) { continue; } MyRelationsBetweenPlayerAndBlock relation = block.GetUserRelationToOwner(CubeBlock.OwnerId); if (relation == MyRelationsBetweenPlayerAndBlock.Enemies || TargetNeutrals && (relation == MyRelationsBetweenPlayerAndBlock.Neutral || relation == MyRelationsBetweenPlayerAndBlock.NoOwnership)) { Vector3D blockPosition = block.WorldMatrix.Translation; double rangeSqrd = (CubeBlock.WorldMatrix.Translation - blockPosition).LengthSquared(); if (rangeSqrd < MaximumRangeSqrd && (rangeSqrd < likelyTargetDistanceSqrd || (block is IMyDecoy && !(likelyTarget is IMyDecoy))) && IsPositionInTurretArch(blockPosition) && IsTargetVisible(block, blockPosition)) { likelyTarget = block; likelyTargetDistanceSqrd = rangeSqrd; } } } } if (likelyTarget is IMyCubeBlock) { continue; } if (ent is MyMeteor) { if (!TargetMeteors) { continue; } double rangeSqrd = (CubeBlock.WorldMatrix.Translation - ent.WorldMatrix.Translation).LengthSquared(); if (rangeSqrd < MaximumRangeSqrd && rangeSqrd < likelyTargetDistanceSqrd) { if (IsTargetVisible(ent, ent.WorldMatrix.Translation)) { likelyTarget = ent; likelyTargetDistanceSqrd = rangeSqrd; } } } } return(likelyTarget); }
private InitialTargetStatus GetInitialTarget() { if (loadedAmmo == null || loadedAmmo.MissileDefinition == null) { Log.DebugLog("no ammo"); return(InitialTargetStatus.NotReady); } if (m_weaponTarget.Options.TargetGolis.IsValid()) { Log.TraceLog("golis: " + m_weaponTarget.Options.TargetGolis); m_weaponTarget.SetTarget(new GolisTarget(CubeBlock, m_weaponTarget.Options.TargetGolis)); return(InitialTargetStatus.Golis); } if (m_weaponTarget.CurrentControl != WeaponTargeting.Control.Off && !(m_weaponTarget.CurrentTarget is NoTarget)) { Log.TraceLog("from active weapon, control: " + m_weaponTarget.CurrentControl + ", target: " + m_weaponTarget.CurrentTarget); return(InitialTargetStatus.FromWeapon); } else { Log.TraceLog("clearing weapon target"); m_weaponTarget.SetTarget(NoTarget.Instance); } RelayStorage storage = m_relayPart.GetStorage(); if (storage == null) { Log.TraceLog("Failed to get storage for launcher"); return(InitialTargetStatus.NoStorage); } else { ITerminalProperty <float> rangeProperty = CubeBlock.GetProperty("Range") as ITerminalProperty <float>; if (rangeProperty == null) { Logger.AlwaysLog("rangeProperty == null", Logger.severity.FATAL); return(InitialTargetStatus.NotReady); } float range = rangeProperty.GetValue(CubeBlock); if (range < 1f) { range = loadedAmmo.MissileDefinition.MaxTrajectory; } m_weaponTarget.GetLastSeenTarget(storage, range); if (!(m_weaponTarget.CurrentTarget is NoTarget)) { Log.TraceLog("LastSeen: " + m_weaponTarget.CurrentTarget.Entity.nameWithId()); return(InitialTargetStatus.FromWeapon); } else if (m_weaponTarget.Options.TargetEntityId != 0) { return(InitialTargetStatus.NotFoundId); } else { return(InitialTargetStatus.NotFoundAny); } } }
public void Click() { if (FollowingCamera.touchscreen) { if (Input.touchCount != 1) { return; } else { Touch t = Input.GetTouch(0); if (t.phase != TouchPhase.Ended | t.deltaPosition != Vector2.zero) { return; } } } RaycastHit rh; if (Physics.Raycast(FollowingCamera.cam.ScreenPointToRay(Input.mousePosition), out rh)) { Transform collided = rh.transform; switch (currentAction) { case ClickAction.CreateBlock: { Block b = collided.parent.gameObject.GetComponent <Block>(); if (b == null) { b = collided.parent.parent.gameObject.GetComponent <Block>(); } if (b != null) { Vector3Int cpos = new Vector3Int(b.pos.x, b.pos.y, b.pos.z); if (b.type == BlockType.Cube) { float coordsDelta = rh.point.z - b.transform.position.z; if (Mathf.Abs(coordsDelta) >= Block.QUAD_SIZE / 2f) { if (coordsDelta > 0) { cpos.z += 1; if (cpos.z >= Chunk.CHUNK_SIZE) { return; } } else { cpos.z -= 1; if (cpos.z < 0) { return; } } } coordsDelta = rh.point.x - b.transform.position.x; if (Mathf.Abs(coordsDelta) >= Block.QUAD_SIZE / 2f) { if (coordsDelta > 0) { cpos.x += 1; if (cpos.x >= Chunk.CHUNK_SIZE) { return; } } else { cpos.x -= 1; if (cpos.x < 0) { return; } } } coordsDelta = rh.point.y - b.transform.position.y; if (Mathf.Abs(coordsDelta) >= Block.QUAD_SIZE / 2f) { if (coordsDelta > 0) { cpos.y += 1; if (cpos.y >= Chunk.CHUNK_SIZE) { return; } } else { cpos.y -= 1; if (cpos.y < 0) { return; } } } GameMaster.mainChunk.AddBlock(new ChunkPos(cpos.x, cpos.y, cpos.z), BlockType.Cube, chosenMaterialId, true); } else // surface block { GameMaster.mainChunk.ReplaceBlock(b.pos, BlockType.Cube, chosenMaterialId, true); } } break; } case ClickAction.DeleteBlock: { Block b = collided.parent.gameObject.GetComponent <Block>(); if (b == null) { b = collided.parent.parent.gameObject.GetComponent <Block>(); } if (b != null) { Vector3Int cpos = new Vector3Int(b.pos.x, b.pos.y, b.pos.z); if (b.type == BlockType.Surface | b.type == BlockType.Cave) { GameMaster.mainChunk.DeleteBlock(new ChunkPos(cpos.x, cpos.y - 1, cpos.z)); } GameMaster.mainChunk.DeleteBlock(new ChunkPos(cpos.x, cpos.y, cpos.z)); } break; } case ClickAction.AddGrassland: { Block b = collided.parent.gameObject.GetComponent <Block>(); if (b == null) { b = collided.parent.parent.gameObject.GetComponent <Block>(); } if (b != null) { SurfaceBlock sb = b as SurfaceBlock; if (sb == null & b.pos.y < Chunk.CHUNK_SIZE - 1) { sb = b.myChunk.AddBlock(new ChunkPos(b.pos.x, b.pos.y + 1, b.pos.z), BlockType.Surface, ResourceType.DIRT_ID, true) as SurfaceBlock; } if (sb != null && sb.grassland == null) { Grassland.CreateOn(sb); sb.grassland.AddLifepowerAndCalculate(LIFEPOWER_PORTION); } } break; } case ClickAction.DeleteGrassland: { Block b = collided.parent.gameObject.GetComponent <Block>(); if (b == null) { b = collided.parent.parent.gameObject.GetComponent <Block>(); } if (b != null) { SurfaceBlock sb = b as SurfaceBlock; if (sb != null && sb.grassland != null) { sb.grassland.Annihilation(true); } } break; } case ClickAction.MakeSurface: { Block b = collided.parent.gameObject.GetComponent <Block>(); if (b == null) { b = collided.parent.parent.gameObject.GetComponent <Block>(); } if (b != null) { if (b.type != BlockType.Surface) { if (b.pos.y < Chunk.CHUNK_SIZE - 1) { b.myChunk.AddBlock(new ChunkPos(b.pos.x, b.pos.y + 1, b.pos.z), BlockType.Surface, chosenMaterialId, true); } } else { b.ReplaceMaterial(chosenMaterialId); } } break; } case ClickAction.MakeCave: { CubeBlock cb = collided.parent.gameObject.GetComponent <CubeBlock>(); if (cb != null) { float x = cb.myChunk.CalculateSupportPoints(cb.pos.x, cb.pos.y, cb.pos.z); if (x > 0.5f) { cb.myChunk.ReplaceBlock(cb.pos, BlockType.Cave, cb.material_id, true); } } break; } case ClickAction.AddLifepower: { Block b = collided.parent.gameObject.GetComponent <Block>(); if (b == null) { b = collided.parent.parent.gameObject.GetComponent <Block>(); } if (b != null) { SurfaceBlock sb = b as SurfaceBlock; if (sb != null && sb.grassland != null) { sb.grassland.AddLifepowerAndCalculate(LIFEPOWER_PORTION); } } break; } case ClickAction.TakeLifepower: { Block b = collided.parent.gameObject.GetComponent <Block>(); if (b == null) { b = collided.parent.parent.gameObject.GetComponent <Block>(); } if (b != null) { SurfaceBlock sb = b as SurfaceBlock; if (sb != null && sb.grassland != null) { sb.grassland.TakeLifepowerAndCalculate(LIFEPOWER_PORTION); } } break; } } } }