// example based on the MSDN Events Sample (events1.cs)
public static void GenEvents1(AssemblyGen ag)
{
TypeGen ChangedEventHandler, ListWithChangedEvent;
using (ag.Namespace("MyCollections"))
{
// A delegate type for hooking up change notifications.
ChangedEventHandler = ag.Delegate(typeof(void), "ChangedEventHandler").Parameter(typeof(object), "sender").Parameter(typeof(EventArgs), "e");
// A class that works just like ArrayList, but sends event
// notifications whenever the list changes.
ListWithChangedEvent = ag.Public.Class("ListWithChangedEvent", typeof(ArrayList));
{
// An event that clients can use to be notified whenever the
// elements of the list change.
EventGen Changed = ListWithChangedEvent.Public.Event(ChangedEventHandler, "Changed");
// Invoke the Changed event; called whenever list changes
CodeGen g = ListWithChangedEvent.Protected.Virtual.Method(typeof(void), "OnChanged").Parameter(typeof(EventArgs), "e");
{
g.If(Changed != null);
{
g.InvokeDelegate(Changed, g.This(), g.Arg("e"));
}
g.End();
}
// Override some of the methods that can change the list;
// invoke event after each
g = ListWithChangedEvent.Public.Override.Method(typeof(int), "Add").Parameter(typeof(object), "value");
{
Operand i = g.Local(g.Base().Invoke("Add", g.Arg("value")));
g.Invoke(g.This(), "OnChanged", Static.Field(typeof(EventArgs), "Empty"));
g.Return(i);
}
g = ListWithChangedEvent.Public.Override.Method(typeof(void), "Clear");
{
g.Invoke(g.Base(), "Clear");
g.Invoke(g.This(), "OnChanged", Static.Field(typeof(EventArgs), "Empty"));
}
g = ListWithChangedEvent.Public.Override.Indexer(typeof(object)).Index(typeof(int), "index").Setter();
{
g.Assign(g.Base()[g.Arg("index")], g.PropertyValue());
g.Invoke(g.This(), "OnChanged", Static.Field(typeof(EventArgs), "Empty"));
}
}
}
using (ag.Namespace("TestEvents"))
{
TypeGen EventListener = ag.Class("EventListener");
{
FieldGen List = EventListener.Field(ListWithChangedEvent, "List");
// This will be called whenever the list changes.
CodeGen g = EventListener.Private.Method(typeof(void), "ListChanged").Parameter(typeof(object), "sender").Parameter(typeof(EventArgs), "eventArgs");
{
g.WriteLine("This is called when the event fires.");
}
g = EventListener.Public.Constructor().Parameter(ListWithChangedEvent, "list");
{
g.Assign(List, g.Arg("list"));
// Add "ListChanged" to the Changed event on "List".
g.SubscribeEvent(List, "Changed", Exp.NewDelegate(ChangedEventHandler, g.This(), "ListChanged"));
}
g = EventListener.Public.Method(typeof(void), "Detach");
{
// Detach the event and delete the list
g.UnsubscribeEvent(List, "Changed", Exp.NewDelegate(ChangedEventHandler, g.This(), "ListChanged"));
g.Assign(List, null);
}
}
TypeGen Test = ag.Class("Test");
{
// Test the ListWithChangedEvent class.
CodeGen g = Test.Public.Static.Method(typeof(void), "Main");
{
// Create a new list.
Operand list = g.Local(Exp.New(ListWithChangedEvent));
// Create a class that listens to the list's change event.
Operand listener = g.Local(Exp.New(EventListener, list));
// Add and remove items from the list.
g.Invoke(list, "Add", "item 1");
g.Invoke(list, "Clear");
g.Invoke(listener, "Detach");
}
}
}
}
/// <summary>
/// Iterate over all loaded mods and emit new types
/// </summary>
void Awake()
{
// Generate overloaded PQSMod types
AssemblyGen assembly = new AssemblyGen(Guid.NewGuid().ToString(),
new CompilerOptions {
OutputPath = Path.GetTempFileName()
});
List <Type> modTypes = GetModTypes();
foreach (Type modType in modTypes)
{
if (typeof(PQSMod).IsAssignableFrom(modType))
{
// Get the ModLoader type we want to extend
Type loaderType = modTypes.FirstOrDefault(t =>
t.BaseType != null && t.BaseType.FullName != null &&
t.BaseType.FullName.StartsWith("Kopernicus.Configuration.ModLoader.ModLoader") &&
t.BaseType.GetGenericArguments()[0] == modType);
if (loaderType == null)
{
continue;
}
// Generate the Mod Type
TypeGen modGen = assembly.Public.Class($"{modType.Name}Regional", modType);
{
FieldGen multiplierMap = modGen.Public.Field(typeof(MapSO), "multiplierMap");
FieldGen splitChannels = modGen.Public.Field(typeof(Boolean), "splitChannels");
FieldGen multiplier = modGen.Private.Field(typeof(Color), "multiplier");
FieldGen preBuildColor = modGen.Private.Field(typeof(Color), "preBuildColor");
FieldGen preBuildHeight = modGen.Private.Field(typeof(Double), "preBuildHeight");
// OnVertexBuildHeight
CodeGen onVertexBuild = modGen.Public.Override.Method(typeof(void), "OnVertexBuild")
.Parameter(typeof(PQS.VertexBuildData), "data");
{
ContextualOperand data = onVertexBuild.Arg("data");
onVertexBuild.Assign(multiplier, onVertexBuild.Local(multiplierMap.Invoke(
"GetPixelColor", new TypeMapper(),
data.Field("u"), data.Field("v"))));
onVertexBuild.If(!splitChannels);
{
onVertexBuild.Assign(multiplier.Field("a", new TypeMapper()),
multiplier.Field("r", new TypeMapper()));
}
onVertexBuild.End();
onVertexBuild.Assign(preBuildColor, data.Field("vertColor"));
onVertexBuild.Assign(preBuildHeight, data.Field("vertHeight"));
onVertexBuild.Invoke(onVertexBuild.Base(), "OnVertexBuild", data);
onVertexBuild.Assign(data.Field("vertColor"),
assembly.StaticFactory.Invoke(typeof(Color), "Lerp", preBuildColor,
data.Field("vertColor"), multiplier.Field("a", new TypeMapper())));
onVertexBuild.Assign(data.Field("vertHeight"),
assembly.StaticFactory.Invoke(typeof(UtilMath), "Lerp", preBuildHeight,
data.Field("vertHeight"), multiplier.Field("r", new TypeMapper())));
}
// OnVertexBuildHeight
CodeGen onVertexBuildHeight = modGen.Public.Override.Method(typeof(void), "OnVertexBuildHeight")
.Parameter(typeof(PQS.VertexBuildData), "data");
{
ContextualOperand data = onVertexBuildHeight.Arg("data");
onVertexBuildHeight.Assign(multiplier, onVertexBuildHeight.Local(multiplierMap.Invoke(
"GetPixelColor", new TypeMapper(),
data.Field("u"), data.Field("v"))));
onVertexBuildHeight.If(!splitChannels);
{
onVertexBuildHeight.Assign(multiplier.Field("a", new TypeMapper()),
multiplier.Field("r", new TypeMapper()));
}
onVertexBuildHeight.End();
onVertexBuildHeight.Assign(preBuildColor, data.Field("vertColor"));
onVertexBuildHeight.Assign(preBuildHeight, data.Field("vertHeight"));
onVertexBuildHeight.Invoke(onVertexBuildHeight.Base(), "OnVertexBuildHeight", data);
onVertexBuildHeight.Assign(data.Field("vertColor"),
assembly.StaticFactory.Invoke(typeof(Color), "Lerp", preBuildColor,
data.Field("vertColor"), multiplier.Field("a", new TypeMapper())));
onVertexBuildHeight.Assign(data.Field("vertHeight"),
assembly.StaticFactory.Invoke(typeof(UtilMath), "Lerp", preBuildHeight,
data.Field("vertHeight"), multiplier.Field("r", new TypeMapper())));
}
}
// Generate the Loader Type
Type modLoader = typeof(ModLoader <>).MakeGenericType(modGen);
TypeGen loaderGen =
assembly.Public.Class($"{modType.Name.Replace("PQSMod_", "").Replace("PQS", "")}Regional",
modLoader);
{
PropertyGen multiplierMap = loaderGen.Public.Property(typeof(MapSOParserRGB <MapSO>), "multiplierMap")
.Attribute(typeof(ParserTarget), "multiplierMap");
{
CodeGen getter = multiplierMap.Getter();
{
getter.Return(getter.Base().Property("Mod").Field("multiplierMap"));
}
CodeGen setter = multiplierMap.Setter();
{
setter.Assign(setter.Base().Property("Mod").Field("multiplierMap"),
setter.PropertyValue());
}
}
PropertyGen splitChannels = loaderGen.Public.Property(typeof(NumericParser <Boolean>), "splitChannels")
.Attribute(typeof(ParserTarget), "splitChannels");
{
CodeGen getter = splitChannels.Getter();
{
getter.Return(getter.Base().Property("Mod").Field("splitChannels"));
}
CodeGen setter = splitChannels.Setter();
{
setter.Assign(setter.Base().Property("Mod").Field("splitChannels"),
setter.PropertyValue());
}
}
FieldGen loader = loaderGen.Public.Field(loaderType, "loader")
.BeginAttribute(typeof(ParserTarget), "Mod").SetField("AllowMerge", true).End();
CodeGen create_PQS = loaderGen.Public.Override.Method(typeof(void), "Create")
.Parameter(typeof(PQS), "pqsVersion");
{
ContextualOperand pqsVersion = create_PQS.Arg("pqsVersion");
create_PQS.Invoke(create_PQS.Base(), "Create", pqsVersion);
create_PQS.Assign(loader, assembly.ExpressionFactory.New(loaderType));
create_PQS.Invoke(loader, "Create", create_PQS.Base().Property("Mod"), pqsVersion);
}
CodeGen create_Mod_PQS = loaderGen.Public.Override.Method(typeof(void), "Create")
.Parameter(modGen, "_mod")
.Parameter(typeof(PQS), "pqsVersion");
{
ContextualOperand _mod = create_Mod_PQS.Arg("_mod");
ContextualOperand pqsVersion = create_Mod_PQS.Arg("pqsVersion");
create_Mod_PQS.Invoke(create_Mod_PQS.Base(), "Create", _mod, pqsVersion);
create_Mod_PQS.Assign(loader, assembly.ExpressionFactory.New(loaderType));
create_Mod_PQS.Invoke(loader, "Create", create_Mod_PQS.Base().Property("Mod"), pqsVersion);
}
}
}
}
assembly.Save();
// Hacking into my own mod. Oh well.
modTypes.AddRange(assembly.GetAssembly().GetTypes());
typeof(Parser).GetField("_modTypes", BindingFlags.NonPublic | BindingFlags.Static)
?.SetValue(null, modTypes);
}
