public static USharpPathAttribute GetManagedPathAttribute(Type type)
{
USharpPathAttribute attribute;
Managed.TryGetValue(type, out attribute);
return(attribute);
}
public ResourceFileItem(uint type, Managed resource)
{
this.type = type;
this.resource = resource;
this.resource.PropertyChanged += this.OnPropertyChanged;
this.resource.PropertyChanging += this.OnPropertyChanging;
}
protected override void OnSubModuleLoad()
{
try
{
base.OnSubModuleLoad();
var harmony = new Harmony("BannerlordCheats");
harmony.PatchAll();
}
catch (Exception e)
{
try
{
var errorFileName = $"Error-{DateTime.Now:yyyy-MM-dd-HH-mm-ss}.txt";
SubModule.ErrorFile = errorFileName;
var errorFilePath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), errorFileName);
var errorMessage = new StringBuilder();
errorMessage.AppendLine("Installed Modules:");
errorMessage.AppendLine(Managed.GetModulesVersionStr());
errorMessage.AppendLine("Exception Message:");
errorMessage.AppendLine(e.ToString());
File.WriteAllText(errorFilePath, errorMessage.ToString());
}
catch { }
}
}
public override int GetHashCode()
{
unchecked
{
return((WorkingSetPrivate.GetHashCode() * 397) ^ Managed.GetHashCode());
}
}
private void ConvertProviders(Provider provider, Managed.Database.Provider newProvider)
{
newProvider.Name = provider.Name;
newProvider.Description = provider.Description;
newProvider.Web = provider.Web;
newProvider.Pinned = provider.Pinned;
foreach (var media in provider.Medias) {
var stream = new Stream { Name = media.Name, Description = media.Description, Web = media.Web, ChatEmbed = media.ChatEmbed, StreamGuid = media.StreamGuid, StreamEmbed = media.StreamEmbed, Tags = media.Tags, Size = media.Size };
foreach (var newEmbedData in media.ChatEmbedData.Select(embedData => new StreamDeskProperty { Name = embedData.Name, Value = embedData.Value }))
{
stream.ChatEmbedData.Add(newEmbedData);
}
foreach (var newEmbedData in media.StreamEmbedData.Select(embedData => new StreamDeskProperty { Name = embedData.Name, Value = embedData.Value }))
{
stream.StreamEmbedData.Add(newEmbedData);
}
newProvider.Streams.Add(stream);
}
foreach (var subProvider in provider.SubProviders)
{
var newSubProvider = new Managed.Database.Provider();
ConvertProviders(subProvider, newSubProvider);
newProvider.SubProviders.Add(newSubProvider);
}
}
protected override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
Hashtable requestParameters = new Hashtable()
{
{ "SolutionName", SolutionManagementHelper.GetSolutionUniqueName(_repository, Id, false) },
{ "ExportAutoNumberingSettings", AutoNumberingSettings.ToBool() },
{ "ExportCalendarSettings", CalendarSettings.ToBool() },
{ "ExportCustomizationSettings", CustomizationSettings.ToBool() },
{ "ExportEmailTrackingSettings", EmailTrackingSettings.ToBool() },
{ "ExportGeneralSettings", GeneralSettings.ToBool() },
{ "ExportIsvConfig", IsvConfig.ToBool() },
{ "ExportMarketingSettings", MarketingSettings.ToBool() },
{ "ExportOutlookSynchronizationSettings", OutlookSynchronizationSettings.ToBool() },
{ "ExportRelationshipRoles", RelationshipRoles.ToBool() },
{ "Managed", Managed.ToBool() }
};
if (_context != null)
{
_context.SetParametersOnRequest(requestParameters);
}
OrganizationResponse response = _repository.Execute("ExportSolution", requestParameters);
File.WriteAllBytes(Path, (byte[])response.Results["ExportSolutionFile"]);
}
public unsafe static void Run()
{
Managed inst = new Managed()
{
mCount = 5,
mName = "NoNo"
};
fixed(int *pValue = &inst.mCount)
{
*pValue = 7;
}
Console.Write(inst.mCount + " ");
fixed(char *pChar = inst.mName.ToCharArray())
{
int length = inst.mName.Length;
for (int i = 0; i < length; i++)
{
Console.Write(*(pChar + i));
}
}
Console.WriteLine();
}
internal static int GetTypeOfField(string className, string fieldName)
{
FieldInfo fieldOfClass = Managed.GetFieldOfClass(className, fieldName);
if (fieldOfClass == (FieldInfo)null)
{
return(-1);
}
System.Type fieldType = fieldOfClass.FieldType;
if (fieldOfClass.FieldType == typeof(string))
{
return(0);
}
if (fieldOfClass.FieldType == typeof(double))
{
return(1);
}
if (fieldOfClass.FieldType.IsEnum)
{
return(9);
}
if (fieldOfClass.FieldType == typeof(float))
{
return(2);
}
if (fieldOfClass.FieldType == typeof(bool))
{
return(3);
}
if (fieldType == typeof(byte) || fieldType == typeof(sbyte) || (fieldType == typeof(short) || fieldType == typeof(ushort)) || (fieldType == typeof(int) || fieldType == typeof(uint) || (fieldType == typeof(long) || fieldType == typeof(ulong))))
{
return(4);
}
if (fieldOfClass.FieldType == typeof(Vec3))
{
return(5);
}
if (fieldOfClass.FieldType == typeof(GameEntity))
{
return(6);
}
if (fieldOfClass.FieldType == typeof(Texture))
{
return(7);
}
if (fieldOfClass.FieldType == typeof(MetaMesh))
{
return(8);
}
if (fieldOfClass.FieldType == typeof(Material))
{
return(10);
}
if (fieldOfClass.FieldType == typeof(SimpleButton))
{
return(11);
}
return(fieldOfClass.FieldType == typeof(MatrixFrame) ? 13 : -1);
}
// public override string ToString()
// {
// return
// string.Format("int: {0}{1}object: {2}",
// i, Environment.NewLine, obj);
// }
// public unsafe static string Manipulate ()
// {
// string result = string.Empty;;
// Managed managed = new Managed();
// Managed* managed_ptr = &managed;
// //result = managed_ptr->ToString();
// return result;
// }
// unsafe static void Main ()
// {
// string result = string.Empty;;
// Managed managed = new Managed(10, "test");
// Managed* managed_ptr = &managed;
// //result = managed_ptr->ToString();
// return result;
// }
unsafe static void Main ()
{
Managed managed = new Managed(10, new Info());
Managed* managed_ptr = &managed;
Console.WriteLine (managed_ptr->i);
}
public static IEvent Add <T>(T _target, Condition _cond, Handler <T> _handler, int _fireCount, uint _priority, string _desc, string _id = null)
{
var id = _id ?? GenID();
var mEvt = Managed <T> .Create(_cond, _handler, _target, _fireCount, _desc, id);
Manage(mEvt, _priority);
return(mEvt);
}
/// <summary>
/// Parse text block.
/// </summary>
public virtual void Serialize(TextSerializer parser, Managed managed)
{
parser.WriteAttribute(ClassName);
parser.OpenBlock();
this.SerializeContent(parser,managed);
parser.CloseBlock();
}
static void Main(string[] args)
{
Managed m = new Managed();
Console.WriteLine(m.PrivateSetter);
m.Mgr.SetProperty("lol");
Console.WriteLine(m.PrivateSetter);
Console.Read();
}
public Point GetWindowCenter()
{
Point windowCenter = new Point();
Managed.RECT windowRect = new Managed.RECT();
Managed.GetWindowRect(procHwnd, out windowRect);
windowCenter.X = windowRect.left + ((windowRect.right - windowRect.left) / 2);
windowCenter.Y = windowRect.top + ((windowRect.bottom - windowRect.top) / 2);
return(windowCenter);
}
static void Wrapper()
{
Console.WriteLine(" Managed wrapper for native DLL ");
Console.WriteLine();
Mixedtest = new Managed();
Mixedtest.ValueChanged += new ValueChangedHandler(EventHandler);
Mixedtest.PropMixedCpp1 = 111;
Console.WriteLine("Свойство PropManagedCpp1 установлено в: " + Mixedtest.PropMixedCpp1);
Mixedtest.MethodMixedCpp1(5);
Console.WriteLine("=====================================================");
}
public bool IsProcessInForeground()
{
if (procHwnd == Managed.GetForegroundWindow())
{
return(true);
}
else
{
return(false);
}
}
private void ConvertEmbeds(StreamDeskDatabase currentDb, Managed.Database.StreamDeskDatabase newDb)
{
foreach (var chatEmbedNew in currentDb.ChatEmbeds.Select(chatEmbed => new Managed.Database.ChatEmbed { EmbedFormat = chatEmbed.EmbedFormat, FriendlyName = chatEmbed.FriendlyName, IrcServer = chatEmbed.IrcServer, Name = chatEmbed.Name }))
{
newDb.ChatEmbeds.Add(chatEmbedNew);
}
foreach (var streamEmbedNew in currentDb.StreamEmbeds.Select(streamEmbed => new Managed.Database.StreamEmbed() { EmbedFormat = streamEmbed.EmbedFormat, FriendlyName = streamEmbed.FriendlyName, Name = streamEmbed.Name }))
{
newDb.StreamEmbeds.Add(streamEmbedNew);
}
}
private void OverlayTheForm()
{
Managed.SetWindowLong(this.Handle, Managed.GWL_STYLE, Managed.WS_VISIBLE | Managed.WS_POPUP | Managed.WS_MAXIMIZE);
Managed.SetWindowLong(this.Handle, Managed.GWL_EXSTYLE, Managed.GetWindowLong(this.Handle, Managed.GWL_EXSTYLE) | Managed.WS_EX_LAYERED | Managed.WS_EX_TRANSPARENT);
Managed.Margins margins;
margins.cxLeftWidth = 0;
margins.cxRightWidth = this.Width;
margins.cyTopHeight = 0;
margins.cyBottomHeight = this.Height;
Managed.DwmExtendFrameIntoClientArea(this.Handle, ref margins);
}
public bool IsProcessRunning()
{
procHwnd = Managed.FindWindow(null, processWindowName);
if (procHwnd != IntPtr.Zero)
{
return(true);
}
else
{
return(false);
}
}
void IManagedComponent.OnStart()
{
Debug.DebugManager = (IDebugManager) new MBDebugManager();
FaceGen.CreateInstance();
Dictionary <string, Type> dictionary1 = new Dictionary <string, Type>();
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
Dictionary <string, Type> dictionary2 = this.CollectModuleAssemblyTypes(assembly);
dictionary1 = dictionary1.Union <KeyValuePair <string, Type> >((IEnumerable <KeyValuePair <string, Type> >)dictionary2).ToDictionary <KeyValuePair <string, Type>, string, Type>((Func <KeyValuePair <string, Type>, string>)(k => k.Key), (Func <KeyValuePair <string, Type>, Type>)(v => v.Value));
}
Managed.InitializeTypes(dictionary1);
}
protected override void OnSubModuleLoad()
{
SyncObject = (SyncObjectV1)Module.CurrentModule.GetInitialStateOptionWithId(SyncObjectV1.SyncId);
if (SyncObject == null) // This is the first mod to initialize MBOptionScreen
{
try
{
new Harmony("bannerlord.mboptionscreen").PatchAll(typeof(MBOptionScreenSubModule).Assembly);
}
catch (Exception ex)
{
// TODO
}
// Find the latest implementation among loaded mods
// as the game seems to be able to load multiple versions of an
// assembly if it has a strong name
var version = ApplicationVersionParser.TryParse(Managed.GetVersionStr(), out var v) ? v : default;
var modOptionsGauntletScreenType = AttributeHelper.Get <ModuleOptionVersionAttribute>(version);
var fileStorageType = AttributeHelper.Get <FileStorageVersionAttribute>(version);
var settingsStorageType = AttributeHelper.Get <SettingsStorageVersionAttribute>(version);
SyncObject = new SyncObjectV1
{
FileStorage = (IFileStorage)Activator.CreateInstance(fileStorageType.Type),
SettingsStorage = (ISettingsStorage)Activator.CreateInstance(settingsStorageType.Type),
ModOptionScreen = modOptionsGauntletScreenType.Type
};
Module.CurrentModule.AddInitialStateOption(SyncObject); // Workaround
Module.CurrentModule.AddInitialStateOption(new InitialStateOption("ModOptionsMenu", new TextObject("{=HiZbHGvYG}Mod Options"), 9990, () =>
{
var screen = (ScreenBase)Activator.CreateInstance(SyncObject.ModOptionScreen);
ScreenManager.PushScreen(screen);
}, false));
FileDatabase.FileDatabase.Initialize("ModOptions");
}
var settingsEnumerable = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(a => a.DefinedTypes)
.Where(t => !t.IsAbstract && t.IsSubclassOf(typeof(SettingsBase)) && t != typeof(Settings));
foreach (var settings in settingsEnumerable)
{
SettingsDatabase.RegisterSettings((SettingsBase)Activator.CreateInstance(settings));
}
}
public static void Clear()
{
gatheredUnrealTypes = false;
Assemblies.Clear();
AssembliesManagedTypes.Clear();
AssembliesNativeTypes.Clear();
AssemblySerializedModuleInfo.Clear();
processedAssemblies.Clear();
All.Clear();
Managed.Clear();
Native.Clear();
AllByPath.Clear();
ManagedByPath.Clear();
NativeByPath.Clear();
}
static void Main(string[] args)
{
Console.WriteLine("Unmanaged Test");
IntPtr pointer = GetUnmanagedStruct();
Console.WriteLine(string.Format("Unmanaged Struct: 0x{0:X}", pointer.ToInt64()));
//int managed = pointer.MapTo<int>();
Managed managed = pointer.MapTo <Managed>();
Console.Write(JsonConvert.SerializeObject(managed, Formatting.Indented));
Console.ReadKey();
}
public static IEvent Create(Condition _condition, Handler <IEvent> _action, int _fireCount, string _description, string _id)
{
var evt = new Managed <IEvent>
{
m_Condition = _condition,
m_Handler = _action,
FireCount = _fireCount,
Description = _description,
ID = _id,
Enabled = true
};
evt.m_Target = evt;
return(evt);
}
public static void ReadFromLocal()
{
// alustukset
Managed mapper = new Managed();
JKWriter writer = new JKWriter(mapper);
Entry entry = new Entry(EntryType.Information, "Terve 4!");
// kirjoitetaan tietue
writer.WriteEntry(entry);
// annetaan instanssi readerille
using (JKReader reader = new JKReader(mapper))
{
// loopataan lukijassa olevat tietueet
foreach (IEntry e in reader)
{
Console.WriteLine(e.Message);
}
}
}
protected override void Execute(CodeActivityContext context)
{
CrmConnection connection = CrmConnection.Parse(CrmConnectionString.Get(context));
using (OrganizationService orgService = new OrganizationService(connection))
{
Common.ExportSolution export = new Common.ExportSolution(orgService);
OutputFile.Set(context, export.Export(Managed.Get(context),
OutputFolder.Get(context),
UniqueSolutionName.Get(context),
ExportAutoNumberingSettings.Get(context),
ExportCalendarSettings.Get(context),
ExportCustomizationSettings.Get(context),
ExportEmailTrackingSettings.Get(context),
ExportGeneralSettings.Get(context),
ExportIsvConfig.Get(context),
ExportMarketingSettings.Get(context),
ExportOutlookSynchronizationSettings.Get(context),
ExportRelationshipRoles.Get(context)));
}
}
/**
* Constructor.
* Generates an instance of <code>MarketItem</code> from a <code>JSONObject</code>.
*
* @param jsonObject a <code>JSONObject</code> representation of the wanted
* <code>MarketItem</code>.
* @throws JSONException
*/
public MarketItem(JSONObject jsonObject)
{
//MarketItem miDeserialized = Newtonsoft.Json.JsonConvert.DeserializeObject<MarketItem>(jsonObject.ToString());
if (jsonObject.HasField(StoreJSONConsts.MARKETITEM_MANAGED))
{
int isManaged = (int)jsonObject[StoreJSONConsts.MARKETITEM_MANAGED].n;
SoomlaUtils.LogDebug(TAG, isManaged.ToString());
if (isManaged == 0)
{
this.mManaged = Managed.MANAGED;
}
else
{
this.mManaged = Managed.UNMANAGED;
}
}
else
{
this.mManaged = Managed.UNMANAGED;
}
if (jsonObject.HasField(StoreJSONConsts.MARKETITEM_PRODUCT_ID))
{
this.mProductId = jsonObject[StoreJSONConsts.MARKETITEM_PRODUCT_ID].str;
}
else
{
SoomlaUtils.LogError(TAG, "Market Item No Product ID");
}
this.mPrice = (double)jsonObject[StoreJSONConsts.MARKETITEM_PRICE].n;
this.mMarketPriceAndCurrency = jsonObject[StoreJSONConsts.MARKETITEM_MARKETPRICE].str;
this.mMarketTitle = jsonObject[StoreJSONConsts.MARKETITEM_MARKETTITLE].str;
this.mMarketDescription = jsonObject[StoreJSONConsts.MARKETITEM_MARKETDESC].str;
this.mMarketCurrencyCode = jsonObject[StoreJSONConsts.MARKETITEM_MARKETCURRENCYCODE].str;
this.mMarketPriceMicros = (long)jsonObject[StoreJSONConsts.MARKETITEM_MARKETPRICEMICROS].n;
}
private static void _forward_mono_CreateEntity(EntityComponentStore *entityComponentStore, void *archetype, Entity *outEntities, int count)
{
Managed._bfp_CreateEntity((IntPtr)entityComponentStore, (IntPtr)archetype, (IntPtr)outEntities, count);
}
private static void _forward_mono_SetChunkComponent(EntityComponentStore *entityComponentStore, ArchetypeChunk *chunks, int chunkCount, void *componentData, int componentTypeIndex)
{
Managed._bfp_SetChunkComponent((IntPtr)entityComponentStore, (IntPtr)chunks, chunkCount, (IntPtr)componentData, componentTypeIndex);
}
private static void _forward_mono_MoveEntityArchetype(EntityComponentStore *entityComponentStore, Entity *entity, void *dstArchetype)
{
Managed._bfp_MoveEntityArchetype((IntPtr)entityComponentStore, (IntPtr)entity, (IntPtr)dstArchetype);
}
private void SubscribeOnNameChange(Managed item)
{
item.PropertyChanged += this.ItemPropertyChanged;
item.PropertyChanging += this.ItemPropertyChanging;
}
private void UnsubscribeOnNameChange(Managed item)
{
item.PropertyChanged -= this.ItemPropertyChanged;
item.PropertyChanging -= this.ItemPropertyChanging;
}
/// <summary>
/// Parse text block.
/// </summary>
public override void SerializeContent(TextSerializer parser, Managed managed)
{
base.SerializeContent(parser, managed);
var variables = (Model)managed;
int i = 1;
foreach (var mesh in variables.Meshes)
{
parser.WriteAttribute("CMesh");
parser.OpenBlock();
parser.WriteAttribute("name");
parser.WriteStringValue(mesh.Name,"mesh"+i);
parser.WriteAttribute("scale");
parser.WriteFloatValue(1);
if (mesh.IsVertexStreamAvailable)
{
parser.WriteAttribute("CVerts");
parser.OpenBlock();
parser.WriteAttribute("numVerts");
parser.WriteIntValue(mesh.Vertices.Count);
foreach (var vector3 in mesh.Vertices)
{
parser.WriteAttribute("v");
parser.WriteRaw(" {");
parser.WriteFloatValue(vector3.X);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.Y);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.Z);
parser.WriteRaw(" }");
}
parser.CloseBlock();
}
if (mesh.IsNormalStreamAvailable)
{
parser.WriteAttribute("CVertNorms");
parser.OpenBlock();
parser.WriteAttribute("numVertNorms");
parser.WriteIntValue(mesh.Normals.Count);
foreach (var vector3 in mesh.Normals)
{
parser.WriteAttribute("vn");
parser.WriteRaw(" {");
parser.WriteFloatValue(vector3.X);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.Y);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.Z);
parser.WriteRaw(" }");
}
parser.CloseBlock();
}
if (mesh.IsColorStreamAvailable)
{
parser.WriteAttribute("CVertCols");
parser.OpenBlock();
parser.WriteAttribute("numVertCols");
parser.WriteIntValue(mesh.Colors.Count);
foreach (var vector3 in mesh.Colors)
{
parser.WriteAttribute("col");
parser.WriteRaw(" {");
parser.WriteFloatValue(vector3.R / 255.0f);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.G / 255.0f);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.B / 255.0f);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.A/255.0f);
parser.WriteRaw(" }");
}
parser.CloseBlock();
}
if (mesh.IsUV0StreamAvailable)
{
parser.WriteAttribute("CUVs");
parser.OpenBlock();
parser.WriteAttribute("setID");
parser.WriteIntValue(0);
parser.WriteAttribute("numUVs");
parser.WriteIntValue(mesh.UV0.Count);
foreach (var vector3 in mesh.UV0)
{
parser.WriteAttribute("uv");
parser.WriteRaw(" {");
parser.WriteFloatValue(vector3.X);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.Y);
parser.WriteRaw(" }");
}
parser.CloseBlock();
}
if (mesh.IsUV1StreamAvailable)
{
parser.WriteAttribute("CUVs");
parser.OpenBlock();
parser.WriteAttribute("setID");
parser.WriteIntValue(1);
parser.WriteAttribute("numUVs");
parser.WriteIntValue(mesh.UV1.Count);
foreach (var vector3 in mesh.UV1)
{
parser.WriteAttribute("uv");
parser.WriteRaw(" {");
parser.WriteFloatValue(vector3.X);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.Y);
parser.WriteRaw(" }");
}
parser.CloseBlock();
}
foreach (var surface in mesh.Surfaces)
{
parser.WriteAttribute("CSurface");
parser.OpenBlock();
parser.WriteAttribute("material");
parser.WriteStringValue(surface.Material.NameReference,"noskin");
switch (surface.VertexSourceType)
{
case VertexSourceType.TriangleList:
WriteTriList(parser, surface, mesh);
break;
//case VertexSourceType.TrianleStrip:
// break;
//case VertexSourceType.QuadList:
// break;
//case VertexSourceType.QuadStrip:
// break;
//case VertexSourceType.LineLine:
// break;
//case VertexSourceType.LineStrip:
// break;
default:
throw new ArgumentOutOfRangeException();
}
WriteTriList(parser, surface, mesh);
parser.CloseBlock();
}
parser.CloseBlock();
++i;
}
}
private String mProductId; //id of this VirtualGood in the market
#endregion Fields
#region Constructors
/**
* Constructor.
*
* @param mProductId the id of the current item in the market
* @param mManaged the Managed type of the current item in the market
* @param mPrice the actual $$ cost of the current item in the market
*/
public MarketItem(String mProductId, Managed mManaged, double mPrice)
{
this.mProductId = mProductId;
this.mManaged = mManaged;
this.mPrice = mPrice;
}
public void setManaged(Managed managed)
{
this.mManaged = managed;
}
/// <summary>
/// Parse text block.
/// </summary>
public virtual void SerializeContent(TextSerializer parser, Managed managed)
{
parser.WriteAttribute("name");
parser.WriteStringValue(managed.Name);
}
static void Wrapper()
{
Console.WriteLine(" Managed wrapper for native DLL ");
Console.WriteLine();
Mixedtest = new Managed();
Mixedtest.ValueChanged += new ValueChangedHandler(EventHandler);
Mixedtest.PropMixedCpp1 = 111;
Console.WriteLine("Свойство PropManagedCpp1 установлено в: " + Mixedtest.PropMixedCpp1);
Mixedtest.MethodMixedCpp1(5);
Console.WriteLine("=====================================================");
}
public void Write(System.IO.FileStream file, Managed.Database.StreamDeskDatabase streamDeskDatabase)
{
}
private static void _forward_mono_DestroyEntity(EntityComponentStore *entityComponentStore, Entity *entities, int count)
{
Managed._bfp_DestroyEntity((IntPtr)entityComponentStore, (IntPtr)entities, count);
}
private static void _forward_mono_InstantiateEntities(EntityComponentStore *entityComponentStore, Entity *srcEntity, Entity *outputEntities, int instanceCount)
{
Managed._bfp_InstantiateEntities((IntPtr)entityComponentStore, (IntPtr)srcEntity, (IntPtr)outputEntities, instanceCount);
}
private static void _forward_mono_RemoveComponentsEntitiesBatch(EntityComponentStore *entityComponentStore, Unity.Collections.LowLevel.Unsafe.UnsafeList *entityBatchList, ref ComponentTypes types)
{
Managed._bfp_RemoveComponentsEntitiesBatch((IntPtr)entityComponentStore, (IntPtr)entityBatchList, ref types);
}
public CatalogEntry(String sku, int nameId, Managed managed)
{
this.sku = sku;
this.nameId = nameId;
this.managed = managed;
}
private static void _forward_mono_RemoveComponentChunks(EntityComponentStore *entityComponentStore, ArchetypeChunk *chunks, int chunkCount, int typeIndex)
{
Managed._bfp_RemoveComponentChunks((IntPtr)entityComponentStore, (IntPtr)chunks, chunkCount, typeIndex);
}
public static ApplicationVersion GameVersion() => TryParse(Managed.GetVersionStr(), out var v) ? v : default;
private static void _forward_mono_RemoveComponentsChunks(EntityComponentStore *entityComponentStore, ArchetypeChunk *chunks, int chunkCount, ref ComponentTypes types)
{
Managed._bfp_RemoveComponentsChunks((IntPtr)entityComponentStore, (IntPtr)chunks, chunkCount, ref types);
}
public void AddResource(Managed item)
{
if (this.embeddedResources.Contains(item))
{
throw new ApplicationException("item is in collection already");
}
this.embeddedResources.Add(item);
this.SubscribeOnNameChange(item);
//TODO: get source file reference
this.resourceManager.ProvideResource(item.ClassHashCode, item.NameHash, item, this.resourceFile);
}
private static void _forward_mono_AddSharedComponentChunks(EntityComponentStore *entityComponentStore, ArchetypeChunk *chunks, int chunkCount, int componentTypeIndex, int sharedComponentIndex)
{
Managed._bfp_AddSharedComponentChunks((IntPtr)entityComponentStore, (IntPtr)chunks, chunkCount, componentTypeIndex, sharedComponentIndex);
}
