public void Initialize(Entity entity, EntitiesHarvestableUI entitiesHarvestable)
{
float population;
if (entity.population < 0)
{
population = 1;
}
else
{
population = Mathf.Floor(entity.population);
}
text.text = "" + population + " " + entity.entitySO.name;
this.entity = entity;
this.entitiesHarvestable = entitiesHarvestable;
foreach (Transform trans in ressourcesPreview.transform)
{
Destroy(trans.gameObject);
}
foreach (var res in entity.entitySO.resources)
{
ResourceTemplate temp = Instantiate(ressourcesTemplate, ressourcesPreview.transform);
temp.icon.sprite = res.Key.icon;
temp.value.text = "" + res.Value.gain[entity.HarvestedBonus];
}
}
public void TestSchemaDependsOnWhenParametrizePropertiesOnlyIsTrue()
{
ResourceTemplate actual = GetSchema(true);
Assert.AreEqual(1, actual.dependsOn.Count);
Assert.AreEqual("[resourceId('Microsoft.ApiManagement/service/apis', parameters('service_dev_name'),'vita-gatan')]", actual.dependsOn[0].Value <string>());
}
/// <summary>
/// Put a resource template in the templates warehouse.
/// </summary>
/// <param name="template">Resource template.</param>
public static void PutTemplate(ResourceTemplate template)
{
if (!templates.ContainsKey(template.ClassId))
{
templates.Add(template.ClassId, template);
}
}
public string PrepareTemplate(ResourceTemplate resource)
{
var segments = new List <string>()
{
_generationRootFolder.FullName,
"resourceTemplates",
};
var subSegments = resource.Template.Split('/', StringSplitOptions.RemoveEmptyEntries);
segments.AddRange(subSegments.Take(subSegments.Length - 1));
segments.Add(subSegments.Last() + ".yaml");
var templatePath = Path.Combine(segments.ToArray());
var template = ReadFileAsJson(templatePath);
try
{
return(SubstituteParams(template, resource.Params));
}
catch (Exception e)
{
throw new Exception($"Can't substitute params in template: {resource.Template}", e);
}
}
public void AddResource(ResourceTemplate resource)
{
if (Resources.ContainsKey(resource.Key))
{
throw new MeException($"Duplicate resource {resource.Name}.");
}
Resources.Add(resource.Key, resource);
}
public ResourceInstance(ResourceTemplate template, Entity parent)
{
Resource = template;
Parent = parent;
Refresh();
Value = MaxAmount * Modifier;
NextRegenTick = 0;
}
public void AddResource(ResourceTemplate resource)
{
if (ResourceMap.ContainsKey(resource.Key))
{
return;
}
ResourceInstance resIn = new ResourceInstance(resource, this);
ResourceMap.Add(resource.Key, resIn);
RefreshProperties();
}
ResourceTemplate ResourceFromJson(JToken json, ClassTemplate result)
{
string resKey = json.Value <string>();
ResourceTemplate res = Engine.GetPropertyManager().GetResource(resKey);
if (res == null)
{
throw new MeException($"Class {result.Name} references resource with key {resKey}, which does not exist.");
}
return(res);
}
public static ResourceTemplate getMockHP(IGameEngine engine)
{
MeNode max = TreeConverter.Build("VIT*20", engine);;
MeNode regen = TreeConverter.Build("0", engine);
ResourceTemplate hp = new ResourceTemplate();
hp.Formula = max;
hp.RegenFormula = regen;
hp.Key = Entity.HP_KEY;
hp.RegenInterval = new MeNode(GcConstants.Resources.DEFAULT_INTERVAL);
return(hp);
}
public void HandNestedIncludeWithPrefixDirs()
{
var template = new ResourceTemplate(_lib, new FileBasedResourceLocator("Views"), new FileLocatorFactory(), "Home/Index.htm");
ITile a = new TemplateTile("a", template, new List <TileAttribute>());
var result = a.Render(new TagModel(new Dictionary <string, string> {
{ "Message", "Test" }
}));
string expected = File.ReadAllText("expected_insert_template.htm");
result = CleanUp(result);
expected = CleanUp("VIEWS" + expected);
Assert.That(result, Is.EqualTo(expected));
}
public void LoadResourcesFromPath(string path)
{
JArray resourceJson = FileHandler.FromPath <JArray>(path);
ResourceReader reader = new ResourceReader(Engine);
foreach (JToken resourceValue in resourceJson)
{
if (resourceValue.Type != JTokenType.Object)
{
throw new MeException($"Expected a json object \"{path}\"at \"{resourceValue}\".");
}
ResourceTemplate newResource = reader.FromJson(resourceValue.ToObject <JObject>());
AddResource(newResource);
}
}
public bool FromJObject(JObject obj, IGameEngine engine)
{
string key = obj[GcConstants.General.KEY].ToObject <string>();
if (!engine.GetPropertyManager().HasResource(key))
{
return(false);
}
ResourceTemplate template = engine.GetPropertyManager().GetResource(key);
Resource = template;
double value = obj[GcConstants.General.VALUE].ToObject <double>();
Value = value;
return(true);
}
/// <summary>
/// Get a template by type from the templates warehouse. If not in the warehouse, a new ResourceTemplate is created and added to the warehouse.
/// </summary>
/// <param name="type">.Net type.</param>
/// <returns>Resource template.</returns>
public static ResourceTemplate GetTemplate(Type type)
{
// loaded ?
foreach (var t in templates.Values)
{
if (t.ClassName == type.FullName)
{
return(t);
}
}
var template = new ResourceTemplate(type);
templates.Add(template.ClassId, template);
return(template);
}
public void ResourceReaderTestDefaultValues()
{
string key = "TEST_RES";
JObject resource = new JObject();
resource.Add(GcConstants.General.KEY, key);
resource.Add(GcConstants.General.FORMULA, "VIT*20");
ResourceTemplate res = Reader.FromJson(resource);
Assert.AreEqual(key, res.Key);
Assert.IsNotNull(res.Formula);
Assert.AreEqual(GcConstants.Resources.DEFAULT_INTERVAL, res.RegenInterval.Value.ToLong());
Assert.AreEqual(GcConstants.Resources.DEFAULT_REGEN, res.RegenFormula.Value.ToDouble());
Assert.AreEqual(GcConstants.Resources.DEFAULT_MODIFIER, res.StartMod.Value.ToDouble());
}
protected override void OnInit(EventArgs e)
{
if (ResourceTemplate != null)
{
ScheduledResourceTemplate srt = new ScheduledResourceTemplate();
plcResource.Controls.Add(srt);
ResourceTemplate.InstantiateIn(srt);
}
if (SubNavTemplate != null)
{
ScheduledResourceSubNavTemplate snt = new ScheduledResourceSubNavTemplate();
plcSubNav.Controls.Add(snt);
SubNavTemplate.InstantiateIn(snt);
}
base.OnInit(e);
}
public static void StartUp(TestContext ctx)
{
Definer.Instance().Engine = Engine;
DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null);
trueDamage.Key = "T";
Engine.AddDamageType(trueDamage);
ResourceTemplate mana = new ResourceTemplate();
mana.Key = "MP";
ResourceTemplate hp = new ResourceTemplate();
hp.Key = Entity.HP_KEY;
Engine.GetPropertyManager().AddResource(hp);
Engine.GetPropertyManager().AddResource(mana);
Engine.GetCoreManager().DefaultSkillThreat = GcConstants.Core.DEFAULT_THREAT;
}
public void RefreshView()
{
for (int i = 0; i < sizePool; i++)
{
pool[i].gameObject.SetActive(false);
}
int index = 0;
foreach (KeyValuePair <ResourceType, float> data in inv.resources)
{
ResourceTemplate template = pool[index++];
template.icon.sprite = data.Key.icon;
template.value.text = "" + data.Value;
template.textPanel.text = I18N.GetText(data.Key.infoboxPanel);
template.textPanel.spriteAsset = data.Key.textIcons;
template.gameObject.SetActive(true);
}
}
public static void StartUp(TestContext ctx)
{
Definer.Instance().Engine = Engine;
DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null);
trueDamage.Name = "true";
trueDamage.Key = "T";
Engine.AddDamageType(trueDamage);
ResourceTemplate res = new ResourceTemplate()
{
Key = "MP"
};
SkillCost nullCost = new SkillCost(res, TreeConverter.Build("0", Engine));
_testSkill = new SkillTemplate();
_testSkill.Type = SkillType.Cast;
_testSkill.Key = "TEST_CAST";
SkillLevelTemplate testLevelTemplate = new SkillLevelTemplate();
testLevelTemplate.Cooldown = TreeConverter.Build("3", Engine);
testLevelTemplate.Duration = TreeConverter.Build($"{LConstants.SourceKeyword}{LConstants.PROP_OP}INT", Engine);
testLevelTemplate.Interruptible = TreeConverter.Build("true", Engine);
testLevelTemplate.Formulas.Add(TreeConverter.Build($"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10)", Engine));
testLevelTemplate.PushBack = TreeConverter.Build("true", Engine);
testLevelTemplate.Cost = nullCost;
_testSkill.ByLevel.Add(testLevelTemplate);
Engine.GetSkillManager().AddSkill(_testSkill);
BaseObject bDmg = new BaseObject()
{
Description = "", Key = "BASE_DMG", Name = "Base damage"
};
Engine.GetPropertyManager().BaseValues.Add("BASE_DMG", bDmg);
BaseObject intellect = new BaseObject()
{
Description = "", Key = "INT", Name = "Intellect"
};
Engine.GetPropertyManager().Attributes.Add("INT", intellect);
}
public MockEntity(IGameEngine engine)
: base(engine)
{
AddAttribute("VIT", 5);
AddAttribute("STR", 5);
AddAttribute("INT", 5);
AddAttribute("AGI", 10);
AddAttribute("DEF", 10);
AddAttribute("MDEF", 10);
AddResource(getMockHP(engine));
MeNode mpNode = TreeConverter.Build("INT*10", engine);
MeNode mpRegen = TreeConverter.Build("INT/100", engine);
ResourceTemplate resTemp = new ResourceTemplate();
resTemp.Formula = mpNode;
resTemp.RegenFormula = mpRegen;
resTemp.Key = "MP";
resTemp.RegenInterval = new MeNode(GcConstants.Resources.DEFAULT_INTERVAL);
AddResource(resTemp);
}
public ResourceTemplate FromJson(JObject json)
{
ResourceTemplate result = new ResourceTemplate();
result.LoadBase(json);
//get formula for calculating max amount
string maxValue = JsonUtils.ValidateJsonEntry(
GcConstants.General.FORMULA,
json,
JTokenType.String,
$"Unknown formula for resource {result.Name}").ToString();
result.Formula = TreeConverter.Build(maxValue, Engine);
//get formula for calculating regen
string regenValue = JsonUtils.GetValueOrDefault(
json,
GcConstants.Resources.REGEN,
GcConstants.Resources.DEFAULT_REGEN.ToString(CultureInfo.InvariantCulture));
result.RegenFormula = TreeConverter.Build(regenValue, Engine);
//get interval
string intervalValue = JsonUtils.GetValueOrDefault <string>(json, GcConstants.Resources.INTERVAL, GcConstants.Resources.DEFAULT_INTERVAL.ToString());
result.RegenInterval = TreeConverter.Build(intervalValue, Engine);
//get modifier
string modifierValue = JsonUtils.GetValueOrDefault <string>(
json,
GcConstants.Resources.MODIFIER,
GcConstants.Resources.DEFAULT_MODIFIER.ToString());
result.StartMod = TreeConverter.Build(modifierValue, Engine);
return(result);
}
public void EntityTestAddResource()
{
MockEntity ent = new MockEntity(Engine);
ResourceTemplate resTemp = new ResourceTemplate();
resTemp.Formula = new MeNode(100);
resTemp.RegenFormula = new MeNode(0);
resTemp.RegenInterval = new MeNode(0);
resTemp.StartMod = new MeNode(0);
resTemp.Key = "TEST_RES";
resTemp.Name = "Test Resource";
resTemp.Description = "";
ent.AddResource(resTemp);
ent.Key = "TEST_KEY";
Assert.AreEqual(0, ent.GetProperty(resTemp.Key).Value);
long amount = 50;
Engine.AddPlayer(ent);
string fromula = $"{LConstants.ADD_TO_RESOURCE_F}({ent.Key},{resTemp.Key},{amount})";
TreeConverter.Build(fromula, Engine).Resolve();
Assert.AreEqual(amount, ent.GetProperty(resTemp.Key).Value);
}
public void ResourceReaderTestNonDefaultValues()
{
string key = "TEST_RES";
JObject resource = new JObject();
resource.Add(GcConstants.General.KEY, key);
resource.Add(GcConstants.General.FORMULA, "VIT*20");
long interval = 5;
resource.Add(GcConstants.Resources.INTERVAL, interval);
resource.Add(GcConstants.Resources.REGEN, "100/10");
double mod = 1;
resource.Add(GcConstants.Resources.MODIFIER, mod);
ResourceTemplate res = Reader.FromJson(resource);
Assert.AreEqual(key, res.Key);
Assert.IsNotNull(res.Formula);
Assert.AreEqual(interval, res.RegenInterval.Value.ToLong());
Assert.AreEqual(10, res.RegenFormula.Resolve().Value.ToDouble());
Assert.AreEqual(mod, res.StartMod.Value.ToDouble());
}
public static void StartUp(TestContext context)
{
DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null);
trueDamage.Key = "T";
trueDamage.Name = "true";
Engine.AddDamageType(trueDamage);
ResourceTemplate res = new ResourceTemplate()
{
Key = "MP"
};
SkillCost nullCost = new SkillCost(res, TreeConverter.Build("0", Engine));
SkillCost notFree = new SkillCost(res, TreeConverter.Build("50", Engine));
_testSkill = new SkillTemplate();
_testSkill.Type = SkillType.Cast;
_testSkill.Key = "TEST_CAST";
SkillLevelTemplate testLevelTemplate = new SkillLevelTemplate();
testLevelTemplate.Cooldown = TreeConverter.Build("3", Engine);
testLevelTemplate.Duration = TreeConverter.Build($"{LConstants.SourceKeyword}{LConstants.PROP_OP}INT", Engine);
testLevelTemplate.Interruptible = TreeConverter.Build("true", Engine);
testLevelTemplate.Formulas.Add(TreeConverter.Build($"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10)", Engine));
testLevelTemplate.PushBack = TreeConverter.Build("true", Engine);
testLevelTemplate.Cost = nullCost;
_testSkill.ByLevel.Add(testLevelTemplate);
_testChannelSkill = new SkillTemplate();
_testChannelSkill.Type = SkillType.Channel;
_testChannelSkill.Key = "TEST_CHANNEL";
SkillLevelTemplate testLevelTemplate2 = new SkillLevelTemplate();
testLevelTemplate2.Cooldown = TreeConverter.Build("120", Engine);
testLevelTemplate2.Duration = TreeConverter.Build("60", Engine);
testLevelTemplate2.Interval = TreeConverter.Build("10", Engine);
testLevelTemplate2.PushBack = TreeConverter.Build("true", Engine);
testLevelTemplate2.Interruptible = TreeConverter.Build("true", Engine);
testLevelTemplate2.Cost = nullCost;
MeNode channelFormula = TreeConverter.Build(
$"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10)",
Engine);
Engine.GetSanitizer().SetHarmsToPeriodic(channelFormula);
testLevelTemplate2.Formulas.Add(channelFormula);
_testChannelSkill.ByLevel.Add(testLevelTemplate2);
_instantHarm = new SkillTemplate();
_instantHarm.Type = SkillType.Cast;
_instantHarm.Key = "HURT";
SkillLevelTemplate hurtLevelTemplate = new SkillLevelTemplate();
hurtLevelTemplate.Cooldown = TreeConverter.Build("0", Engine);
hurtLevelTemplate.Duration = TreeConverter.Build("0", Engine);
hurtLevelTemplate.PushBack = TreeConverter.Build("false", Engine);
hurtLevelTemplate.Interruptible = TreeConverter.Build("true", Engine);
hurtLevelTemplate.Formulas.Add(TreeConverter.Build($"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10)", Engine));
hurtLevelTemplate.Cost = nullCost;
_instantHarm.ByLevel.Add(hurtLevelTemplate);
_unpushable = new SkillTemplate();
_unpushable.Type = SkillType.Cast;
_unpushable.Key = "NOPUSH";
SkillLevelTemplate unpushTemplate = new SkillLevelTemplate();
unpushTemplate.Cooldown = TreeConverter.Build("0", Engine);
unpushTemplate.Duration = TreeConverter.Build("5", Engine);
unpushTemplate.Interruptible = TreeConverter.Build("false", Engine);
unpushTemplate.PushBack = TreeConverter.Build("false", Engine);
unpushTemplate.Formulas.Add(TreeConverter.Build($"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10)", Engine));
unpushTemplate.Cost = nullCost;
_unpushable.ByLevel.Add(unpushTemplate);
_costly = new SkillTemplate();
_costly.Type = SkillType.Cast;
_costly.Key = "COSTLY";
SkillLevelTemplate costlyTemplate = new SkillLevelTemplate();
costlyTemplate.Cooldown = TreeConverter.Build("0", Engine);
costlyTemplate.Duration = TreeConverter.Build("0", Engine);
costlyTemplate.Interruptible = TreeConverter.Build("true", Engine);
costlyTemplate.Formulas.Add(TreeConverter.Build($"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10)", Engine));
costlyTemplate.PushBack = TreeConverter.Build("true", Engine);
costlyTemplate.Cost = notFree;
_costly.ByLevel.Add(costlyTemplate);
_skillUsingStat = new SkillTemplate();
_skillUsingStat.Type = SkillType.Cast;
_skillUsingStat.Key = "WITH_STAT";
SkillLevelTemplate withStaTemplate = new SkillLevelTemplate();
withStaTemplate.Cooldown = TreeConverter.Build("0", Engine);
withStaTemplate.Duration = TreeConverter.Build("0", Engine);
withStaTemplate.Interruptible = TreeConverter.Build("true", Engine);
withStaTemplate.Formulas.Add(TreeConverter.Build($"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10*{LConstants.SourceKeyword}{LConstants.PROP_OP}STR+{LConstants.GET_PROP_F}({LConstants.SourceKeyword},{BASE_VALUE}))", Engine));
withStaTemplate.PushBack = TreeConverter.Build("true", Engine);
withStaTemplate.Cost = nullCost;
_skillUsingStat.ByLevel.Add(withStaTemplate);
}
/// <summary>
/// Create new instance.
/// </summary>
/// <param name="id">Instance Id.</param>
/// <param name="name">Name of the instance.</param>
/// <param name="resource">Resource to manage.</param>
/// <param name="store">Store responsible for the resource.</param>
public Instance(uint id, string name, IResource resource, IStore store, ResourceTemplate customTemplate = null, ulong age = 0)
{
this.store = store;
this.resource = resource;
this.id = id;
this.name = name;
this.instanceAge = age;
this.attributes = new KeyList <string, object>(this);
children = new AutoList <IResource, Instance>(this);
parents = new AutoList <IResource, Instance>(this);
managers = new AutoList <IPermissionsManager, Instance>(this);
children.OnAdd += Children_OnAdd;
children.OnRemoved += Children_OnRemoved;
parents.OnAdd += Parents_OnAdd;
parents.OnRemoved += Parents_OnRemoved;
resource.OnDestroy += Resource_OnDestroy;
if (customTemplate != null)
{
this.template = customTemplate;
}
else
{
this.template = Warehouse.GetTemplate(resource.GetType());
}
// set ages
for (byte i = 0; i < template.Properties.Length; i++)
{
ages.Add(0);
modificationDates.Add(DateTime.MinValue);
}
// connect events
Type t = resource.GetType();
#if NETSTANDARD1_5
var events = t.GetTypeInfo().GetEvents(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
#else
var events = t.GetEvents(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
#endif
foreach (var evt in events)
{
//if (evt.EventHandlerType != typeof(ResourceEventHanlder))
// continue;
if (evt.EventHandlerType == typeof(ResourceEventHanlder))
{
var ca = (ResourceEvent[])evt.GetCustomAttributes(typeof(ResourceEvent), true);
if (ca.Length == 0)
{
continue;
}
ResourceEventHanlder proxyDelegate = (args) => EmitResourceEvent(null, null, evt.Name, args);
evt.AddEventHandler(resource, proxyDelegate);
}
else if (evt.EventHandlerType == typeof(CustomResourceEventHanlder))
{
var ca = (ResourceEvent[])evt.GetCustomAttributes(typeof(ResourceEvent), true);
if (ca.Length == 0)
{
continue;
}
CustomResourceEventHanlder proxyDelegate = (issuer, receivers, args) => EmitResourceEvent(issuer, receivers, evt.Name, args);
evt.AddEventHandler(resource, proxyDelegate);
}
/*
* else if (evt.EventHandlerType == typeof(CustomUsersEventHanlder))
* {
* var ca = (ResourceEvent[])evt.GetCustomAttributes(typeof(ResourceEvent), true);
* if (ca.Length == 0)
* continue;
*
* CustomUsersEventHanlder proxyDelegate = (users, args) => EmitResourceEvent(evt.Name, users, null, args);
* evt.AddEventHandler(resource, proxyDelegate);
* }
* else if (evt.EventHandlerType == typeof(CustomConnectionsEventHanlder))
* {
* var ca = (ResourceEvent[])evt.GetCustomAttributes(typeof(ResourceEvent), true);
* if (ca.Length == 0)
* continue;
*
* CustomConnectionsEventHanlder proxyDelegate = (connections, args) => EmitResourceEvent(evt.Name, null, connections, args);
* evt.AddEventHandler(resource, proxyDelegate);
* }
* else if (evt.EventHandlerType == typeof(CustomReceiversEventHanlder))
* {
* var ca = (ResourceEvent[])evt.GetCustomAttributes(typeof(ResourceEvent), true);
* if (ca.Length == 0)
* continue;
*
* CustomReceiversEventHanlder proxyDelegate = (users, connections, args) => EmitResourceEvent(evt.Name, users, connections, args);
* evt.AddEventHandler(resource, proxyDelegate);
*
* }
*/
}
}
public void TestSchema()
{
ResourceTemplate actual = GetSchema(false);
Assert.IsNotNull(actual);
}
/// <summary>
/// Put a resource in the warehouse.
/// </summary>
/// <param name="resource">Resource instance.</param>
/// <param name="name">Resource name.</param>
/// <param name="store">IStore that manages the resource. Can be null if the resource is a store.</param>
/// <param name="parent">Parent resource. if not presented the store becomes the parent for the resource.</param>
public static void Put(IResource resource, string name, IStore store = null, IResource parent = null, ResourceTemplate customTemplate = null, ulong age = 0, IPermissionsManager manager = null)
{
resource.Instance = new Instance(resourceCounter++, name, resource, store, customTemplate, age);
if (manager != null)
{
resource.Instance.Managers.Add(manager);
}
if (store == parent)
{
parent = null;
}
if (parent == null)
{
if (!(resource is IStore))
{
store.Instance.Children.Add(resource);
}
}
else
{
parent.Instance.Children.Add(resource);
}
if (resource is IStore)
{
stores.Add(resource as IStore);
StoreConnected?.Invoke(resource as IStore, name);
}
else
{
store.Put(resource);
}
resources.Add(resource.Instance.Id, resource);
if (!storeIsOpen)
{
resource.Trigger(ResourceTrigger.Initialize);
}
}
public ClassTemplate FromJson(JObject json)
{
ClassTemplate result = new ClassTemplate();
result.LoadBase(json);
AddBaseValueVector(GcConstants.Classes.BASE_VALUES, json, result, result.BasicValues);
foreach (string baseV in result.BasicValues.Keys)
{
if (!Engine.GetPropertyManager().HasBaseValue(baseV))
{
throw new MeException($"Class {result.Name} references unknown base value {baseV}.");
}
}
foreach (BaseObject baseValue in Engine.GetPropertyManager().BaseValues.Values)
{
if (!result.BasicValues.ContainsKey(baseValue.Key))
{
result.BasicValues.Add(baseValue.Key, 0);
}
}
AddBaseValueVector(GcConstants.Classes.BASIC_ATTRIBUTES, json, result, result.Attributes);
foreach (string baseV in result.Attributes.Keys)
{
if (!Engine.GetPropertyManager().HasAttribute(baseV))
{
throw new MeException($"Class {result.Name} references unknown attribute {baseV}.");
}
}
foreach (BaseObject attribute in Engine.GetPropertyManager().Attributes.Values)
{
if (!result.Attributes.ContainsKey(attribute.Key))
{
result.Attributes.Add(attribute.Key, 0);
}
}
JToken[] skills = JsonUtils.GetValueOrDefault <JToken[]>(json, GcConstants.Classes.SKILLS, null);
if (skills != null)
{
foreach (JToken value in skills)
{
SkillTemplate skill = SkillFromJson(value, result);
result.Skills.Add(skill.Key, skill);
}
}
JToken baseAttack = JsonUtils.ValidateJsonEntry(GcConstants.Classes.BASE_ATTACK, json, JTokenType.String, $"Class {result.Name} does not contain a {GcConstants.Classes.BASE_ATTACK} entry.");
SkillTemplate baseSkill = SkillFromJson(baseAttack, result);
result.BaseAttack = baseSkill;
JToken[] resources = JsonUtils.GetValueOrDefault <JToken[]>(json, GcConstants.Classes.RESOURCES, null);
if (resources != null)
{
foreach (JToken value in resources)
{
ResourceTemplate res = ResourceFromJson(value, result);
result.Resources.Add(res.Key, res);
}
}
return(result);
}
private uint processPacket(byte[] msg, uint offset, uint ends, NetworkBuffer data, int chunkId)
{
var packet = new IIPPacket();
// packets++;
if (ready)
{
var rt = packet.Parse(msg, offset, ends);
//Console.WriteLine("Rec: " + chunkId + " " + packet.ToString());
/*
* if (packet.Command == IIPPacketCommand.Event)
* Console.WriteLine("Rec: " + packet.Command.ToString() + " " + packet.Event.ToString());
* else if (packet.Command == IIPPacketCommand.Report)
* Console.WriteLine("Rec: " + packet.Command.ToString() + " " + packet.Report.ToString());
* else
* Console.WriteLine("Rec: " + packet.Command.ToString() + " " + packet.Action.ToString() + " " + packet.ResourceId + " " + offset + "/" + ends);
*/
//packs.Add(packet.Command.ToString() + " " + packet.Action.ToString() + " " + packet.Event.ToString());
//if (packs.Count > 1)
// Console.WriteLine("P2");
if (rt <= 0)
{
var size = ends - offset;
data.HoldFor(msg, offset, size, size + (uint)(-rt));
return(ends);
}
else
{
offset += (uint)rt;
if (packet.Command == IIPPacket.IIPPacketCommand.Event)
{
switch (packet.Event)
{
case IIPPacket.IIPPacketEvent.ResourceReassigned:
IIPEventResourceReassigned(packet.ResourceId, packet.NewResourceId);
break;
case IIPPacket.IIPPacketEvent.ResourceDestroyed:
IIPEventResourceDestroyed(packet.ResourceId);
break;
case IIPPacket.IIPPacketEvent.PropertyUpdated:
IIPEventPropertyUpdated(packet.ResourceId, packet.MethodIndex, packet.Content);
break;
case IIPPacket.IIPPacketEvent.EventOccurred:
IIPEventEventOccurred(packet.ResourceId, packet.MethodIndex, packet.Content);
break;
case IIPPacketEvent.ChildAdded:
IIPEventChildAdded(packet.ResourceId, packet.ChildId);
break;
case IIPPacketEvent.ChildRemoved:
IIPEventChildRemoved(packet.ResourceId, packet.ChildId);
break;
case IIPPacketEvent.Renamed:
IIPEventRenamed(packet.ResourceId, packet.Content);
break;
case IIPPacketEvent.AttributesUpdated:
IIPEventAttributesUpdated(packet.ResourceId, packet.Content);
break;
}
}
else if (packet.Command == IIPPacket.IIPPacketCommand.Request)
{
switch (packet.Action)
{
// Manage
case IIPPacket.IIPPacketAction.AttachResource:
IIPRequestAttachResource(packet.CallbackId, packet.ResourceId);
break;
case IIPPacket.IIPPacketAction.ReattachResource:
IIPRequestReattachResource(packet.CallbackId, packet.ResourceId, packet.ResourceAge);
break;
case IIPPacket.IIPPacketAction.DetachResource:
IIPRequestDetachResource(packet.CallbackId, packet.ResourceId);
break;
case IIPPacket.IIPPacketAction.CreateResource:
IIPRequestCreateResource(packet.CallbackId, packet.StoreId, packet.ResourceId, packet.Content);
break;
case IIPPacket.IIPPacketAction.DeleteResource:
IIPRequestDeleteResource(packet.CallbackId, packet.ResourceId);
break;
case IIPPacketAction.AddChild:
IIPRequestAddChild(packet.CallbackId, packet.ResourceId, packet.ChildId);
break;
case IIPPacketAction.RemoveChild:
IIPRequestRemoveChild(packet.CallbackId, packet.ResourceId, packet.ChildId);
break;
case IIPPacketAction.RenameResource:
IIPRequestRenameResource(packet.CallbackId, packet.ResourceId, packet.Content);
break;
// Inquire
case IIPPacket.IIPPacketAction.TemplateFromClassName:
IIPRequestTemplateFromClassName(packet.CallbackId, packet.ClassName);
break;
case IIPPacket.IIPPacketAction.TemplateFromClassId:
IIPRequestTemplateFromClassId(packet.CallbackId, packet.ClassId);
break;
case IIPPacket.IIPPacketAction.TemplateFromResourceId:
IIPRequestTemplateFromResourceId(packet.CallbackId, packet.ResourceId);
break;
case IIPPacketAction.QueryLink:
IIPRequestQueryResources(packet.CallbackId, packet.ResourceLink);
break;
case IIPPacketAction.ResourceChildren:
IIPRequestResourceChildren(packet.CallbackId, packet.ResourceId);
break;
case IIPPacketAction.ResourceParents:
IIPRequestResourceParents(packet.CallbackId, packet.ResourceId);
break;
case IIPPacket.IIPPacketAction.ResourceHistory:
IIPRequestInquireResourceHistory(packet.CallbackId, packet.ResourceId, packet.FromDate, packet.ToDate);
break;
// Invoke
case IIPPacket.IIPPacketAction.InvokeFunction:
IIPRequestInvokeFunction(packet.CallbackId, packet.ResourceId, packet.MethodIndex, packet.Content);
break;
case IIPPacket.IIPPacketAction.GetProperty:
IIPRequestGetProperty(packet.CallbackId, packet.ResourceId, packet.MethodIndex);
break;
case IIPPacket.IIPPacketAction.GetPropertyIfModified:
IIPRequestGetPropertyIfModifiedSince(packet.CallbackId, packet.ResourceId, packet.MethodIndex, packet.ResourceAge);
break;
case IIPPacket.IIPPacketAction.SetProperty:
IIPRequestSetProperty(packet.CallbackId, packet.ResourceId, packet.MethodIndex, packet.Content);
break;
// Attribute
case IIPPacketAction.GetAllAttributes:
IIPRequestGetAttributes(packet.CallbackId, packet.ResourceId, packet.Content, true);
break;
case IIPPacketAction.UpdateAllAttributes:
IIPRequestUpdateAttributes(packet.CallbackId, packet.ResourceId, packet.Content, true);
break;
case IIPPacketAction.ClearAllAttributes:
IIPRequestClearAttributes(packet.CallbackId, packet.ResourceId, packet.Content, true);
break;
case IIPPacketAction.GetAttributes:
IIPRequestGetAttributes(packet.CallbackId, packet.ResourceId, packet.Content, false);
break;
case IIPPacketAction.UpdateAttributes:
IIPRequestUpdateAttributes(packet.CallbackId, packet.ResourceId, packet.Content, false);
break;
case IIPPacketAction.ClearAttributes:
IIPRequestClearAttributes(packet.CallbackId, packet.ResourceId, packet.Content, false);
break;
}
}
else if (packet.Command == IIPPacket.IIPPacketCommand.Reply)
{
switch (packet.Action)
{
// Manage
case IIPPacket.IIPPacketAction.AttachResource:
IIPReply(packet.CallbackId, packet.ClassId, packet.ResourceAge, packet.ResourceLink, packet.Content);
break;
case IIPPacket.IIPPacketAction.ReattachResource:
IIPReply(packet.CallbackId, packet.ResourceAge, packet.Content);
break;
case IIPPacket.IIPPacketAction.DetachResource:
IIPReply(packet.CallbackId);
break;
case IIPPacket.IIPPacketAction.CreateResource:
IIPReply(packet.CallbackId, packet.ResourceId);
break;
case IIPPacket.IIPPacketAction.DeleteResource:
case IIPPacketAction.AddChild:
case IIPPacketAction.RemoveChild:
case IIPPacketAction.RenameResource:
IIPReply(packet.CallbackId);
break;
// Inquire
case IIPPacket.IIPPacketAction.TemplateFromClassName:
case IIPPacket.IIPPacketAction.TemplateFromClassId:
case IIPPacket.IIPPacketAction.TemplateFromResourceId:
IIPReply(packet.CallbackId, ResourceTemplate.Parse(packet.Content));
break;
case IIPPacketAction.QueryLink:
case IIPPacketAction.ResourceChildren:
case IIPPacketAction.ResourceParents:
case IIPPacketAction.ResourceHistory:
IIPReply(packet.CallbackId, packet.Content);
break;
// Invoke
case IIPPacket.IIPPacketAction.InvokeFunction:
IIPReplyInvoke(packet.CallbackId, packet.Content);
break;
case IIPPacket.IIPPacketAction.GetProperty:
IIPReply(packet.CallbackId, packet.Content);
break;
case IIPPacket.IIPPacketAction.GetPropertyIfModified:
IIPReply(packet.CallbackId, packet.Content);
break;
case IIPPacket.IIPPacketAction.SetProperty:
IIPReply(packet.CallbackId);
break;
// Attribute
case IIPPacketAction.GetAllAttributes:
case IIPPacketAction.GetAttributes:
IIPReply(packet.CallbackId, packet.Content);
break;
case IIPPacketAction.UpdateAllAttributes:
case IIPPacketAction.UpdateAttributes:
case IIPPacketAction.ClearAllAttributes:
case IIPPacketAction.ClearAttributes:
IIPReply(packet.CallbackId);
break;
}
}
else if (packet.Command == IIPPacketCommand.Report)
{
switch (packet.Report)
{
case IIPPacketReport.ManagementError:
IIPReportError(packet.CallbackId, AsyncReply.ErrorType.Management, packet.ErrorCode, null);
break;
case IIPPacketReport.ExecutionError:
IIPReportError(packet.CallbackId, AsyncReply.ErrorType.Exception, packet.ErrorCode, packet.ErrorMessage);
break;
case IIPPacketReport.ProgressReport:
IIPReportProgress(packet.CallbackId, AsyncReply.ProgressType.Execution, packet.ProgressValue, packet.ProgressMax);
break;
case IIPPacketReport.ChunkStream:
IIPReportChunk(packet.CallbackId, packet.Content);
break;
}
}
}
}
else
{
var rt = authPacket.Parse(msg, offset, ends);
//Console.WriteLine(session.LocalAuthentication.Type.ToString() + " " + offset + " " + ends + " " + rt + " " + authPacket.ToString());
if (rt <= 0)
{
data.HoldFor(msg, ends + (uint)(-rt));
return(ends);
}
else
{
offset += (uint)rt;
if (session.LocalAuthentication.Type == AuthenticationType.Host)
{
if (authPacket.Command == IIPAuthPacket.IIPAuthPacketCommand.Declare)
{
if (authPacket.RemoteMethod == IIPAuthPacket.IIPAuthPacketMethod.Credentials && authPacket.LocalMethod == IIPAuthPacket.IIPAuthPacketMethod.None)
{
Server.Membership.UserExists(authPacket.RemoteUsername, authPacket.Domain).Then(x =>
{
if (x)
{
session.RemoteAuthentication.Username = authPacket.RemoteUsername;
remoteNonce = authPacket.RemoteNonce;
session.RemoteAuthentication.Domain = authPacket.Domain;
SendParams((byte)0xa0, localNonce);
}
else
{
//Console.WriteLine("User not found");
SendParams((byte)0xc0, (byte)1, (ushort)14, DC.ToBytes("User not found"));
}
});
}
}
else if (authPacket.Command == IIPAuthPacket.IIPAuthPacketCommand.Action)
{
if (authPacket.Action == IIPAuthPacket.IIPAuthPacketAction.AuthenticateHash)
{
var remoteHash = authPacket.Hash;
Server.Membership.GetPassword(session.RemoteAuthentication.Username,
session.RemoteAuthentication.Domain).Then((pw) =>
{
if (pw != null)
{
var hashFunc = SHA256.Create();
var hash = hashFunc.ComputeHash(BinaryList.ToBytes(pw, remoteNonce, localNonce));
if (hash.SequenceEqual(remoteHash))
{
// send our hash
var localHash = hashFunc.ComputeHash(BinaryList.ToBytes(localNonce, remoteNonce, pw));
SendParams((byte)0, localHash);
readyToEstablish = true;
}
else
{
Global.Log("auth", LogType.Warning, "U:" + RemoteUsername + " IP:" + Socket.RemoteEndPoint.Address.ToString() + " S:DENIED");
//Console.WriteLine("Incorrect password");
SendParams((byte)0xc0, (byte)1, (ushort)5, DC.ToBytes("Error"));
}
}
});
}
else if (authPacket.Action == IIPAuthPacket.IIPAuthPacketAction.NewConnection)
{
if (readyToEstablish)
{
var r = new Random();
session.Id = new byte[32];
r.NextBytes(session.Id);
SendParams((byte)0x28, session.Id);
ready = true;
OnReady?.Invoke(this);
Server.Membership.Login(session);
Global.Log("auth", LogType.Warning, "U:" + RemoteUsername + " IP:" + Socket.RemoteEndPoint.Address.ToString() + " S:AUTH");
}
}
}
}
else if (session.LocalAuthentication.Type == AuthenticationType.Client)
{
if (authPacket.Command == IIPAuthPacket.IIPAuthPacketCommand.Acknowledge)
{
remoteNonce = authPacket.RemoteNonce;
// send our hash
var hashFunc = SHA256.Create();
var localHash = hashFunc.ComputeHash(BinaryList.ToBytes(localPassword, localNonce, remoteNonce));
SendParams((byte)0, localHash);
}
else if (authPacket.Command == IIPAuthPacket.IIPAuthPacketCommand.Action)
{
if (authPacket.Action == IIPAuthPacket.IIPAuthPacketAction.AuthenticateHash)
{
// check if the server knows my password
var hashFunc = SHA256.Create();
var remoteHash = hashFunc.ComputeHash(BinaryList.ToBytes(remoteNonce, localNonce, localPassword));
if (remoteHash.SequenceEqual(authPacket.Hash))
{
// send establish request
SendParams((byte)0x20, (ushort)0);
}
else
{
SendParams((byte)0xc0, 1, (ushort)5, DC.ToBytes("Error"));
}
}
else if (authPacket.Action == IIPAuthPacket.IIPAuthPacketAction.ConnectionEstablished)
{
session.Id = authPacket.SessionId;
ready = true;
OnReady?.Invoke(this);
}
}
else if (authPacket.Command == IIPAuthPacket.IIPAuthPacketCommand.Error)
{
OnError?.Invoke(this, authPacket.ErrorCode, authPacket.ErrorMessage);
Close();
}
}
}
}
return(offset);
//if (offset < ends)
// processPacket(msg, offset, ends, data, chunkId);
}
