private static void RegisterTypes(Assembly assembly) { if (assembly == null) { return; } #if XB1 // XB1_ALLINONEASSEMBLY System.Diagnostics.Debug.Assert(m_registered == false); if (m_registered == true) { return; } m_registered = true; foreach (var type in MyAssembly.GetTypes()) #else // !XB1 foreach (var type in assembly.GetTypes()) #endif // !XB1 { var attributes = type.GetCustomAttributes(typeof(MyStorageDataProviderAttribute), false); if (attributes == null || attributes.Length == 0) { continue; } Debug.Assert(typeof(IMyStorageDataProvider).IsAssignableFrom(type)); var attribute = (MyStorageDataProviderAttribute)attributes[0]; Debug.Assert(type.GetConstructor(System.Type.EmptyTypes) != null, "Storage data provider must have parameterless constructor defined."); attribute.ProviderType = type; m_attributesById.Add(attribute.ProviderTypeId, attribute); m_attributesByType.Add(attribute.ProviderType, attribute); } }
public void Add(LogElementBO element, [Optional, DefaultParameterValue(true)] bool sendtoWeb) { element.Owner = Owner; element.CivVersion = ClientVersion; element.Assembly = new string[AppDomain.CurrentDomain.GetAssemblies().Length]; int i = 0; foreach (Assembly MyAssembly in AppDomain.CurrentDomain.GetAssemblies()) { element.Assembly[i] = MyAssembly.ToString(); i++; } WriteToFile(element); // Désactivation des services web //if (AutomaticSendReport && sendtoWeb) //{ // ThreadStart start = delegate() // { // SendToWeb(element); // }; // new Thread(start).Start(); //} }
private void LoadScripts(Assembly assembly) { if (assembly == null) { return; } #if XB1 // XB1_ALLINONEASSEMBLY System.Diagnostics.Debug.Assert(m_scriptsLoaded == false); if (m_scriptsLoaded == true) { return; } m_scriptsLoaded = true; foreach (var type in MyAssembly.GetTypes()) #else // !XB1 foreach (var type in assembly.GetTypes()) #endif // !XB1 { var attrs = type.GetCustomAttributes(false); foreach (var attr in attrs) { if (attr is MyScriptedSystemAttribute) { var scriptAttribute = attr as MyScriptedSystemAttribute; var stringId = MyStringHash.GetOrCompute(scriptAttribute.ScriptName); Debug.Assert(!m_groupScripts.ContainsKey(stringId)); m_groupScripts[stringId] = Activator.CreateInstance(type) as MyGroupScriptBase; } } } }
public void RegisterComponentsFromAssembly(Assembly assembly, bool modAssembly = false) { if (assembly == null) { return; } #if XB1 // XB1_ALLINONEASSEMBLY MySandboxGame.Log.WriteLine("Registered modules from: N/A (on XB1)"); System.Diagnostics.Debug.Assert(m_registered == false); if (m_registered == true) { return; } m_registered = true; foreach (Type type in MyAssembly.GetTypes()) #else // !XB1 MySandboxGame.Log.WriteLine("Registered modules from: " + assembly.FullName); foreach (Type type in assembly.GetTypes()) #endif // !XB1 { if (Attribute.IsDefined(type, typeof(MySessionComponentDescriptor))) { TryRegisterSessionComponent(type, modAssembly); } } }
public void RegisterFromAssembly(Assembly assembly) { if (assembly == null) { return; } #if XB1 // XB1_ALLINONEASSEMBLY System.Diagnostics.Debug.Assert(m_registered == false); if (m_registered == true) { return; } m_registered = true; var types = MyAssembly.GetTypes(); foreach (Type type in types) #else // !XB1 foreach (Type type in assembly.GetTypes()) #endif // !XB1 { var descriptorArray = type.GetCustomAttributes(typeof(TAttribute), false); foreach (TAttribute descriptor in descriptorArray) { RegisterDescriptor(descriptor, type); } } }
private static void RegisterFromAssembly(Assembly assembly) { if (assembly == null) { return; } var baseType = typeof(MyComponentBase); #if XB1 // XB1_ALLINONEASSEMBLY System.Diagnostics.Debug.Assert(m_registered == false); if (m_registered == true) { return; } m_registered = true; var types = MyAssembly.GetTypes(); #else // !XB1 var types = assembly.GetTypes(); #endif // !XB1 foreach (var type in types) { if (baseType.IsAssignableFrom(type)) { AddId(type, MyStringId.GetOrCompute(type.Name)); RegisterComponentTypeAttribute(type); } } }
public Type GetType(string fullName, bool throwOnError) { #if XB1 // XB1_ALLINONEASSEMBLY Type type; if ((type = MyAssembly.GetType(fullName, false)) != null) { return(type); } #else // !XB1 foreach (var assembly in m_assemblies) { Type type; if ((type = assembly.GetType(fullName, false)) != null) { return(type); } } #endif // !XB1 if (throwOnError) { throw new TypeLoadException(string.Format("Type {0} was not found in any registered assembly!", fullName)); } return(null); }
public static List <Type> GetTriggerTypes() { #if XB1 // XB1_ALLINONEASSEMBLY return(MyAssembly.GetTypes().Where(type => type.IsSubclassOf(typeof(MyTrigger)) && (MyFakes.ENABLE_NEW_TRIGGERS || (type != typeof(MyTriggerTimeLimit) && type != typeof(MyTriggerBlockDestroyed)) )).ToList()); #else // !XB1 return(Assembly.GetCallingAssembly().GetTypes().Where(type => type.IsSubclassOf(typeof(MyTrigger)) && (MyFakes.ENABLE_NEW_TRIGGERS || (type != typeof(MyTriggerTimeLimit) && type != typeof(MyTriggerBlockDestroyed)) )).ToList()); #endif // !XB1 }
internal static void RegisterFromAssembly(Assembly assembly, bool registerLegacyNames = false) { if (assembly == null) { return; } var baseType = typeof(MyObjectBuilder_Base); #if XB1 // XB1_ALLINONEASSEMBLY System.Diagnostics.Debug.Assert(m_registered == false); if (m_registered == true) { return; } m_registered = true; var types = MyAssembly.GetTypes(); #else // !XB1 var types = assembly.GetTypes(); #endif // !XB1 Array.Sort(types, FullyQualifiedNameComparer.Default); foreach (var type in types) { if (baseType.IsAssignableFrom(type) && !m_typeByName.ContainsKey(type.Name)) { var myType = new MyObjectBuilderType(type); var myId = new MyRuntimeObjectBuilderId(++m_idCounter); m_typeById.Add(myId, myType); m_idByType.Add(myType, myId); m_typeByName.Add(type.Name, myType); const string PREFIX = "MyObjectBuilder_"; if (registerLegacyNames && type.Name.StartsWith(PREFIX)) { RegisterLegacyName(myType, type.Name.Substring(PREFIX.Length)); } var attrs = type.GetCustomAttributes(typeof(MyObjectBuilderDefinitionAttribute), true); if (attrs.Length > 0) { MyObjectBuilderDefinitionAttribute att = (MyObjectBuilderDefinitionAttribute)attrs[0]; if (!string.IsNullOrEmpty(att.LegacyName)) { RegisterLegacyName(myType, att.LegacyName); } } } } }
private static void RegisterPoolsFromAssembly(Assembly assembly) { #if XB1 // XB1_ALLINONEASSEMBLY System.Diagnostics.Debug.Assert(m_registered == false); if (m_registered == true) { return; } m_registered = true; foreach (var type in MyAssembly.GetTypes()) #else // !XB1 foreach (var type in assembly.GetTypes()) #endif // !XB1 { var customAttributes = type.GetCustomAttributes(typeof(PooledObjectAttribute), false); if (customAttributes != null && customAttributes.Length > 0) { Debug.Assert(customAttributes.Length == 1); PooledObjectAttribute attribute = (PooledObjectAttribute)customAttributes[0]; var methods = type.GetMethods(); bool delegateFound = false; foreach (var method in methods) { var methodAttributes = method.GetCustomAttributes(typeof(PooledObjectCleanerAttribute), false); if (methodAttributes != null && methodAttributes.Length > 0) { Debug.Assert(methodAttributes.Length == 1); MyGenericObjectPool objectPool = new MyGenericObjectPool(attribute.PoolPreallocationSize, type); CleanerDelegate cleanerDelegate = method.CreateDelegate <CleanerDelegate>(); // Make sure everything in the pool is always clean foreach (var objectInPool in objectPool.Unused) { cleanerDelegate(objectInPool); } m_poolsByType.Add(type, MyTuple.Create(objectPool, cleanerDelegate)); delegateFound = true; break; } } if (!delegateFound) { Debug.Fail("Pooled type does not have a cleaner method."); } } } }
/// <summary> /// Register an activity documentation component component factory /// </summary> /// <param name="componentFactory">the activity documentation component factory</param> /// <exception cref="Exception">throws, when the target assembly is not loaded or the /// registry class or methods cannot be found</exception> public void Register(IActivityDocumentationComponentFactory componentFactory) { try { Type componentRegistryType = MyAssembly.GetType(ComponentRegistryClassName); PropertyInfo theInstanceProperty = componentRegistryType.GetProperty("TheInstance"); MethodInfo registerMethod = componentRegistryType.GetMethod("Register", new Type[] { typeof(object) }); object componentRegistry = theInstanceProperty.GetValue(null, null); registerMethod.Invoke(componentRegistry, new object[] { componentFactory }); } catch (Exception e) { // If AD is not installed, this should not cause Gear Chart to error //throw new InvalidOperationException("Cannot register component", e); } }
// Create additional model generators from plugins using reflection. public void CreateAdditionalModelGenerators(MyCubeSize gridSizeEnum) { #if XB1 // XB1_ALLINONEASSEMBLY { #else // !XB1 Assembly[] assemblies = new Assembly[] { Assembly.GetExecutingAssembly(), MyPlugins.GameAssembly, MyPlugins.SandboxAssembly, MyPlugins.UserAssembly, }; foreach (var assembly in assemblies) { if (assembly == null) { continue; } #endif // !XB1 // Lookup Type lookupType = typeof(IMyBlockAdditionalModelGenerator); #if XB1 // XB1_ALLINONEASSEMBLY IEnumerable <Type> lookupTypes = MyAssembly.GetTypes().Where( t => lookupType.IsAssignableFrom(t) && t.IsClass && !t.IsAbstract); #else // !XB1 IEnumerable <Type> lookupTypes = assembly.GetTypes().Where( t => lookupType.IsAssignableFrom(t) && t.IsClass && !t.IsAbstract); #endif // !XB1 // Create instances foreach (var type in lookupTypes) { IMyBlockAdditionalModelGenerator generator = Activator.CreateInstance(type) as IMyBlockAdditionalModelGenerator; if (generator.Initialize(m_grid, gridSizeEnum)) { AdditionalModelGenerators.Add(generator); } else { generator.Close(); } } } }
private static void RegisterScreensFromAssembly(Assembly assembly) { if (assembly == null) { return; } var baseScreen = typeof(MyGuiScreenBase); #if XB1 // XB1_ALLINONEASSEMBLY System.Diagnostics.Debug.Assert(m_registered == false); if (m_registered == true) { return; } m_registered = true; foreach (var type in MyAssembly.GetTypes()) #else // !XB1 foreach (var type in assembly.GetTypes()) #endif // !XB1 { if (!baseScreen.IsAssignableFrom(type)) { continue; } var attributes = type.GetCustomAttributes(typeof(MyDebugScreenAttribute), false); if (attributes.Length == 0) { continue; } var attribute = (MyDebugScreenAttribute)attributes[0]; SortedDictionary <string, MyDevelopGroupTypes> typesInGroup; if (!s_developScreenTypes.TryGetValue(attribute.Group, out typesInGroup)) { typesInGroup = new SortedDictionary <string, MyDevelopGroupTypes>(); s_developScreenTypes.Add(attribute.Group, typesInGroup); s_developGroups.Add(attribute.Group, new MyDevelopGroup(attribute.Group)); } MyDevelopGroupTypes val = new MyDevelopGroupTypes(type, attribute.DirectXSupport); typesInGroup.Add(attribute.Name, val); } }
private static void ChooseScreenType <T>(ref Type createdType, Assembly assembly) where T : MyGuiScreenBase { if (assembly == null) { return; } #if XB1 // XB1_ALLINONEASSEMBLY foreach (var type in MyAssembly.GetTypes()) #else // !XB1 foreach (var type in assembly.GetTypes()) #endif // !XB1 { if (typeof(T).IsAssignableFrom(type)) { createdType = type; break; } } }
private static void RegisterAssemblyTypes(Assembly assembly) { if (assembly == null) { return; } var iMyUseObject = typeof(IMyUseObject); #if XB1 // XB1_ALLINONEASSEMBLY System.Diagnostics.Debug.Assert(m_registered == false); if (m_registered == true) { return; } m_registered = true; foreach (var type in MyAssembly.GetTypes()) #else // !XB1 foreach (var type in assembly.GetTypes()) #endif // !XB1 { if (!iMyUseObject.IsAssignableFrom(type)) { continue; } var attributes = (MyUseObjectAttribute[])type.GetCustomAttributes(typeof(MyUseObjectAttribute), false); if (attributes.IsNullOrEmpty()) { continue; } foreach (var attribute in attributes) { AssertHasCorrectCtor(type); Debug.Assert(!m_useObjectTypesByDummyName.ContainsKey(attribute.DummyName) || m_useObjectTypesByDummyName[attribute.DummyName].Assembly != type.Assembly, "Overriding use object with class in same assembly! This should not happen."); m_useObjectTypesByDummyName[attribute.DummyName] = type; } } }
private static void RegisterEventTypesAndHandlers(Assembly assembly) { if (assembly == null) { return; } #if XB1 // XB1_ALLINONEASSEMBLY System.Diagnostics.Debug.Assert(m_registered == false); if (m_registered == true) { return; } m_registered = true; foreach (Type type in MyAssembly.GetTypes()) #else // !XB1 foreach (Type type in assembly.GetTypes()) #endif // !XB1 { foreach (MethodInfo method in type.GetMethods()) { if (!method.IsPublic || !method.IsStatic) { continue; } var descriptorArray = method.GetCustomAttributes(typeof(MyGlobalEventHandler), false); if (descriptorArray != null && descriptorArray.Length > 0) { foreach (var descriptor in descriptorArray) { MyGlobalEventHandler typedDescriptor = (MyGlobalEventHandler)descriptor; RegisterHandler(typedDescriptor.EventDefinitionId, method); } } } } m_globalEventFactory.RegisterFromAssembly(assembly); }
public static void RegisterFromAssembly(Assembly assembly) { #if XB1 // XB1_ALLINONEASSEMBLY System.Diagnostics.Debug.Assert(m_registered == false); if (m_registered == true) { return; } m_registered = true; foreach (var t in MyAssembly.GetTypes()) #else // !XB1 foreach (var t in assembly.GetTypes()) #endif // !XB1 { if (!t.IsGenericType && t.BaseType != null && t.BaseType.IsGenericType && t.BaseType.GetGenericTypeDefinition() == typeof(MySerializer <>)) { Type argType = t.BaseType.GetGenericArguments()[0]; Register(argType, t); } } }
public void RegisterFromAssembly(Assembly assembly) { #if XB1 // XB1_ALLINONEASSEMBLY System.Diagnostics.Debug.Assert(m_registered == false); if (m_registered == true) { return; } m_registered = true; foreach (var type in MyAssembly.GetTypes().Where(t => typeof(MyExternalReplicable).IsAssignableFrom(t) && !t.IsAbstract)) #else // !XB1 foreach (var type in assembly.GetTypes().Where(t => typeof(MyExternalReplicable).IsAssignableFrom(t) && !t.IsAbstract)) #endif // !XB1 { var objType = type.FindGenericBaseTypeArgument(typeof(MyExternalReplicable <>)); if (objType != null && !m_objTypeToExternalReplicableType.ContainsKey(objType)) { Debug.Assert(type.HasDefaultConstructor(), string.Format("Type '{0}' should have public constructor", type.Name)); m_objTypeToExternalReplicableType.TryAdd(objType, type); } } }
public static void PrintHelp() { Console.WriteLine(); Console.WriteLine($"Viramate Installer v{MyAssembly.GetName().Version}"); Console.WriteLine( @"-? /? Print help --version Print version number and quit --update Update the installer even if install succeeds --nodir Don't open the install directory --nohelp Don't open the help webpage after install --disk Only install from a local directory instead of the internet (for debugging purposes) --network Only install from the internet, not a local directory --force Force install/update even if nothing is changed" ); }
private Type FindTerminalTypeFromInterface <TBlock>() { #if XB1 // XB1_ALLINONEASSEMBLY var type = MyAssembly.GetTypes().FirstOrDefault(x => typeof(TBlock).IsAssignableFrom(x) && !x.IsInterface); if (type == null) { System.Diagnostics.Debug.Assert(false, "XB1 TODO?"); } return(type); #else // !XB1 var type = Assembly.GetExecutingAssembly().GetTypes().FirstOrDefault(x => typeof(TBlock).IsAssignableFrom(x) && !x.IsInterface); if (type == null) { var gameAssembly = MyPlugins.GameAssembly; if (gameAssembly != null) { type = gameAssembly.GetTypes().FirstOrDefault(x => typeof(TBlock).IsAssignableFrom(x) && !x.IsInterface); } } return(type); #endif // !XB1 }
public void RegisterFromAssembly(Assembly assembly) { if (assembly == null) { return; } #if XB1 // XB1_ALLINONEASSEMBLY System.Diagnostics.Debug.Assert(m_registered == false); if (m_registered == true) { return; } m_registered = true; foreach (var type in MyAssembly.GetTypes()) #else // !XB1 foreach (var type in assembly.GetTypes()) #endif // !XB1 { if (MyTypeTable.ShouldRegister(type)) { m_typeTable.Register(type); } } }
static void RegisterFromAssembly(Assembly assembly) { #if XB1 // XB1_ALLINONEASSEMBLY System.Diagnostics.Debug.Assert(m_registered == false); if (m_registered == true) { return; } m_registered = true; foreach (var type in MyAssembly.GetTypes()) #else // !XB1 foreach (var type in assembly.GetTypes()) #endif // !XB1 { var attribute = Attribute.GetCustomAttribute(type, typeof(MessageIdAttribute)) as MessageIdAttribute; if (attribute != null) { TypeMap.Add(type, Tuple.Create((ushort)(attribute.MessageId * 4), attribute.SendType)); TypeMap.Add(typeof(Request <>).MakeGenericType(type), Tuple.Create((ushort)(attribute.MessageId * 4 + 1), attribute.SendType)); TypeMap.Add(typeof(Success <>).MakeGenericType(type), Tuple.Create((ushort)(attribute.MessageId * 4 + 2), attribute.SendType)); TypeMap.Add(typeof(Failure <>).MakeGenericType(type), Tuple.Create((ushort)(attribute.MessageId * 4 + 3), attribute.SendType)); } } }
public static async Task InstallExtension() { var allowAutoClose = true; Console.WriteLine(); Console.WriteLine($"Viramate Installer v{MyAssembly.GetName().Version}"); if (Environment.GetCommandLineArgs().Contains("--version")) { return; } if (Environment.GetCommandLineArgs().Contains("--update")) { await AutoUpdateInstaller(); } Console.WriteLine("Installing extension. This'll take a moment..."); if (await InstallExtensionFiles(false, null) != InstallResult.Failed) { Console.WriteLine($"Extension id: {ExtensionId}"); string manifestText; using (var s = new StreamReader(OpenResource("nmh.json"), Encoding.UTF8)) manifestText = s.ReadToEnd(); manifestText = manifestText .Replace( "$executable_path$", ExecutablePath.Replace("\\", "\\\\").Replace("\"", "\\\"") ).Replace( "$extension_id$", ExtensionId ); var manifestPath = Path.Combine(MiscPath, "nmh.json"); Directory.CreateDirectory(MiscPath); File.WriteAllText(manifestPath, manifestText); Directory.CreateDirectory(Path.Combine(DataPath, "Help")); foreach (var n in MyAssembly.GetManifestResourceNames()) { if (!n.EndsWith(".gif") && !n.EndsWith(".png")) { continue; } var destinationPath = Path.Combine(DataPath, n.Replace("Viramate.", "").Replace("Help.", "Help\\")); using (var src = MyAssembly.GetManifestResourceStream(n)) using (var dst = File.Open(destinationPath, FileMode.Create)) await src.CopyToAsync(dst); } const string keyName = @"Software\Google\Chrome\NativeMessagingHosts\com.viramate.installer"; using (var key = Registry.CurrentUser.CreateSubKey(keyName)) { Console.WriteLine($"{keyName}\\@ = {manifestPath}"); key.SetValue(null, manifestPath); } try { WebSocketServer.SetupFirewallRule(); } catch (Exception exc) { Console.WriteLine("Failed to install firewall rule: {0}", exc); allowAutoClose = false; } string helpFileText; using (var s = new StreamReader(OpenResource("Help/index.html"), Encoding.UTF8)) helpFileText = s.ReadToEnd(); helpFileText = Regex.Replace( helpFileText, @"\<pre\ id='install_path'>[^<]*\</pre\>", @"<pre id='install_path'>" + DataPath + "</pre>" ); var helpFilePath = Path.Combine(DataPath, "Help", "index.html"); File.WriteAllText(helpFilePath, helpFileText); Console.WriteLine($"Viramate v{ReadManifestVersion(null)} has been installed."); if (!Environment.GetCommandLineArgs().Contains("--nohelp")) { Console.WriteLine("Opening install instructions..."); Process.Start(helpFilePath); } else if (!Debugger.IsAttached && !IsRunningInsideCmd) { Console.WriteLine("Press enter to exit."); return; } if (!Environment.GetCommandLineArgs().Contains("--nodir")) { Console.WriteLine("Waiting, then opening install directory..."); await Task.Delay(2000); Process.Start(DataPath); } } else { await AutoUpdateInstaller(); if (!Debugger.IsAttached && !IsRunningInsideCmd) { Console.WriteLine("Failed to install extension. Press enter to exit."); Console.ReadLine(); } else { Console.WriteLine("Failed to install extension."); } } }
public DefaultComponent() { AddShortcut(MyKeys.None, false, false, false, false, () => "Hammer (CTRL + Mouse left)", null ); AddShortcut(MyKeys.H, true, true, true, false, () => "Hammer force: " + (HammerForce ? "ON" : "OFF"), delegate { HammerForce = !HammerForce; return(true); } ); AddShortcut(MyKeys.OemPlus, true, true, false, false, () => "Radius+: " + RADIUS, delegate { RADIUS += 0.5f; return(true); } ); AddShortcut(MyKeys.OemMinus, true, true, false, false, () => "", delegate { RADIUS -= 0.5f; return(true); } ); AddShortcut(MyKeys.NumPad7, true, false, false, false, () => "Shown mass: " + ShowRealBlockMass.ToString(), delegate { ShowRealBlockMass++; ShowRealBlockMass = (ShownMassEnum)((int)ShowRealBlockMass % (int)ShownMassEnum.MaxVal); return(true); }); AddShortcut(MyKeys.NumPad8, true, false, false, false, () => "MemA: " + m_memoryA + " MemB: " + m_memoryB + " Diff:" + (m_memoryB - m_memoryA), Diff); AddShortcut(MyKeys.NumPad9, true, false, false, false, () => "", () => { m_drawBodyInfo = !m_drawBodyInfo; m_drawUpdateInfo = !m_drawUpdateInfo; return(true); }); AddShortcut(MyKeys.NumPad6, true, false, false, false, () => "Prioritize: " + (MyFakes.PRIORITIZE_PRECALC_JOBS ? "On" : "Off"), () => { MyFakes.PRIORITIZE_PRECALC_JOBS = !MyFakes.PRIORITIZE_PRECALC_JOBS; return(true); }); m_dbgComponents.Clear(); #if XB1 // XB1_ALLINONEASSEMBLY foreach (var t in MyAssembly.GetTypes()) #else // !XB1 foreach (var t in Assembly.GetExecutingAssembly().GetTypes()) #endif // !XB1 { if (t.IsSubclassOf(typeof(MyRenderComponentBase))) { continue; } if (t.IsSubclassOf(typeof(MySyncComponentBase))) { continue; } if (t.IsSubclassOf(typeof(MyEntityComponentBase))) { m_dbgComponents.Add(t); } } }
public Deck() { Cards = new List <Card>(); CardImages = new List <Bitmap>(); //creates bitmap objects for each bmp image in folder //Check for different way to access the images as the path //won't be the same if the images are embedded into the dll file. //for (int i = 0; i < 52; i++) //{ // int cardNum = i + 1; // if (i < 10) // { // CardImages.Add(new Bitmap("C:\\Users\\Matthew Pendleton\\Documents\\Visual Studio 2015\\Projects\\LibraryFiles\\LibraryFiles\\CardGames\\CardGames\\Images\\cards_0"+cardNum+"_clubs.bmp")); // } // CardImages.Add(new Bitmap("C:\\Users\\Matthew Pendleton\\Documents\\Visual Studio 2015\\Projects\\LibraryFiles\\LibraryFiles\\CardGames\\CardGames\\Images\\cards_"+cardNum+"_clubs.bmp")); //} MyAssembly = Assembly.GetExecutingAssembly(); string assemblyStream = " "; try { for (int i = 0; i < 53; i++) { int cardNum = i + 1; if (i < 9) { assemblyStream = "CardGames.Images.cards_0" + cardNum + "_clubs.bmp"; } else if (i >= 9 && i < 13) { assemblyStream = "CardGames.Images.cards_" + cardNum + "_clubs.bmp"; } else if (i >= 13 && i < 26) { assemblyStream = "CardGames.Images.cards_" + cardNum + "_diamonds.bmp"; } else if (i >= 26 && i < 39) { assemblyStream = "CardGames.Images.cards_" + cardNum + "_hearts.bmp"; } else if (i >= 39 && i < 52) { assemblyStream = "CardGames.Images.cards_" + cardNum + "_spades.bmp"; } else if (i == 52) { assemblyStream = "CardGames.Images.cards_59_backs.bmp"; } //stream needs to stay open for cards to display in program. Stream myStream = MyAssembly.GetManifestResourceStream(assemblyStream); if (myStream != null && assemblyStream != " " && i != 52) { CardImages.Add(new Bitmap(myStream)); } else if (i == 52 && myStream != null) { DeckBack = new Card() { CardImage = new Bitmap(myStream) }; } else { throw new ArgumentException("Invalid Stream for i= " + i); } } for (int i = 0; i < 13; i++) { for (int j = 0; j < 4; j++) { Card card = new Card(); card.Face = (Face)i; card.Suit = (Suit)j; //selects out of the list of card pictures first all suits of the Ace //then all suits of the 2 etc... switch (j) { case 0: card.CardImage = CardImages[i]; break; case 1: card.CardImage = CardImages[i + 13]; break; case 2: card.CardImage = CardImages[i + 26]; break; case 3: card.CardImage = CardImages[i + 39]; break; default: throw new ArgumentException("something went wrong with switch statement"); } Cards.Add(card); } } } catch (ArgumentException e) { MessageBox.Show(e.Message); throw; } }
// Main method static void Main(string[] args) { #if XB1 XB1Interface.XB1Interface.Init(); MyAssembly.Init(); #endif SpaceEngineersGame.SetupBasicGameInfo(); m_startup = new MyCommonProgramStartup(args); if (m_startup.PerformReporting()) { return; } m_startup.PerformAutoconnect(); #if !XB1 if (!m_startup.CheckSingleInstance()) { return; } #endif // !XB1 var appDataPath = m_startup.GetAppDataPath(); MyInitializer.InvokeBeforeRun(AppId, MyPerGameSettings.BasicGameInfo.ApplicationName, appDataPath); MyInitializer.InitCheckSum(); m_startup.InitSplashScreen(); if (!m_startup.Check64Bit()) { return; } m_startup.DetectSharpDxLeaksBeforeRun(); using (MySteamService steamService = new MySteamService(MySandboxGame.IsDedicated, AppId)) { m_renderer = null; SpaceEngineersGame.SetupPerGameSettings(); SpaceEngineersGame.SetupRender(); try { InitializeRender(); } catch (MyRenderException ex) { #if !XB1 MessageBox.Show(ex.Message); #else // XB1 System.Diagnostics.Debug.Assert(false, "InitializeRender failed"); #endif // XB1 return; } VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MyProgram.Init"); VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MySteam.Init()"); if (!m_startup.CheckSteamRunning(steamService)) { return; } VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("new MySandboxGame()"); VRageGameServices services = new VRageGameServices(steamService); if (!MySandboxGame.IsDedicated) { MyFileSystem.InitUserSpecific(steamService.UserId.ToString()); } using (SpaceEngineersGame game = new SpaceEngineersGame(services, args)) { VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock(); game.Run(disposeSplashScreen: m_startup.DisposeSplashScreen); } } m_startup.DetectSharpDxLeaksAfterRun(); #if PROFILING MyPerformanceTimer.WriteToLog(); #endif MyInitializer.InvokeAfterRun(); }
protected void LoadBotData(Assembly assembly) { #if XB1 // XB1_ALLINONEASSEMBLY System.Diagnostics.Debug.Assert(m_botDataLoaded == false); if (m_botDataLoaded == true) { return; } m_botDataLoaded = true; var allTypes = MyAssembly.GetTypes(); #else // !XB1 var allTypes = assembly.GetTypes(); #endif // !XB1 foreach (var type in allTypes) { if (!type.IsAbstract && type.IsSubclassOf(typeof(MyBotActionsBase))) { var typeAttrs = type.GetCustomAttributes(true); string behaviorName = ""; var behaviorData = new BehaviorData(type); foreach (var typeAttr in typeAttrs) { if (typeAttr is MyBehaviorDescriptorAttribute) { var behaviorPropertiesAttr = typeAttr as MyBehaviorDescriptorAttribute; Debug.Assert(!m_botDataByBehaviorType.ContainsKey(behaviorPropertiesAttr.DescriptorCategory), "Bot type already declared in the factory"); behaviorName = behaviorPropertiesAttr.DescriptorCategory; } else if (typeAttr is BehaviorActionImplAttribute) { var behaviorImplAttr = typeAttr as BehaviorActionImplAttribute; behaviorData.LogicType = behaviorImplAttr.LogicType; } } if (!string.IsNullOrEmpty(behaviorName) && behaviorData.LogicType != null) { m_botDataByBehaviorType[behaviorName] = behaviorData; } else { Debug.Assert(false, "Invalid bot data. Definition will be removed"); } } else if (!type.IsAbstract && type.IsSubclassOf(typeof(MyBotLogic))) { foreach (var typeAttr in type.GetCustomAttributes(typeof(BehaviorLogicAttribute), true)) { var subtypeAttr = typeAttr as BehaviorLogicAttribute; m_logicDataByBehaviorSubtype[subtypeAttr.BehaviorSubtype] = new LogicData(type); } } else if (!type.IsAbstract && typeof(MyAiTargetBase).IsAssignableFrom(type)) { foreach (var typeAttr in type.GetCustomAttributes(typeof(TargetTypeAttribute), true)) { var tarTypeAttr = typeAttr as TargetTypeAttribute; m_TargetTypeByName[tarTypeAttr.TargetType] = type; } } } }
public static void RegisterTypesFromAssembly(Assembly assembly) { if (assembly == null) { return; } #if !XB1 // XB1_ALLINONEASSEMBLY if (m_registeredAssemblies.Contains(assembly)) { return; } m_registeredAssemblies.Add(assembly); if (m_registered.Contains(assembly)) { return; } m_registered.Add(assembly); #endif // !XB1 #if XB1 // XB1_ALLINONEASSEMBLY if (m_registered == true) { return; } m_registered = true; foreach (Type type in MyAssembly.GetTypes()) #else // !XB1 foreach (Type type in assembly.GetTypes()) #endif // !XB1 { var descriptorArray = type.GetCustomAttributes(typeof(MyDefinitionTypeAttribute), false); if (descriptorArray.Length > 0) { if (!type.IsSubclassOf(typeof(MyDefinitionBase)) && type != typeof(MyDefinitionBase)) { MyLog.Default.Error("Type {0} is not a definition.", type.Name); continue; } foreach (MyDefinitionTypeAttribute descriptor in descriptorArray) { m_definitionFactory.RegisterDescriptor(descriptor, type); var pp = (MyDefinitionPostprocessor)Activator.CreateInstance(descriptor.PostProcessor); pp.DefinitionType = descriptor.ObjectBuilderType; m_postProcessors.Add(pp); m_postprocessorsByType.Add(descriptor.ObjectBuilderType, pp); MyXmlSerializerManager.RegisterSerializer(descriptor.ObjectBuilderType); } var tp = type; while (tp != typeof(MyDefinitionBase)) { tp = tp.BaseType; HashSet <Type> children; if (!m_childDefinitionMap.TryGetValue(tp, out children)) { children = new HashSet <Type>(); m_childDefinitionMap[tp] = children; children.Add(tp); // make sure it contains itself } children.Add(type); } } } m_postProcessors.Sort(MyDefinitionPostprocessor.Comparer); }
public void CustomAssemblyImplThrows () { var ma = new MyAssembly(); try { ma.GetName (); Assert.Fail ("must throw"); } catch (NotImplementedException){ } }
//**************************************** /// <summary> /// Initialise the GuiService, automatically selecting the GUI Toolkit /// </summary> public static void Init() { //**************************************** GuiToolkit NewToolkit; string RootPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Toolkits"); string ToolkitPath = null; Assembly MyAssembly; object[] Attribs; //**************************************** foreach (string Argument in Environment.GetCommandLineArgs()) { // Was the toolkit specified on the command line? if (Argument.StartsWith("-Toolkit:")) { ToolkitPath = Path.Combine(RootPath, string.Format("Proximity.Gui.{0}.dll", Argument.Substring(9))); break; } } //**************************************** if (ToolkitPath == null) { // No toolkit specified, pick an appropriate one automatically switch (Environment.OSVersion.Platform) { case PlatformID.Win32NT: case PlatformID.Win32S: case PlatformID.Win32Windows: case PlatformID.WinCE: try { // Check if WPF is installed MyAssembly = Assembly.Load("PresentationFramework, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"); // Success, use the WPF toolkit ToolkitPath = Path.Combine(RootPath, "Proximity.Gui.Wpf.dll"); } catch (FileNotFoundException) { // Exception, use WinForms instead ToolkitPath = Path.Combine(RootPath, "Proximity.Gui.WinForms.dll"); } break; case PlatformID.MacOSX: case PlatformID.Unix: case (PlatformID)128: ToolkitPath = Path.Combine(RootPath, "Proximity.Gui.GtkSharp.dll"); break; default: throw new PlatformNotSupportedException("Platform is unsupported"); } } //**************************************** // Load the Toolkit Assembly MyAssembly = Assembly.LoadFrom(ToolkitPath); // Find the Attribute that tells us the Toolkit Class Attribs = MyAssembly.GetCustomAttributes(typeof(GuiToolkitAttribute), false); if (Attribs.Length == 0) { throw new GuiException("Missing Toolkit Attribute"); } // Create the Toolkit NewToolkit = (GuiToolkit)Activator.CreateInstance(((GuiToolkitAttribute)Attribs[0]).ToolkitType); //**************************************** Init(NewToolkit); }
static Stream OpenResource(string name) { return(MyAssembly.GetManifestResourceStream("Viramate." + name.Replace("/", ".").Replace("\\", "."))); }