public void UpdatePart(BuildingInstance buildingInstance) { if (itemIndex < 0) { gameObject.SetActive(false); return; } if (itemIndex >= buildingInstance.items.Count) { gameObject.SetActive(false); return; } // There isn't enough items for this part. if (buildingInstance.items[itemIndex].item.image == null) { gameObject.SetActive(false); return; } var placedItem = buildingInstance.items[itemIndex]; if (placedItem.item.type == itemType) { return; // hasn't changed } if (meshFilter == null) { meshFilter = GetComponent <MeshFilter>(); } meshFilter.mesh = ImageManager.Instance.CreateMesh(buildingInstance.items[itemIndex].item.image, ImageManager.Direction.Front); }
internal static List <BuildingInstance> ReadBuildingInstance(string dir, int sheetIndex, Dictionary <int, KeyValuePair <AbsFightModel, BuildingModel> > buildingModels) { FileInfo file = new FileInfo(dir); ExcelPackage package = new ExcelPackage(file); List <BuildingInstance> buildingInstanceList = null; if (package.Workbook.Worksheets.Count > 0) { ExcelWorksheet excelWorksheet = package.Workbook.Worksheets[sheetIndex]; buildingInstanceList = new List <BuildingInstance>(); for (int m = excelWorksheet.Dimension.Start.Row, n = excelWorksheet.Dimension.End.Row; m <= n; m++) { int categoryId = excelWorksheet.GetValue <byte>(m, 1); int specieId = excelWorksheet.GetValue <byte>(m, 5); KeyValuePair <AbsFightModel, BuildingModel> pair = buildingModels[categoryId.GetHashCode() + specieId.GetHashCode()]; BuildingInstance buildingInstance = new BuildingInstance(pair.Key, pair.Value); buildingInstance.posX = excelWorksheet.GetValue <float>(m, 2); buildingInstance.posY = excelWorksheet.GetValue <float>(m, 3); buildingInstance.posZ = excelWorksheet.GetValue <float>(m, 4); buildingInstance.eAngleX = excelWorksheet.GetValue <float>(m, 18); buildingInstance.eAngleY = excelWorksheet.GetValue <float>(m, 19); buildingInstance.eAngleZ = excelWorksheet.GetValue <float>(m, 20); buildingInstance.scaleX = excelWorksheet.GetValue <float>(m, 21); buildingInstance.scaleY = excelWorksheet.GetValue <float>(m, 22); buildingInstance.scaleZ = excelWorksheet.GetValue <float>(m, 23); buildingInstance.teamId = excelWorksheet.GetValue <byte>(m, 24); buildingInstanceList.Add(buildingInstance); } } package.Dispose(); return(buildingInstanceList); }
void StoreBuildingInfo(BuildingInstance building) { if (building.building_type.building_type == 30) { return; // We won't do civzones right now. } for (int zz = building.pos_z_min; zz <= building.pos_z_max; zz++) { for (int yy = building.pos_y_min; yy <= building.pos_y_max; yy++) { for (int xx = building.pos_x_min; xx <= building.pos_x_max; xx++) { if ((building.building_type.building_type == 29) && building.room != null && building.room.extents.Count > 0) { int buildingLocalX = xx - building.room.pos_x; int buildingLocalY = yy - building.room.pos_y; if (building.room.extents[buildingLocalY * building.room.width + buildingLocalX] == 0) { continue; } } buildingInfoMap[new DFCoord(xx, yy, zz)] = building; } } } }
/// <summary> /// 加载一个建筑 /// </summary> /// <param name="buildingInstance"></param> /// <param name="isHost"></param> private void LoadBuilding(BuildingInstance buildingInstance, bool isHost) { int bKey = buildingInstance.fightModel.category.GetHashCode() + buildingInstance.fightModel.specieId.GetHashCode(); if (prefabNames.ContainsKey(bKey)) { string abAssetName = prefabNames[bKey]; string[] nameCompose = abAssetName.Split(' '); if (!instanceDic.ContainsKey(abAssetName)) { instanceDic.Add(abAssetName, new HashSet <AbsFightInstance>()); } if (!instanceDic[abAssetName].Contains(buildingInstance)) { instanceDic[abAssetName].Add(buildingInstance); } if (isHost && buildingInstance.teamId == GameRuntimeData.teamId) { hasAIDic.Add(buildingInstance.instanceId); } SendMsg(Msgs.GetMsgAssetLoadRequest((ushort)AssetLoadEvent.LoadRequest, nameCompose[0], nameCompose[1])); } }
public void UpdatePart(BuildingInstance buildingInput) { if (setParts.Count > 0) { foreach (var activePart in activeParts) { activePart.UpdatePart(buildingInput); } return; } foreach (var item in setParts) { Destroy(item.gameObject); } setParts.Clear(); activeParts.Clear(); var room = buildingInput.room; if (room == null || room.extents.Count == 0) { for (int x = buildingInput.pos_x_min; x <= buildingInput.pos_x_max; x++) { for (int y = buildingInput.pos_y_min; y <= buildingInput.pos_y_max; y++) { GameObject newPart = Instantiate(part, GameMap.DFtoUnityCoord(x, y, buildingInput.pos_z_max), BuildingManager.TranslateDirection(buildingInput.direction), transform); newPart.name += buildingInput.index; setParts.Add(newPart); } } } else { for (int x = 0; x < room.width; x++) { for (int y = 0; y < room.height; y++) { var set = room.extents[x + y * room.width]; if (set == 0) { continue; } GameObject newPart = Instantiate(part, GameMap.DFtoUnityCoord(room.pos_x + x, room.pos_y + y, buildingInput.pos_z_max), BuildingManager.TranslateDirection(buildingInput.direction), transform); newPart.name += buildingInput.index; setParts.Add(newPart); } } } foreach (var setPart in setParts) { activeParts.AddRange(setPart.GetInterfacesInChildren <IBuildingPart>()); } foreach (var activePart in activeParts) { activePart.UpdatePart(buildingInput); } }
public void UpdatePart(BuildingInstance buildingInstance) { if (buildingInstance.direction == BuildingDirection.NONE) { gameObject.SetActive(buildingInstance.active == 0); } else { shouldBeRaised = buildingInstance.active == 1; } }
void BuildProvince() { foreach (var province in provinceData) { province.buildings = new List <BuildingInstance>(); foreach (var building in buildings) { BuildingInstance temp = new BuildingInstance(building); province.buildings.Add(temp); } } }
private void CreateBuilding(BuildingInstance building) { building.hp = building.fightModel.maxHp; building.atk = building.fightModel.atk; //攻击力 building.def = building.fightModel.def; //防御力 building.speed = building.fightModel.speed; //移动速度 building.atkSpeed = building.fightModel.atkSpeed; //攻击速度 building.atkRange = building.fightModel.atkRange; //攻击范围 building.eyeRange = building.fightModel.eyeRange; //视野范围 fightRoomDTO.buildingEntities.Add(building); instances.Add(building.instanceId, building); }
public void Initialize(BuildingInstance buildingInput) { DFHack.DFCoord pos = new DFHack.DFCoord( (buildingInput.pos_x_min + buildingInput.pos_x_max) / 2, (buildingInput.pos_y_min + buildingInput.pos_y_max) / 2, buildingInput.pos_z_max); //always update building rotation because that depends on outside stuff if (MapDataStore.Main[pos] != null && rotationType != RotationType.BuildingDirection) { transform.localRotation = MeshContent.TranslateRotation(rotationType, MapDataStore.Main[pos]); } if (originalBuilding != null && originalBuilding.active == buildingInput.active && originalBuilding.items.Count == buildingInput.items.Count && originalBuilding.pos_x_min == buildingInput.pos_x_min && originalBuilding.pos_y_min == buildingInput.pos_y_min) { return; //There's nothing changed. } originalBuilding = buildingInput; foreach (var part in parts) { part.UpdatePart(buildingInput); } var group = GetComponent <LODGroup>(); if (group == null) { group = gameObject.AddComponent <LODGroup>(); var lods = new LOD[1]; lods[0] = new LOD(0.05f, GetComponentsInChildren <MeshRenderer>()); group.SetLODs(lods); group.RecalculateBounds(); } UpdateTilePositions(buildingInput); foreach (var item in GetComponentsInChildren <Collider>()) { if (item.GetComponent <BuildingSelect>() == null) { item.gameObject.AddComponent <BuildingSelect>().root = this; } } }
public Tuple <Sprite, int> GetSpriteAndRotationAt(Vector2Int position) { if (!IsOccupied(position)) { return(null); } BuildingInstance building = _slotToBuilding[position]; Vector2Int origin = _buildingOrigin[building]; Vector2Int offset = InverseRotate(position - origin, building.Rotation); return(new Tuple <Sprite, int>( building.Template.Tiles.First(tile => tile.Offset == offset).Sprite, building.Rotation )); }
private DFCoord2d GetRotatedLocalCoord(DFCoord worldCoord, BuildingInstance building) { switch (building.direction) { case BuildingDirection.NORTH: return(new DFCoord2d(worldCoord.x - building.pos_x_min, worldCoord.y - building.pos_y_min)); case BuildingDirection.EAST: return(new DFCoord2d(worldCoord.y - building.pos_y_min, building.pos_x_max - worldCoord.x)); case BuildingDirection.SOUTH: return(new DFCoord2d(building.pos_x_max - worldCoord.x, building.pos_y_max - worldCoord.y)); case BuildingDirection.WEST: return(new DFCoord2d(building.pos_y_max - worldCoord.y, worldCoord.x - building.pos_x_min)); default: return(new DFCoord2d(worldCoord.x - building.pos_x_min, worldCoord.y - building.pos_y_min)); } }
public void ConstructBuilding(BuildingTemplate template, Vector2Int origin, int rotation) { if (!IsValidBuilding(template, origin, rotation)) { Debug.LogError( "Attempting to build invalid configuration.\n" + $"Building{template.DisplayName} origin {origin} rotation {rotation}" ); return; } var building = new BuildingInstance(template, rotation); _buildingOrigin[building] = origin; foreach (BuildingTile tile in template.Tiles) { Vector2Int offset = Rotate(tile.Offset, rotation); _slotToBuilding[origin + offset] = building; } }
private void UpdateTilePositions(BuildingInstance buildingInput) { ClearSelectionColliders(); List <Vector3> transformList = new List <Vector3>(); var room = buildingInput.room; if (room == null || room.extents.Count == 0 || buildingInput.is_room) { for (int x = buildingInput.pos_x_min; x <= buildingInput.pos_x_max; x++) { for (int y = buildingInput.pos_y_min; y <= buildingInput.pos_y_max; y++) { transformList.Add(GameMap.DFtoUnityCoord(x, y, buildingInput.pos_z_max)); } } } else { for (int y = 0; y < room.height; y++) { for (int x = 0; x < room.width; x++) { var set = room.extents[x + y * room.width]; if (set == 0) { continue; } transformList.Add(GameMap.DFtoUnityCoord(room.pos_x + x, room.pos_y + y, buildingInput.pos_z_max)); } } } tilePositions = new Matrix4x4[transformList.Count]; for (int i = 0; i < transformList.Count; i++) { Instantiate(BuildingManager.Instance.selectionFloor, transformList[i], Quaternion.identity, transform); tilePositions[i] = Matrix4x4.Translate(transformList[i]); } }
public void UpdatePart(BuildingInstance buildingInstance) { if (itemIndex < 0) { return; } if (itemIndex >= buildingInstance.items.Count) { return; // There isn't enough items for this part. } var placedItem = buildingInstance.items[itemIndex]; if (placedItem.item.type == itemType) { return; // hasn't changed } if (item != null) { Destroy(item.gameObject); } item = ItemManager.InstantiateItem(placedItem.item, transform, false); }
/// <summary> /// 创建实体实例 /// </summary> /// <param name="fightInstance"></param> /// <param name="obj"></param> /// <param name="hasAI"></param> private void CreateEntityInstance(AbsFightInstance fightInstance, UnityEngine.Object obj, bool hasAI) { GameObject entity = null; switch (fightInstance.fightModel.category) { case (byte)ModelType.Building: BuildingInstance buildingInstance = fightInstance as BuildingInstance; entity = GameObject.Instantiate(obj, new Vector3(buildingInstance.posX, buildingInstance.posY, buildingInstance.posZ), Quaternion.Euler(0, 0, 0)) as GameObject; entity.transform.eulerAngles = new Vector3(buildingInstance.eAngleX, buildingInstance.eAngleY, buildingInstance.eAngleZ); entity.transform.localScale = new Vector3(buildingInstance.scaleX, buildingInstance.scaleY, buildingInstance.scaleZ); break; case (byte)ModelType.Hero: entity = GameObject.Instantiate(obj, new Vector3(fightInstance.posX, fightInstance.posY, fightInstance.posZ), Quaternion.Euler(0, 0, 0)) as GameObject; break; case (byte)ModelType.Creature: entity = GameObject.Instantiate(obj, new Vector3(fightInstance.posX, fightInstance.posY, fightInstance.posZ), Quaternion.Euler(0, 0, 0)) as GameObject; break; } if (entity != null) { if (fightInstance.teamId == 1) { entity.layer = LayerIds.TeamOneLayer; } else { entity.layer = LayerIds.TeamTwoLayer; } } InitialScripts(entity, fightInstance); InitialAI(hasAI, entity, fightInstance); }
public MsgBuildingCreate(ushort msgId, BuildingInstance buildingCreateDTO, bool isHost) { this.msgId = msgId; this.buildingCreateDTO = buildingCreateDTO; this.isHost = isHost; }
public void UpdatePart(BuildingInstance buildingInput) { Color partColor = new Color32(128, 128, 128, 128); float textureIndex = 0; if (string.IsNullOrEmpty(item) || ItemTokenList.ItemLookup == null) { if (index < 0) { partColor = ContentLoader.GetColor(buildingInput.material); textureIndex = ContentLoader.GetPatternIndex(buildingInput.material); } else if (index >= buildingInput.items.Count - endOffset) { gameObject.SetActive(false); return; } else { var buildingItem = buildingInput.items[index]; //skip items that are just stored in the building. //though they should be later in the list anyway. if ((buildingItem.mode == 0) != storedItem) { gameObject.SetActive(false); return; } partColor = ContentLoader.GetColor(buildingItem.item); textureIndex = ContentLoader.GetPatternIndex(buildingItem.item.material); } } else if (!ItemTokenList.ItemLookup.ContainsKey(item)) { gameObject.SetActive(false); return; } else { MatPairStruct itemCode = ItemTokenList.ItemLookup[item].mat_pair; bool set = false; foreach (var item in buildingInput.items) { //skip items that are just stored in the building. //though they should be later in the list anyway. if (item.mode == 0 && !storedItem) { continue; } //if our setting is a generic item, like any weapon, then any subtype can match. if ((itemCode.mat_index == -1 && itemCode.mat_type == item.item.type.mat_type) || (item.item.type == itemCode)) { partColor = ContentLoader.GetColor(item.item); textureIndex = ContentLoader.GetPatternIndex(item.item.material); set = true; break; } } if (!set) { gameObject.SetActive(false); return; } } gameObject.SetActive(true); if (meshRenderer == null) { meshRenderer = GetComponent <MeshRenderer>(); } if (partColor.a < 0.5f) { meshRenderer.sharedMaterial = TransparentMaterial; } else { meshRenderer.sharedMaterial = OriginalMaterial; } meshRenderer.sharedMaterial.SetTexture("_MatTex", ContentLoader.Instance.PatternTextureArray); MaterialPropertyBlock prop = new MaterialPropertyBlock(); prop.SetColor("_MatColor", partColor); prop.SetFloat("_MatIndex", textureIndex); meshRenderer.SetPropertyBlock(prop); }
public void UpdatePart(BuildingInstance buildingInput) { ColorDefinition dye = null; MatPairStruct mat = new MatPairStruct(-1, -1); if (string.IsNullOrEmpty(item) || ItemTokenList.ItemLookup == null) { mat = buildingInput.material; } else if (!ItemTokenList.ItemLookup.ContainsKey(item)) { gameObject.SetActive(false); return; } else { MatPairStruct itemCode = ItemTokenList.ItemLookup[item].mat_pair; bool set = false; foreach (var item in buildingInput.items) { //skip items that are just stored in the building. //though they should be later in the list anyway. if (item.mode == 0) { continue; } //if our setting is a generic item, like any weapon, then any subtype can match. if ((itemCode.mat_index == -1 && itemCode.mat_type == item.item.type.mat_type) || (item.item.type == itemCode)) { mat = item.item.material; dye = item.item.dye; set = true; break; } } if (!set) { gameObject.SetActive(false); return; } } gameObject.SetActive(true); Color partColor = Color.gray; ColorContent colorContent; if (ContentLoader.Instance.MaterialColors.TryGetValue(mat, out colorContent)) { partColor = colorContent.color; } if (dye != null) { partColor *= (Color) new Color32((byte)dye.red, (byte)dye.green, (byte)dye.blue, 255); } int textureIndex = 0; TextureContent textureContent; if (ContentLoader.Instance.MaterialTextures.TryGetValue(mat, out textureContent)) { textureIndex = textureContent.StorageIndex; } meshRenderer.sharedMaterial.SetTexture("_MatTex", ContentLoader.Instance.materialTextureStorage.AtlasTexture); MaterialPropertyBlock prop = new MaterialPropertyBlock(); prop.SetColor("_MatColor", partColor); prop.SetFloat("_MatIndex", textureIndex); meshRenderer.SetPropertyBlock(prop); }
public void UpdatePart(BuildingInstance buildingInput) { on = buildingInput.active > 0; }
/// <summary> /// 初始化数据 /// </summary> /// <param name="buildingInstance"></param> public override void Initial(AbsFightInstance buildingInstance) { base.Initial(buildingInstance); this.buildingInstance = buildingInstance as BuildingInstance; isAttacking = false; }
public static MsgBuildingCreate GetMsgBuildingCreate(ushort msgId, BuildingInstance dto, bool isHost) { msgBuildingCreate.SetBuildingCreate(msgId, dto, isHost); return(msgBuildingCreate); }