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("\\", ".")));
}
