private static ConstructionInfo ParseContainingFile(string constructionCost)
{
ConstructionInfo result = null;
var indexOfFileHeader = constructionCost.IndexOf("[[", StringComparison.OrdinalIgnoreCase);
var valueString = constructionCost.Substring(0, indexOfFileHeader).Trim();
var temp = constructionCost.Remove(0, indexOfFileHeader);
if (!double.TryParse(valueString, out double value))
{
}
temp = temp.Replace("[[File:", string.Empty); //filename with space? .Replace(" ", string.Empty)
var splitted = temp.Split(new[] { "|" }, StringSplitOptions.RemoveEmptyEntries);
var tempName = splitted[0];
var unit = new CostUnit
{
Type = CostUnitType.File,
Name = tempName.Trim()
};
result = new ConstructionInfo
{
Value = value,
Unit = unit
};
return(result);
}
private object Create(Type typeToCreate, ConstructionInfo info)
{
Type instantiatedType = info.Type;
object[] parms = info.ParameterValues;
// For each constructor parameter that was not provided in the call to Register,
// retrive an object of the parameter type.
for (int i = 0; i < info.Parameters.Length; i++)
{
if (!info.Parameters[i].IsValueSet)
{
parms[i] = Get(info.Parameters[i].Type);
}
}
ConstructorInfo ctor = instantiatedType.GetConstructor(info.ParameterTypes);
if (ctor == null)
{
throw new InvalidOperationException("Constructor for type '" + instantiatedType.Name + "' was not found.");
}
return(ctor.Invoke(parms));
}
private static ConstructionInfo ParseContainingInfoIcon(string constructionCost)
{
ConstructionInfo result = null;
if (!double.TryParse(constructionCost.Split(new[] { "{{" }, StringSplitOptions.RemoveEmptyEntries)[0], out double value))
{
}
var splittedInfo = constructionCost.Split(new[] { "{{" }, StringSplitOptions.RemoveEmptyEntries);
var unit = new CostUnit();
if (splittedInfo[1].Contains("Infoicon"))
{
unit.Type = CostUnitType.InfoIcon;
}
else
{
unit.Type = CostUnitType.Unknown;
}
unit.Name = splittedInfo[1].Replace("}}", string.Empty).Replace("Infoicon", string.Empty).Trim();
result = new ConstructionInfo
{
Value = double.Parse(splittedInfo[0]),
Unit = unit,
};
return(result);
}
ConstructionInfo FindConstruction(IItemCollection primary, IItemCollection secondary, ItemType mainItem, CharClass charClass, out bool canBuild)
{
canBuild = false;
ConstructionInfo best = null;
if (constructions.ContainsKey(mainItem))
{
for (int i = 0; i < constructions[mainItem].Count; i++)
{
ConstructionInfo construction = constructions[mainItem][i];
if (!construction.Classes[(int)charClass])
{
continue;
}
if (CanConstruct(primary, secondary, construction))
{
best = construction;
canBuild = true;
break;
}
else if (best == null && MainItemsAvailable(primary, secondary, construction))
{
best = construction;
}
}
}
return(best);
}
private static ConstructionInfo ParseContainingInfoIcon(string constructionCost)
{
ConstructionInfo result = null;
var splittedInfo = constructionCost.Split(new[] { WIKITEXT_LINK_START }, StringSplitOptions.RemoveEmptyEntries);
if (!double.TryParse(splittedInfo[0], out double parsedValue))
{
logger.Warn($"could not parse construction cost: \"{constructionCost}\"");
}
var unit = new CostUnit();
if (splittedInfo[1].Contains("Infoicon"))
{
unit.Type = CostUnitType.InfoIcon;
}
else
{
unit.Type = CostUnitType.Unknown;
}
unit.Name = splittedInfo[1].Replace(WIKITEXT_LINK_END, string.Empty).Replace("Infoicon", string.Empty).Trim();
result = new ConstructionInfo
{
Value = parsedValue,
Unit = unit,
};
return(result);
}
private void SetPlacesToAttachTo()
{
ConstructionInfo constructionInfo = (ConstructionInfo)this.m_Info;
for (int i = 0; i < constructionInfo.m_PlaceToAttachToNames.Count; i++)
{
this.m_PlacesToAttachToNames.Add(constructionInfo.m_PlaceToAttachToNames[i]);
}
}
bool MainItemsAvailable(IItemCollection primary, IItemCollection secondary, ConstructionInfo construction)
{
for (int i = 0; i < construction.MainItems.Length; i++)
{
if (primary.Contains(construction.MainItems[i]) || secondary.Contains(construction.MainItems[i]))
{
return(true);
}
}
return(false);
}
public void Build(PlayerVO ower, E_Building buildingType, MainBaseVO mainBaseVO)
{
IBuildingVO buildingVO = null;
Vector3Int center = default;
int radius = 0;
int count = 0;
if (mainBaseVO != null)
{
center = mainBaseVO.tilePositon;
radius = mainBaseVO.radius;
}
switch (buildingType)
{
case E_Building.None:
break;
case E_Building.MainBase:
buildingVO = new MainBaseVO();
count = GetBuildMainbasePositionClose(_ConstructionInfos, ower);
break;
case E_Building.FarmLand:
buildingVO = new FarmLandVO();
count = GetBuildPosition(_ConstructionInfos, center, radius, buildingVO.rect);
break;
case E_Building.GoldMine:
buildingVO = new GoldMineVO();
count = GetBuildPosition(_ConstructionInfos, center, radius, buildingVO.rect);
break;
case E_Building.MilitaryCamp:
buildingVO = new MilitaryCampVO();
count = GetBuildPosition(_ConstructionInfos, center, radius, buildingVO.rect);
break;
default:
break;
}
ConstructionInfo constructionInfo = _SelectConstructionHandler(_ConstructionInfos, count, 0);
if (constructionInfo.isRotation)
{
buildingVO.Rotate();
}
buildingVO.tilePositon = constructionInfo.position;
var msgParam = TwoMsgParamsPool <PlayerVO, IBuildingVO> .Instance.Pop();
msgParam.InitParams(ower, buildingVO);
sender.Invoke(GlobalSetting.Cmd_ConfirmConstruction, msgParam);
}
private void SetPlacesToAttach()
{
ConstructionInfo constructionInfo = (ConstructionInfo)this.m_Info;
for (int i = 0; i < constructionInfo.m_PlaceToAttachNames.Count; i++)
{
string name = constructionInfo.m_PlaceToAttachNames[i];
Transform transform = base.gameObject.transform.FindDeepChild(name);
if (transform != null)
{
this.m_PlacesToAttach.Add(transform);
}
}
}
public Construction GetConstruction(Character technician, IItemCollection roomItems, Item mainItem)
{
int index = 3; // TODO
bool canBuild = false;
ConstructionInfo construction = FindConstruction(technician.Items, roomItems, mainItem.Type, technician.Class, out canBuild);
Conversation conv = new Conversation();
if (construction == null)
{
conv.Text = ResourceManager.GetStrings("men_" + defaultDialog.ToString("D3") + "?s" + index);
}
else
{
conv.Text = ResourceManager.GetStrings("men_" + construction.Dialog.ToString("D3") + "?s" + index);
string[] repl = new string[] { "|E", "|F", "|G", "|H" };
for (int i = 0; i < conv.Text.Length; i++)
{
conv.Text[i] = conv.Text[i].Replace("|I", BurntimeClassic.Instance.Game.ItemTypes[construction.Result].Text);
for (int j = 0; j < construction.Items.Length; j++)
{
conv.Text[i] = conv.Text[i].Replace(repl[j], BurntimeClassic.Instance.Game.ItemTypes[construction.Items[j]].Text);
}
}
}
conv.Choices = new ConversationChoice[3];
conv.Choices[0] = new ConversationChoice();
conv.Choices[1] = new ConversationChoice();
if (canBuild)
{
conv.Choices[1].Action = new ConversationAction(ConversationActionType.Yes);
conv.Choices[1].Text = ResourceManager.GetString("burn?501").Replace("|I", BurntimeClassic.Instance.Game.ItemTypes[construction.Result].Text);
}
conv.Choices[2] = new ConversationChoice();
conv.Choices[2].Action = new ConversationAction(ConversationActionType.No);
conv.Choices[2].Text = ResourceManager.GetString("burn?503");
Construction constr = new Construction();
constr.Dialog = conv;
constr.construction = construction;
return(constr);
}
private static ConstructionInfo ParseConstructionInfo(string constructionCost)
{
ConstructionInfo result = null;
if (constructionCost.Contains("[[File:"))
{
result = ParseContainingFile(constructionCost);
}
else
{
result = ParseContainingInfoIcon(constructionCost);
}
return(result);
}
public Constructions(ConfigFile file)
{
defaultDialog = file[""].GetInt("dialog");
ConfigSection[] sections = file.GetAllSections();
foreach (ConfigSection section in sections)
{
ConstructionInfo c = new ConstructionInfo();
c.Result = section.Name;
c.Dialog = section.GetInt("dialog");
c.Items = section.GetStrings("items");
c.Tools = section.GetStrings("tools");
c.MainItems = section.GetStrings("main_items");
c.Classes = new bool[(int)CharClass.Count];
string[] classNames = section.GetStrings("class");
foreach (string name in classNames)
{
try
{
CharClass enumValue = (CharClass)System.Enum.Parse(typeof(CharClass), name, true);
c.Classes[(int)enumValue] = true;
}
catch
{
Burntime.Platform.Log.Warning("Class not found in construction: " + name + "!");
continue;
}
}
foreach (string item in c.MainItems)
{
if (!constructions.ContainsKey(item))
{
constructions.Add(item, new List <ConstructionInfo>());
}
constructions[item].Add(c);
}
}
}
bool CanConstruct(IItemCollection primary, IItemCollection secondary, ConstructionInfo construction)
{
for (int i = 0; i < construction.Items.Length; i++)
{
if (!primary.Contains(construction.Items[i]) && !secondary.Contains(construction.Items[i]))
{
return(false);
}
}
for (int i = 0; i < construction.Tools.Length; i++)
{
if (!primary.Contains(construction.Tools[i]) && !secondary.Contains(construction.Tools[i]))
{
return(false);
}
}
return(true);
}
private static IEnumerable <MappingInfo> AnalyzeLoadMethod(SemanticModel semanticModel, ISymbol loadMethod)
{
var syntaxNode = loadMethod.DeclaringSyntaxReferences.Single().GetSyntax();
var methodSymbols = syntaxNode.DescendantNodes()
.OfType <InvocationExpressionSyntax>()
.Select(invocationExpressionSyntax =>
semanticModel.GetSymbolInfo(invocationExpressionSyntax.Expression).Symbol as IMethodSymbol)
.Where(e => e != null &&
e.GetFullMetadataName() == ExternalLibraryInformation.Module.Register.FullName &&
e.Parameters.IsEmpty);
foreach (var mapping in methodSymbols.Select(e => e.TypeArguments)
.Where(typeArguments =>
typeArguments.Length == ExternalLibraryInformation.Module.RegisterMethodsGenericCount))
{
if (!(mapping[0] is INamedTypeSymbol from))
{
throw new AnalyzerException(
$"Implementation is invalid: {mapping[0].ToDisplayString()}");
}
if (!from.Constructors.Any())
{
throw new AnalyzerException(
$"Implementation has no constructor: {mapping[0].ToDisplayString()}");
}
var constructionInfos = from.Constructors.Select(constructor =>
ConstructionInfo.Create(
constructor.Parameters.Select(
parameter => ParameterInfo.Create(parameter.Type.GetFullMetadataName()))
.ToList()))
.ToList();
var fromInfo = FromInfo.Create(from.GetFullMetadataName(), constructionInfos);
var to = mapping[1];
var toInfo = ToInfo.Create(to.GetFullMetadataName());
yield return(MappingInfo.Create(fromInfo, toInfo));
}
}
private void SetupSurroundingConstructions()
{
Bounds coumpoundObjectBounds = General.GetCoumpoundObjectBounds(base.gameObject);
DebugRender.DrawBox(coumpoundObjectBounds, Color.blue);
List <Construction> list = new List <Construction>();
for (int i = 0; i < Construction.s_EnabledConstructions.Count; i++)
{
Construction construction = Construction.s_EnabledConstructions[i];
if (construction.gameObject.activeSelf && construction.m_Info != null)
{
float magnitude = (construction.gameObject.transform.position - base.gameObject.transform.position).magnitude;
if (magnitude <= 10f)
{
float paramsMulRadius = ((ConstructionInfo)construction.m_Info).m_ParamsMulRadius;
if (paramsMulRadius >= 0f)
{
if (magnitude < paramsMulRadius)
{
list.Add(construction);
}
}
else
{
Bounds coumpoundObjectBounds2 = General.GetCoumpoundObjectBounds(construction.gameObject);
DebugRender.DrawBox(coumpoundObjectBounds2, Color.blue);
if (coumpoundObjectBounds2.Intersects(coumpoundObjectBounds))
{
list.Add(construction);
}
}
}
}
}
if (this.m_RestingPlace)
{
float num = ((ConstructionInfo)this.m_RestingPlace.m_Info).m_RestingParamsMul;
for (int j = 0; j < list.Count; j++)
{
ConstructionInfo constructionInfo = (ConstructionInfo)list[j].m_Info;
if (list[j] != null && list[j].HasRestInfluence())
{
num *= constructionInfo.m_RestingParamsMul;
}
}
this.m_ParamsMul = num;
}
this.m_Shelter = null;
this.m_Firecamps.Clear();
foreach (Construction construction2 in list)
{
if (construction2.GetType() == typeof(Firecamp))
{
this.m_Firecamps.Add((Firecamp)construction2);
}
else if (construction2.m_Info.m_ID.ToString().ToLower().Contains("shelter"))
{
this.m_Shelter = construction2;
}
}
}
private ConstructionInfo SelectConstructionInfoByGreedy(ConstructionInfo constructionArray, int count, int fromIndex = 0)
{
//TODO 获取加成最大者
return(default);
internal QuantizedBvh(ConstructionInfo info)
{
}
