/// <summary>
/// Coerces the given video standard compatibility to a supported value.
/// </summary>
/// <param name="videoStandardCompatiblity">The video standard compatibility to coerce.</param>
/// <returns>The coerced value.</returns>
/// <remarks>The ProgramFeatures.Combine() method had a bug that would result in combining the 'Tolerates' and 'Enhances' modes,
/// which resulted in a value of <see cref="FeatureCompatibility.Requires"/>. This method is used internally to correct for the problem.
/// To do so, it will strip the FeatureCompatibility.Tolerates bit. Recall that for video standards, FeatureCompatibility.Enhanced
/// indicates that video standard compatibility is unknown.</remarks>
public static FeatureCompatibility CoerceVideoStandardCompatibility(this FeatureCompatibility videoStandardCompatiblity)
{
if (videoStandardCompatiblity == FeatureCompatibility.Requires)
{
videoStandardCompatiblity = FeatureCompatibility.Enhances; // Indicates compatibility is unknown.
}
return(videoStandardCompatiblity);
}
/// <summary>
/// Initializes a new instance of the SystemCompatibilityConfigurationPageViewModel type.
/// </summary>
public SystemCompatibilityConfigurationPageViewModel()
{
var selectableOptions = new FeatureCompatibility[] { FeatureCompatibility.Incompatible, FeatureCompatibility.Tolerates, FeatureCompatibility.Enhances, FeatureCompatibility.Requires };
IntellivisionIIOptions = new ObservableCollection <ProgramFeatureImageViewModel>(selectableOptions.ToFeatureViewModels(IntellivisionIIFeatureSet.Data));
SuperVideoArcadeOptions = new ObservableCollection <ProgramFeatureImageViewModel>(selectableOptions.ToFeatureViewModels(SuperVideoArcadeFeatureSet.Data));
TutorvisionOptions = new ObservableCollection <ProgramFeatureImageViewModel>(selectableOptions.ToFeatureViewModels(TutorvisionFeatureSet.Data));
}
/// <summary>
/// Initializes a new instance of the GeneralFeaturesConfigurationPageViewModel type.
/// </summary>
public GeneralFeaturesConfigurationPageViewModel()
{
var selectableOptions = new FeatureCompatibility[] { FeatureCompatibility.Incompatible, FeatureCompatibility.Tolerates, FeatureCompatibility.Enhances };
NtscOptions = new ObservableCollection <ProgramFeatureImageViewModel>(selectableOptions.ToFeatureViewModels(NtscFeatureSet.Data));
PalOptions = new ObservableCollection <ProgramFeatureImageViewModel>(selectableOptions.ToFeatureViewModels(PalFeatureSet.Data));
selectableOptions = new FeatureCompatibility[] { FeatureCompatibility.Incompatible, FeatureCompatibility.Tolerates, FeatureCompatibility.Enhances, FeatureCompatibility.Requires };
IntellivoiceOptions = new ObservableCollection <ProgramFeatureImageViewModel>(selectableOptions.ToFeatureViewModels(IntellivoiceFeatureSet.Data));
}
/// <summary>
/// Converts standard FeatureCompatibility to LuigiFeatureFlags.
/// </summary>
/// <param name="compatibility">The compatibility to convert.</param>
/// <param name="category">The category of feature represented by the compatibility argument.</param>
/// <returns>The compatibility represented as appropriate LuigiFeatureFlags.</returns>
public static LuigiFeatureFlags ToLuigiFeatureFlags(this FeatureCompatibility compatibility, FeatureCategory category)
{
var luigiFeatureFlags = LuigiFeatureFlags.None;
var offset = -1;
switch (category)
{
case FeatureCategory.Intellivoice:
offset = LuigiFeatureFlagsHelpers.IntellivoiceOffset;
break;
case FeatureCategory.Ecs:
offset = LuigiFeatureFlagsHelpers.EcsOffset;
break;
case FeatureCategory.IntellivisionII:
// Intellivision II doesn't really 'enhance' anything. Ignore that value.
if (compatibility != FeatureCompatibility.Enhances)
{
offset = LuigiFeatureFlagsHelpers.IntellivisionIIOffset;
}
break;
case FeatureCategory.KeyboardComponent:
offset = LuigiFeatureFlagsHelpers.KeyboardComponentOffset;
break;
case FeatureCategory.Tutorvision:
// For TutorVision, we need to enable the 'feature compatibility sub-version' as well as the feature itself.
// This could be any value from 1..3 (two bits). Just enable minimum necessary version.
luigiFeatureFlags |= (LuigiFeatureFlags)(1ul << LuigiFeatureFlagsHelpers.ExtendedPeripheralCompatibiltyVersionOffset);
offset = LuigiFeatureFlagsHelpers.TutorVisionOffset;
break;
case FeatureCategory.Jlp:
offset = LuigiFeatureFlagsHelpers.JlpAccelerationOffset;
break;
case FeatureCategory.LtoFlash:
// NOTE: This isn't strictly correct. There isn't really "compatibility" for LTO Flash! -- just features, which are handled separately.
break;
default:
throw new System.InvalidOperationException(string.Format(Resources.Strings.FeatureCategoryNotSupportedByLuigiFormat, category));
}
if (offset >= 0)
{
luigiFeatureFlags |= (LuigiFeatureFlags)((ulong)compatibility << offset);
}
return(luigiFeatureFlags);
}
private ProgramFeatures(GeneralFeatures generalFeatures, FeatureCompatibility ntsc, FeatureCompatibility pal)
{
_features = new Dictionary <FeatureCategory, uint>();
CheckAccessSetFeatureBits(FeatureCategory.Ntsc, (uint)ntsc);
CheckAccessSetFeatureBits(FeatureCategory.Pal, (uint)pal);
CheckAccessSetFeatureBits(FeatureCategory.General, (uint)generalFeatures);
CheckAccessSetFeatureBits(FeatureCategory.KeyboardComponent, (uint)KeyboardComponentFeaturesHelpers.Default);
CheckAccessSetFeatureBits(FeatureCategory.SuperVideoArcade, (uint)FeatureCompatibility.Tolerates);
CheckAccessSetFeatureBits(FeatureCategory.Intellivoice, (uint)FeatureCompatibility.Tolerates);
CheckAccessSetFeatureBits(FeatureCategory.IntellivisionII, (uint)FeatureCompatibility.Tolerates);
CheckAccessSetFeatureBits(FeatureCategory.Ecs, (uint)EcsFeaturesHelpers.Default);
CheckAccessSetFeatureBits(FeatureCategory.Tutorvision, (uint)FeatureCompatibility.Tolerates);
CheckAccessSetFeatureBits(FeatureCategory.Intellicart, (uint)IntellicartCC3FeaturesHelpers.Default);
CheckAccessSetFeatureBits(FeatureCategory.CuttleCart3, (uint)CuttleCart3FeaturesHelpers.Default);
CheckAccessSetFeatureBits(FeatureCategory.Jlp, (uint)JlpFeaturesHelpers.Default);
CheckAccessSetFeatureBits(FeatureCategory.LtoFlash, (uint)LtoFlashFeaturesHelpers.Default);
CheckAccessSetFeatureBits(FeatureCategory.Bee3, (uint)Bee3FeaturesHelpers.Default);
CheckAccessSetFeatureBits(FeatureCategory.Hive, (uint)HiveFeaturesHelpers.Default);
System.Diagnostics.Debug.Assert(_features.Count == (int)FeatureCategory.NumberOfCategories, "Failed to assign default features for all feature categories.");
}
public void CfgVarMetadata_InflateFeatureCompatibility_GetsExpectedFeatureCompatibilty(string cfgFileValue, FeatureCompatibility expectedCfgVarMetadataFeatureCompatibilityValue)
{
var cfgFeatureCompatibilityEntry = "tv_compat = " + cfgFileValue;
using (var stream = new System.IO.MemoryStream(Encoding.UTF8.GetBytes(cfgFeatureCompatibilityEntry)))
{
var cfgVarMetadataFeatureCompatibility = CfgVarMetadataBlock.Inflate(stream) as CfgVarMetadataFeatureCompatibility;
Assert.Equal(expectedCfgVarMetadataFeatureCompatibilityValue, cfgVarMetadataFeatureCompatibility.Compatibility);
}
}
/// <inheritdoc/>
protected override void Parse(string payload)
{
var compatibilityString = GetCleanPayloadString(payload);
if (!string.IsNullOrEmpty(payload))
{
byte compatibility;
if (byte.TryParse(compatibilityString, out compatibility))
{
switch (Type)
{
case CfgVarMetadataIdTag.EcsCompatibility:
case CfgVarMetadataIdTag.IntellivisionIICompatibility:
case CfgVarMetadataIdTag.IntellivoiceCompatibility:
case CfgVarMetadataIdTag.KeyboardComponentCompatibility:
case CfgVarMetadataIdTag.TutorvisionCompatibility:
case CfgVarMetadataIdTag.Jlp:
case CfgVarMetadataIdTag.JlpAccelerators:
if (compatibility < (byte)FeatureCompatibility.NumCompatibilityModes)
{
Compatibility = (FeatureCompatibility)compatibility;
}
break;
case CfgVarMetadataIdTag.Ecs:
if (compatibility == 0)
{
Compatibility = FeatureCompatibility.Tolerates;
}
else if (compatibility == 1)
{
Compatibility = FeatureCompatibility.Requires;
}
break;
case CfgVarMetadataIdTag.IntellivisionII:
if (compatibility == 0)
{
Compatibility = FeatureCompatibility.Incompatible;
}
else if (compatibility == 1)
{
Compatibility = FeatureCompatibility.Tolerates;
}
break;
case CfgVarMetadataIdTag.Voice:
if (compatibility == 0)
{
Compatibility = FeatureCompatibility.Tolerates;
}
else if (compatibility == 1)
{
Compatibility = FeatureCompatibility.Enhances;
}
break;
default:
throw new System.InvalidOperationException(string.Format(Resources.Strings.CfgVarMetadata_TypeError, Type));
}
}
}
}
/// <inheritdoc />
public IProgramFeaturesBuilder WithIntellivoiceCompatibility(FeatureCompatibility intellivoiceCompatibility)
{
_programFeatures.Intellivoice = intellivoiceCompatibility;
return(this);
}
/// <inheritdoc />
public IProgramFeaturesBuilder WithSuperVideoArcadeCompatibility(FeatureCompatibility superVideoArcadeCompatibility)
{
_programFeatures.SuperVideoArcade = superVideoArcadeCompatibility;
return(this);
}
/// <inheritdoc />
public IProgramFeaturesBuilder WithPalCompatibility(FeatureCompatibility palCompatibility)
{
_programFeatures.Pal = palCompatibility;
return(this);
}
/// <inheritdoc />
public IProgramFeaturesBuilder WithNtscCompatibility(FeatureCompatibility ntscCompatibility)
{
_programFeatures.Ntsc = ntscCompatibility;
return(this);
}
public void FeatureCompatibility_TutorvisionFeaturesCompatibilityToLuigiFeatureFlags_ProducesCorrectLuigiFeatureFlags(FeatureCompatibility compatibility, LuigiFeatureFlags expectedFeatureFlags)
{
Assert.Equal(expectedFeatureFlags, compatibility.ToLuigiFeatureFlags(FeatureCategory.Tutorvision));
}
public void FeatureCompatibility_KeyboardComponentFeaturesCompatibilityToLuigiFeatureFlags_ProducesCorrectLuigiFeatureFlags(FeatureCompatibility compatibility, LuigiFeatureFlags expectedFeatureFlags)
{
Assert.Equal(expectedFeatureFlags, compatibility.ToLuigiFeatureFlags(FeatureCategory.KeyboardComponent));
}
/// <summary>
/// Alter the availability of a command. This may be used, for example, to modify the availability of commands not implemented
/// in the simulator, or only available in hardware, et. al.
/// </summary>
/// <param name="command">The command whose availability is being changed.</param>
/// <param name="hardwareStatus">Hardware status associated with command availability.</param>
/// <param name="compatibility">Whether the given hardware flag(s) are required, or must not be set.</param>
public void ChangeCommandAvailablility(ProtocolCommandId command, HardwareStatusFlags hardwareStatus, FeatureCompatibility compatibility)
{
_commandAvailability[command] = new Tuple <HardwareStatusFlags, FeatureCompatibility>(hardwareStatus, compatibility);
}
public void CfgVarMetadata_InflateLegacyCompatibility_GetsExpectedFeatureCompatibility(CfgVarMetadataIdTag legacyTag, string cfgFileValue, FeatureCompatibility expectedCfgVarMetadataFeatureCompatibilityValue)
{
var cfgLegacyFeatureCompatibilityEntry = legacyTag.ToCfgVarString() + " = " + cfgFileValue;
using (var stream = new System.IO.MemoryStream(Encoding.UTF8.GetBytes(cfgLegacyFeatureCompatibilityEntry)))
{
var cfgVarMetadataFeatureCompatibility = CfgVarMetadataBlock.Inflate(stream) as CfgVarMetadataFeatureCompatibility;
Assert.Equal(expectedCfgVarMetadataFeatureCompatibilityValue, cfgVarMetadataFeatureCompatibility.Compatibility);
}
}
/// <inheritdoc />
public IProgramFeaturesBuilder WithTutorvisionCompatibility(FeatureCompatibility tutorvisionCompatibility)
{
_programFeatures.Tutorvision = tutorvisionCompatibility;
return(this);
}
/// <summary>
/// Creates a new instance if the UnmergedProgram structure.
/// </summary>
/// <param name="code">INTV Funhouse code for the ROM.</param>
/// <param name="title">The title of the program (typically title screen title).</param>
/// <param name="vendor">Vendor who wrote the program.</param>
/// <param name="year">The year the program was copyrighted (or released).</param>
/// <param name="crcData">The CRC values of known versions of the program.</param>
/// <param name="crcDescriptions">The descriptions of the known versions of the program for each CRC.</param>
/// <param name="generalFeatures">Generic program features.</param>
/// <param name="intellivoice">Intellivoice compatibility.</param>
internal UnmergedProgram(string code, string title, string vendor, string year, uint[] crcData, string[] crcDescriptions, GeneralFeatures generalFeatures, FeatureCompatibility intellivoice)
{
Code = code;
CrcData = crcData;
CrcDescriptions = crcDescriptions;
CrcCfgs = Enumerable.Repeat((generalFeatures == GeneralFeatures.SystemRom) ? -1 : 0, crcData.Count()).ToArray();
Year = year;
Title = title;
Vendor = vendor;
Features = new ProgramFeatures();
Features.GeneralFeatures = generalFeatures;
Features.Intellivoice = intellivoice;
}
