/// <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; }