public void Setup() { Fake.InitializeFixture(this); A.CallTo(() => this.fakeAndDummyManager.CreateFake(typeof(IFoo), A <IProxyOptions> ._)).Returns(this.fakeReturnedFromFakeAndDummyManager); this.fixture = new FixtureType(); }
/// <summary> /// Constructor /// </summary> /// <param name="pType"></param> public Fixture(FixtureType pType) { mManager = new DmxFramework.Scene.SceneManager(); mManager.Fixture = this; mName = ""; mType = pType; mChannels = new ArrayList(); }
protected virtual void OnSetup() { Fake.InitializeFixture(this); A.CallTo(() => this.fakeAndDummyManager.CreateFake(typeof(IFoo), A <FakeOptions> ._)).Returns(this.fakeReturnedFromFakeAndDummyManager); this.fixture = new FixtureType(); }
#pragma warning restore 649 public DefaultFixtureInitializerTests() { Fake.InitializeFixture(this); A.CallTo(() => this.fakeAndDummyManager.CreateFake(typeof(IFoo), A <Action <IFakeOptions> > ._)).Returns(this.fakeReturnedFromFakeAndDummyManager); this.fixture = new FixtureType(); }
public void Setup() { Fake.InitializeFixture(this); A.CallTo(() => this.fakeAndDummyManager.CreateFake(typeof(IFoo), A<IProxyOptions>._)).Returns(this.fakeReturnedFromFakeAndDummyManager); this.fixture = new FixtureType(); }
#pragma warning restore 649 public DefaultFixtureInitializerTests() { Fake.InitializeFixture(this); A.CallTo(() => this.fakeAndDummyManager.CreateFake(typeof(IFoo), A<Action<IFakeOptions>>._)).Returns(this.fakeReturnedFromFakeAndDummyManager); this.fixture = new FixtureType(); }
/// <summary> /// Constructor /// </summary> /// <param name="pType"></param> public Fixture(Fixture pParent, FixtureType pType) { mParent = pParent; mManager = new DmxFramework.Scene.SceneManager(); mManager.Fixture = this; mName = ""; mType = pType; mChannels = new List <DmxFramework.Channels.Channel>(); }
public void FixtureType_Implements_Interface_Type(Type implementedInterfaceType) { var implementedInterfaces = FixtureType.GetInterfaces(); Assert.Collection( implementedInterfaces.Where(type => type == implementedInterfaceType) , selectedType => Assert.Equal(implementedInterfaceType, selectedType) ); }
public SpecItem(string name, FixtureType type) : base() { this.Name = name; this.FixtureType = type; this.Headers = new List <Header>(); this.Params = new List <Param>(); this.Hosts = new List <SpecHost>(); this.Results = new List <Result>(); }
public void Ctors_Are_Internal() { const string context = nameof(context); var ctors = FixtureType.GetConstructors(NonPublic | Instance); Assert.Collection(ctors , ctor => VerifyParameters( ctor.GetParameters() , p => VerifyParameter <OptionContext>(p, context)) ); }
public async Task CreateTypesAsync(string[] names) { foreach (string name in names) { FixtureType type = new FixtureType(); type.Name = name; await _context.FixtureTypes.AddAsync(type); await _context.SaveChangesAsync(); } }
/// <summary> /// Returns the number of variants available for a given FixtureType. /// </summary> /// <param name="f"></param> /// <returns></returns> public static int GetVariants(FixtureType f) { switch (f) { case FixtureType.wid: return(2); case FixtureType.dor: return(4); case FixtureType.fnc: return(4); default: return(1); } }
public void Ctors_Are_Protected() { const string prototype = nameof(prototype); const string description = nameof(description); // IL Family is the reflection of C# Protected var ctors = FixtureType.GetConstructors(NonPublic | Instance); Assert.Collection(ctors.Select(ctor => ctor.IsFamily), Assert.True); Assert.Collection(ctors , ctor => VerifyParameters( ctor.GetParameters() , p => VerifyParameter <string>(p, prototype) , p => VerifyParameter <string>(p, description) ) ); }
public static FixtureResponse Get(FixtureType type, string name) { if (name.IsNullOrEmpty()) throw new ArgumentNullException("name"); if(!Enum.IsDefined(typeof(FixtureType), type)) throw new InvalidEnumArgumentException("type", (int)type, typeof(FixtureType)); var fixturePath = string.Format("fixtures/{0}/{1}.xml", type, name); if (!File.Exists(fixturePath)) throw new FileNotFoundException("Could not locate the fixture response file!", fixturePath); var contents = new List<string>(); using (var reader = new StreamReader(File.OpenRead(fixturePath))) { string line; while ((line = reader.ReadLine()) != null) contents.Add(line); } var response = new FixtureResponse(); var count = 0; for (; count < contents.Count; ++count) { var line = contents[count]; if (line.IsNullOrWhiteSpace()) continue; if (line.StartsWith("HTTP")) response.StatusCode = ParseStatusCode(line); else if (line.StartsWith("<")) break; else response.AddHeader(ParseHeader(line)); } var remainder = contents.Count - count; response.Xml = string.Join(Environment.NewLine, contents.ToArray(), count, remainder); return response; }
/// <summary> /// Initializes a new instance of the <see cref="Fixture"/> class. /// </summary> /// <param name="type">The type of this fixture.</param> protected Fixture(FixtureType type) { Type = type; }
private static void LoadLandset() { if (!DebugLoadExteriors) { return; } if (_exteriorFixtures == null) { LoadExteriorFixtures(); } if (_blueprints == null) { LoadExteriorBlueprints(); } string landSetPath = FFXIVHSPaths.GetWardLandsetJson(territory); if (!File.Exists(landSetPath)) { //Main and subdivision, 60 plots _landSet = new HousingExteriorStructure[60]; for (int i = 0; i < _landSet.Length; i++) { _landSet[i] = new HousingExteriorStructure(); int numFixtureTypes = Enum.GetValues(typeof(FixtureType)).Length; _landSet[i].fixtures = new int[numFixtureTypes]; } string jsonText = JsonConvert.SerializeObject(_landSet, Formatting.Indented); File.WriteAllText(landSetPath, jsonText); } else { string jsonText = File.ReadAllText(landSetPath); _landSet = JsonConvert.DeserializeObject <HousingExteriorStructure[]>(jsonText); } //TODO: move this, rewrite this ? for (int plotIndex = 0; plotIndex < _landSet.Length; plotIndex++) { Plot plotAt = GetPlot(_territory, plotIndex % 30 + 1, plotIndex > 29); if (_landSet[plotIndex].size == Size.s) { //Verify possibly unset size _landSet[plotIndex].size = plotAt.size; } if (_landSet[plotIndex].fixtures[(int)FixtureType.fnc - 1] == 0) { _landSet[plotIndex].fixtures[(int)FixtureType.fnc - 1] = DefaultFences.fnc[(int)_territory]; } HousingExteriorBlueprint blueprint = _blueprints.set[(int)_landSet[plotIndex].size]; //TODO: If you ever figure out how to tell which transforms are for which house size, fix this string groupName = "{0}_{1:D2}_{2}_house"; string fixedWardName = _territory.ToString().ToLower().Substring(0, _territory.ToString().Length - 1) + '0'; string strSize = _landSet[plotIndex].size.ToString(); groupName = string.Format(groupName, fixedWardName, plotIndex + 1, strSize); Debug.Log(groupName); GameObject parentPlotObject = GameObject.Find(groupName); //For each fixture in our landset element for (int fixtureIndex = 0; fixtureIndex < _landSet[plotIndex].fixtures.Length; fixtureIndex++) { if (_landSet[plotIndex].fixtures[fixtureIndex] == 0) { continue; } FixtureType fixtureType = (FixtureType)fixtureIndex + 1; FFXIVHSLib.Transform[][] transformsForModels = null; Mesh[][][] meshes = GetMeshesForExteriorFixture(_landSet[plotIndex].fixtures[fixtureIndex], ref transformsForModels); //For each variant for (int variantIndex = 0; variantIndex < meshes.Length; variantIndex++) { if (blueprint.fixtureTransforms[fixtureType][variantIndex] == null || meshes[variantIndex] == null) { continue; } //The set of gameobjects for this variant, 1 gameobject per model GameObject[] objects = new GameObject[meshes[variantIndex].Length]; for (int modelIndex = 0; modelIndex < objects.Length; modelIndex++) { objects[modelIndex] = AddMeshToNewGameObject(meshes[variantIndex][modelIndex]); } foreach (FFXIVHSLib.Transform t in blueprint.fixtureTransforms[fixtureType][variantIndex]) { GameObject variantBaseObject = new GameObject(); variantBaseObject.GetComponent <Transform>().SetParent(parentPlotObject.transform); variantBaseObject.GetComponent <Transform>().localPosition = t.translation; variantBaseObject.GetComponent <Transform>().localRotation = t.rotation; variantBaseObject.GetComponent <Transform>().localScale = t.scale; variantBaseObject.name = string.Format("bp{0}_ft{1}_v{2}", _landSet[plotIndex].size, fixtureType, variantIndex); for (int modelIndex = 0; modelIndex < objects.Length; modelIndex++) { if (objects[modelIndex] == null) { continue; } FFXIVHSLib.Transform modelTransform = transformsForModels[variantIndex][modelIndex]; GameObject addedModel = UnityEngine.Object.Instantiate(objects[modelIndex]); addedModel.GetComponent <Transform>().SetParent(variantBaseObject.GetComponent <Transform>()); addedModel.GetComponent <Transform>().localPosition = modelTransform.translation; addedModel.GetComponent <Transform>().localRotation = modelTransform.rotation; addedModel.GetComponent <Transform>().localScale = modelTransform.scale; addedModel.name = addedModel.name.Replace("(Clone)", "_") + string.Format("{0}_{1}_{2}", fixtureIndex, variantIndex, modelIndex); addedModel.SetActive(true); UnityEngine.Object.Destroy(objects[modelIndex]); } } } } } }
public virtual void Verify_Type_Is_Expected(Type expectedType) => Assert.Equal(expectedType.VerifyNotNull(), FixtureType.VerifyNotNull());
protected virtual void OnSetUp() { Fake.InitializeFixture(this); A.CallTo(() => this.fakeAndDummyManager.CreateFake(typeof(IFoo), A<FakeOptions>._)).Returns(this.fakeReturnedFromFakeAndDummyManager); this.fixture = new FixtureType(); }
public void Type_Is_Static() => Assert.True(FixtureType.AssertNotNull().IsStatic());
/// <summary> /// Returns a HousingExteriorBlueprintSet read from the small, medium, and large sgb paths in /// HousingExteriorBlueprintSet. /// </summary> /// <param name="realm"></param> /// <returns></returns> private static HousingExteriorBlueprintSet ReadExteriorBlueprintSet(ARealmReversed realm) { HousingExteriorBlueprintSet thisSet = new HousingExteriorBlueprintSet(); thisSet.set = new HousingExteriorBlueprint[HousingExteriorBlueprintSet.SgbPaths.Length]; for (int i = 0; i < HousingExteriorBlueprintSet.SgbPaths.Length; i++) { string thisPath = HousingExteriorBlueprintSet.SgbPaths[i]; HousingExteriorBlueprint thisBlueprint = new HousingExteriorBlueprint { size = (Size)i }; //These are hardcoded, double check they're there SaintCoinach.IO.File f; if (!realm.Packs.TryGetFile(thisPath, out f)) { throw new FileNotFoundException(); } SgbFile sgb = new SgbFile(f); foreach (SgbGroup group in sgb.Data.OfType <SgbGroup>()) { foreach (SgbGimmickEntry gim in group.Entries.OfType <SgbGimmickEntry>()) { string gimmickPath = gim.Gimmick.File.Path; /* * Group 1: s1h0 or opt * Group 2: size, dor/wid variant, f for fence, or opt's 2chars * Group 3: fixturetype or m for opt * Group 4: a/b/c/d for fence, . for all others */ Regex pattern = new Regex(@"asset\/(.*)?_(.{1,2})_(.{1,3})([0-9]{4})([a-z]|\.)"); Match m = pattern.Match(gimmickPath); if (!m.Success) { continue; } //Obtain fixture type string fType = m.Groups[3].Value; if (fType == "m") { fType = "o" + m.Groups[2].Value; } FixtureType fixtureType = (FixtureType)Enum.Parse(typeof(FixtureType), fType); //Obtains the variant string, examples: s, m, l, co, ca, ci, a, b, c, d string strVariant = m.Groups[5].Value == "." ? m.Groups[2].Value : m.Groups[5].Value; int variant = 0; //Attempt to parse group 2 into a Size to get variant if (!Enum.TryParse(strVariant, out Size fixtureSize)) { //If we can't parse variant to a size, we have to parse into a different fixture variant if (fixtureType == FixtureType.dor) { variant = (int)Enum.Parse(typeof(DoorVariants), strVariant); } else if (fixtureType == FixtureType.wid) { variant = (int)Enum.Parse(typeof(WindowVariants), strVariant); } else if (fixtureType == FixtureType.fnc) { variant = (int)Enum.Parse(typeof(FenceVariants), strVariant); } } else { //If rof/wal is not same size as blueprint, skip it if (fixtureSize != thisBlueprint.size) { continue; } } if (thisBlueprint.fixtureTransforms[fixtureType][variant] == null) { thisBlueprint.fixtureTransforms[fixtureType][variant] = new List <Transform>(); } List <Transform> listForVariant = thisBlueprint.fixtureTransforms[fixtureType][variant]; Transform t = TransformFromVectors(gim.Header.Translation, gim.Header.Rotation, gim.Header.Scale); listForVariant.Add(t); #region switch statement bad // switch (m.Groups[3].Value) // { // case nameof(FixtureType.rof): // if (m.Groups[2].Value == size.ToString()) // { // //exampe but cool // } // break; // case nameof(FixtureType.wal): // //Do stuff // break; // case nameof(FixtureType.wid): // //Do stuff // break; // case nameof(FixtureType.dor): // //Do stuff // break; // case "m": // switch ("o" + m.Groups[2].Value) // { // case nameof(FixtureType.orf): // //Do stuff // break; // case nameof(FixtureType.owl): // //Do stuff // break; // case nameof(FixtureType.osg): // //Do stuff // break; // } // break; // case nameof(FixtureType.fnc): // //Do stuff // break; // } #endregion } } /* * The transforms relevant to the current blueprint come first, * so figure out how many Transforms aren't for this size house * by checking how many transforms are collectively in the blueprints * below this size and variant, then remove that number of entries. */ if (i > 0) { int[][] numTransformsInSmallerBlueprints = new int[Enum.GetValues(typeof(FixtureType)).Length][]; //For every smaller blueprint for (int smallerBlueprintIndex = 0; smallerBlueprintIndex < i; smallerBlueprintIndex++) { //For every fixture type for (int fixtureTypeIndex = 0; fixtureTypeIndex < numTransformsInSmallerBlueprints.Length; fixtureTypeIndex++) { FixtureType fixtureType = (FixtureType)fixtureTypeIndex + 1; int numberOfVariants = HousingExteriorFixture.GetVariants(fixtureType); if (numTransformsInSmallerBlueprints[fixtureTypeIndex] == null) { numTransformsInSmallerBlueprints[fixtureTypeIndex] = new int[numberOfVariants]; } for (int variantIndex = 0; variantIndex < numberOfVariants; variantIndex++) { int?toAddn = thisSet.set[smallerBlueprintIndex].fixtureTransforms[fixtureType][variantIndex]?.Count; int toAdd = toAddn ?? 0; numTransformsInSmallerBlueprints[fixtureTypeIndex][variantIndex] += toAdd; } } } //Whoops, don't do it for fences for (int j = 0; j < numTransformsInSmallerBlueprints[(int)FixtureType.fnc - 1].Length; j++) { numTransformsInSmallerBlueprints[(int)FixtureType.fnc - 1][j] = 0; } //For every fixture type for (int fixtureTypeIndex = 0; fixtureTypeIndex < numTransformsInSmallerBlueprints.Length; fixtureTypeIndex++) { FixtureType fixtureType = (FixtureType)fixtureTypeIndex + 1; int numberOfVariants = HousingExteriorFixture.GetVariants(fixtureType); for (int variantIndex = 0; variantIndex < numberOfVariants; variantIndex++) { List <Transform> variantTransformsList = thisBlueprint.fixtureTransforms[fixtureType][variantIndex]; if (thisBlueprint.fixtureTransforms[fixtureType][variantIndex] == null) { continue; } if (variantTransformsList == null) { continue; } int numTransforms = variantTransformsList.Count; int difference = numTransforms - numTransformsInSmallerBlueprints[fixtureTypeIndex][variantIndex]; if (difference > 0) { List <Transform> newTransforms = new List <Transform>(); for (int tCount = 0; tCount < difference; tCount++) { newTransforms.Add(variantTransformsList[tCount]); } thisBlueprint.fixtureTransforms[fixtureType][variantIndex] = newTransforms; } } } } thisSet.set[i] = thisBlueprint; } return(thisSet); }
public static FixtureResponse Get(FixtureType type, string name) { if (name.IsNullOrEmpty()) { throw new ArgumentNullException("name"); } if (!Enum.IsDefined(typeof(FixtureType), type)) { throw new InvalidEnumArgumentException("type", (int)type, typeof(FixtureType)); } var fixturePath = string.Format("fixtures/{0}/{1}.xml", type, name); if (!File.Exists(fixturePath)) { throw new FileNotFoundException("Could not locate the fixture response file!", fixturePath); } var contents = new List <string>(); using (var reader = new StreamReader(File.OpenRead(fixturePath))) { string line; while ((line = reader.ReadLine()) != null) { contents.Add(line); } } var response = new FixtureResponse(); var count = 0; for (; count < contents.Count; ++count) { var line = contents[count]; if (line.IsNullOrWhiteSpace()) { continue; } if (line.StartsWith("HTTP")) { response.StatusCode = ParseStatusCode(line); } else if (line.StartsWith("<")) { break; } else { response.AddHeader(ParseHeader(line)); } } var remainder = contents.Count - count; response.Xml = string.Join(Environment.NewLine, contents.ToArray(), count, remainder); return(response); }