public void EmergencyFix(SubsystemType subsystem)
{
List <ISubsystem> subsystemsFound = this.ShipConnectedTo.Subsystems.Where(s => s.Type == subsystem).ToList();
if (!subsystemsFound.Any())
{
this.Game.Write.Line("invalid or no fix required.");
return;
}
var subsystemToFix = subsystemsFound.Single(); //yeah. I'd rather say single() above, but oh well..
var thisShip = this.ShipConnectedTo;
if (thisShip.Energy > 1000) //todo: resource this out.
{
thisShip.Energy -= 1000; //todo: resource this out.
subsystemToFix.For(thisShip, this.Game).FullRepair();
this.Game.Write.Line("Ship Energy now at: " + thisShip.Energy);
}
else
{
this.Game.Write.Line("Not Enough Energy for Emergency Fix of " + subsystemToFix.Type);
}
}
public PEBuilder()
{
_is32Bits = true;
_machine = MachineType.I386;
_characteristics = ImageCharacteristics.EXECUTABLE_IMAGE | ImageCharacteristics.MACHINE_32BIT;
_imageBase = 0x400000;
_sectionAlignment = 0x2000;
_fileAlignment = 0x200;
_subsystem = SubsystemType.WINDOWS_CUI;
_dllCharacteristics =
DllCharacteristics.DYNAMIC_BASE |
DllCharacteristics.NX_COMPAT |
DllCharacteristics.NO_SEH;
_sizeOfStackReserve = 0x100000;
_sizeOfStackCommit = 0x1000;
_sizeOfHeapReserve = 0x100000;
_sizeOfHeapCommit = 0x1000;
_majorLinkerVersion = 8;
_minorLinkerVersion = 0;
_majorOperatingSystemVersion = 4;
_minorOperatingSystemVersion = 0;
_majorSubsystemVersion = 4;
_minorSubsystemVersion = 0;
_timeDateStamp = DateTime.Now;
_directories = new DataDirectory[PEConstants.NumberOfRvaAndSizes];
_tasks = new BuildTaskCollection(this);
_sections = new BuildSectionCollection(this);
_fixups = new BuildFixupCollection(this);
}
protected Subsystem(SubsystemType type)
{
Info = new SubsystemInfo {State = SubsystemState.Loading, Type = type};
Info.State = SubsystemState.Loaded;
Info.StartTime = DateTime.Now;
Logger.Log.Write(LogLevels.Debug, "Создание подсистемы типа " + type.ToString());
Info.State = SubsystemState.Working;
}
public ServiceMessage(KernelTypes handler,SubsystemType from, SubsystemType to, Enum type, object[] msg)
{
Handler = handler;
From = from;
To = to;
Type = type;
Message = msg;
}
public override void Controls(string command)
{
if (command == "fix")
{
string subsystemToFix;
this.Game.Write.PromptUser(this.ShowSubsystemsToFix(), out subsystemToFix);
this.EmergencyFix(SubsystemType.GetFromAbbreviation(subsystemToFix));
}
}
protected static ISubsystem For(IShip ship, SubsystemType subsystemType)
{
if (ship == null)
{
throw new GameConfigException("Ship not set up with Subsystem: " + subsystemType);
}
var subSystemToReturn = ship.Subsystems.Single(s => s.Type == subsystemType);
return(subSystemToReturn);
}
public SubsystemElement()
{
ElementType = "SUBSYSTEM";
Id = 0;
Name = "Unknown Subsystem";
Attributes = new Hashtable();
Ics = new List <IcElement>();
Dependencies = new List <DependencyElement>();
DependencyFunction = new DependencyFunctionElement();
Type = SubsystemType.Scripted;
AutoGenerateFunctionName();
}
public override void FromXml(string source)
{
// Deserialize subsystem object from xml string
XqlParser parser = new XqlParser();
parser.LoadData(source);
List <Hashtable> results = parser.Query("SELECT Type, SubId, Name, _innerXml FROM " + ElementType);
if (results.Count == 0)
{
throw new HsfElementException("Unable to parse " + ElementType + " from xml");
}
// Load basic fields and type enum
string innerXml = results[0]["_innerXml"].ToString();
Name = results[0]["Name"].ToString();
Id = Convert.ToInt64(results[0]["SubId"]);
Array posValues = Enum.GetValues(typeof(SubsystemType));
foreach (SubsystemType v in posValues)
{
if (Enum.GetName(typeof(SubsystemType), v) == results[0]["Type"].ToString())
{
Type = v;
}
}
// Load others based on type
if (Type == SubsystemType.Scripted)
{
// Set number of fields that must be loaded for scripted subsystems
results = parser.Query("SELECT initLUAFcn, canPerformLUAFcn, canExtendLUAFcn FROM " + ElementType);
if (results.Count == 0)
{
throw new HsfElementException("Unable to parse " + ElementType + " from xml");
}
_initLuaFcn = results[0]["initLUAFcn"].ToString();
_canPerformLuaFcn = results[0]["canPerformLUAFcn"].ToString();
_canExtendLuaFcn = results[0]["canExtendLUAFcn"].ToString();
}
else
{
// Load ALL possible fields for non-scripted subsystem
results = parser.Query("SELECT * FROM " + ElementType);
Attributes.Clear();
foreach (object key in results[0].Keys)
{
Attributes[key] = results[0][key];
}
}
// Load ICs
parser.LoadData(innerXml);
IcElement sampleIc = new IcElement();
results = parser.Query("SELECT _outerXml FROM " + sampleIc.ElementType);
Ics.Clear();
foreach (Hashtable ht in results)
{
IcElement newIc = new IcElement();
newIc.FromXml(ht["_outerXml"].ToString());
Ics.Add(newIc);
}
// Load dependencies
DependencyElement sampleDep = new DependencyElement();
results = parser.Query("SELECT _outerXml FROM " + sampleDep.ElementType);
Dependencies.Clear();
foreach (Hashtable ht in results)
{
DependencyElement newDep = new DependencyElement();
newDep.FromXml(ht["_outerXml"].ToString());
Dependencies.Add(newDep);
}
// Load dependency function
results = parser.Query("SELECT _outerXml FROM " + DependencyFunction.ElementType);
if (results.Count > 0)
{
DependencyFunction.Enabled = true;
DependencyFunction.FromXml(results[0]["_outerXml"].ToString());
}
else
{
DependencyFunction.Enabled = false;
}
}
protected unsafe void Read(IBinaryAccessor accessor)
{
// DOS
DOSHeader dosHeader;
fixed(byte *pBuff = accessor.ReadBytes(PEConstants.DosHeaderSize))
{
dosHeader = *(DOSHeader *)pBuff;
}
if (dosHeader.Signature != PEConstants.DosSignature)
{
throw new BadImageFormatException(SR.DOSHeaderSignatureNotValid);
}
accessor.Position = dosHeader.Lfanew;
// NT Signature
if (accessor.ReadUInt32() != PEConstants.NTSignature)
{
throw new BadImageFormatException(SR.PESignatureNotValid);
}
// COFF
COFFHeader coffHeader;
fixed(byte *pBuff = accessor.ReadBytes(PEConstants.COFFHeaderSize))
{
coffHeader = *(COFFHeader *)pBuff;
}
_characteristics = coffHeader.Characteristics;
_machine = coffHeader.Machine;
// PE
ushort peMagic = accessor.ReadUInt16();
accessor.Position -= 2;
if (peMagic == PEConstants.PEMagic32)
{
_is32Bits = true;
PEHeader peHeader;
fixed(byte *pBuff = accessor.ReadBytes(PEConstants.PEHeaderSize))
{
peHeader = *(PEHeader *)pBuff;
}
_addressOfEntryPoint = peHeader.AddressOfEntryPoint;
_imageBase = peHeader.ImageBase;
_sectionAlignment = peHeader.SectionAlignment;
_fileAlignment = peHeader.FileAlignment;
_subsystem = peHeader.Subsystem;
_dllCharacteristics = peHeader.DllCharacteristics;
_sizeOfStackReserve = peHeader.SizeOfStackReserve;
}
else if (peMagic == 0x20b)
{
_is32Bits = false;
PEHeader64 peHeader;
fixed(byte *pBuff = accessor.ReadBytes(PEConstants.PEHeader64Size))
{
peHeader = *(PEHeader64 *)pBuff;
}
_addressOfEntryPoint = peHeader.AddressOfEntryPoint;
_imageBase = peHeader.ImageBase;
_sectionAlignment = peHeader.SectionAlignment;
_fileAlignment = peHeader.FileAlignment;
_subsystem = peHeader.Subsystem;
_dllCharacteristics = peHeader.DllCharacteristics;
_sizeOfStackReserve = peHeader.SizeOfStackReserve;
}
else
{
throw new BadImageFormatException(SR.PEHeaderSignatureNotValid);
}
// Directories
for (int i = 0; i < PEConstants.NumberOfRvaAndSizes; i++)
{
fixed(byte *pBuff = accessor.ReadBytes(8))
{
_directories[i] = *(DataDirectory *)pBuff;
}
}
// Sections
_sections = new PESection[coffHeader.NumberOfSections];
for (int i = 0; i < coffHeader.NumberOfSections; i++)
{
_sections[i] = PESection.Read(accessor);
}
}
public SubsystemViewModel(SubsystemType subsystem)
{
Subsystem = subsystem;
}
