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);
}
