private PatternInfo GetOrCreatePatternInfo(int id, object provider,
string path,
CreateWrapperFromProvider wrapperCreator)
{
PatternInfo oldInfo;
if (patternMapping.TryGetValue(id, out oldInfo))
{
if (oldInfo.Provider == provider)
{
return(oldInfo);
}
}
object wrapper = wrapperCreator(provider);
PatternInfo newInfo = new PatternInfo {
Path = path,
Provider = provider,
ProviderWrapper = wrapper
};
patternMapping [id] = newInfo;
bus.Register(new ObjectPath(path), wrapper);
return(newInfo);
}
public CompiledPeg Compile(Pattern StartPattern)
{
var patternInfo = PatternInfo.Build(StartPattern);
var patternIndices = new Dictionary <Pattern, int>();
var compiledPatterns = new List <Method>();
var patternsToCompile = new List <Pattern>();
compiledPatterns.Add(null);
patternIndices[StartPattern] = 0;
patternsToCompile.Add(StartPattern);
foreach (var pattern in patternInfo.Keys)
{
if (pattern != StartPattern)
{
var patternId = patternIndices[pattern] = compiledPatterns.Count;
compiledPatterns.Add(null);
patternsToCompile.Add(pattern);
}
}
foreach (var pattern in patternsToCompile)
{
compiledPatterns[patternIndices[pattern]] = CompilePattern(pattern, patternInfo, patternIndices);
}
return(new CompiledPeg(compiledPatterns, 0));
}
public bool LoadPatternInfo(string programPath)
{
Stream fstream = null;
try
{
string extension = Path.GetExtension(programPath);
if (extension != ".pattern")
{
MessageBox.Show("请确认打开的是后缀为pattern的文件");
return(false);
}
fstream = new FileStream(programPath, FileMode.Open, FileAccess.Read);
BinaryFormatter binFormat = new BinaryFormatter();
this.currPInfo = (PatternInfo)binFormat.Deserialize(fstream);
return(true);
}
catch (Exception e)
{
//throw e;
return(false);
}
finally
{
if (fstream != null)
{
fstream.Close();
}
}
}
public Pattern GeneratePatternFromStruct(PatternInfo pInfo)
{
Pattern pattern = new Pattern();
pattern.mAcceleration = pInfo.Acceleration;
pattern.mSpeed = pInfo.Speed;
pattern.mArrayNumber = pInfo.ArrayNumber;
pattern.mBulletsPerArray = pInfo.BulletsPerArray;
pattern.mDirectionAngle = pInfo.DirectionAngle;
pattern.mFireRate = pInfo.FireRate;
pattern.mHitBox = new Rectangle(pInfo.HitBox[0],
pInfo.HitBox[1],
pInfo.HitBox[2],
pInfo.HitBox[3]);
pattern.mIndvArraySpread = pInfo.IndividualArraySpread;
pattern.mTotalArraySpread = pInfo.TotalArraySpread;
pattern.mRotationSpeed = pInfo.RotationSpeed;
pattern.mRotationSpeedDelta = pInfo.RotationSpeedDelta;
pattern.mMaxRotationSpeed = pInfo.MaxRotationSpeed;
pattern.mBoundedRotation = pInfo.BoundedRotation;
pattern.mMaxRotation = pInfo.MaxRotation;
pattern.mMinRotation = pInfo.MinRotation;
pattern.mFlipRotation = pInfo.FlipRotation;
pattern.SetBulletSpawner(mGameBulletSpawnerPtr);
pattern.mBulletType = pInfo.BulletType;
pattern.mBulletColor = pInfo.BulletColor;
pattern.mDirectional = pInfo.Directional;
return(pattern);
}
private static PatternInfo GetPatternDescriptionInfo(IElement root)
{
// Pattern info
var patternInfo = new PatternInfo();
var infoContainer = root.QuerySelector("div.set__info") as IHtmlDivElement;
if (infoContainer != null && !string.IsNullOrEmpty(infoContainer.InnerText))
{
var lines = infoContainer.InnerText.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
if (lines.Length >= 2)
{
patternInfo.Title = lines[0];
patternInfo.Description = infoContainer.InnerText.Replace(patternInfo.Title, string.Empty).TrimStart('.', ' ', '\n');
}
if (lines.Length == 1)
{
var singleLine = lines[0];
if (singleLine.ToLowerInvariant().Contains("размер"))
{
patternInfo.Description = singleLine;
}
else
{
patternInfo.Title = singleLine;
}
}
}
return(patternInfo);
}
/// <summary>
/// Initializes a new instance of the <see cref="BytesFinder"/> class for the specified bytes pattern.
/// </summary>
/// <param name="pattern">The bytes pattern to seek.</param>
/// <exception cref="ArgumentException"><paramref name="pattern"/> is null or empty.</exception>
public BytesFinder(byte[] pattern)
{
if (pattern == null || pattern.Length == 0)
{
throw new ArgumentException("pattern is null or empty.", nameof(pattern));
}
_mPattInfo = new PatternInfo(pattern);
}
/// <summary>
/// Initializes a new instance of the <see cref="BytesFinder"/> class for the specified <see cref="string"/> pattern.
/// </summary>
/// <param name="pattern">The <see cref="string"/> pattern to seek.</param>
/// <exception cref="ArgumentNullException"><paramref name="pattern"/> is null.</exception>
/// <exception cref="FormatException">
/// The length of <paramref name="pattern"/> is 0 or not equal to this value division by 2.
/// <para>- Or -</para>
/// Unexpected char in <paramref name="pattern"/>.
/// </exception>
public BytesFinder(string pattern)
{
if (pattern == null)
{
throw new ArgumentNullException(nameof(pattern), "pattern is null.");
}
_mPattInfo = new PatternInfo(pattern.Replace(" ", string.Empty)); //remove placeholder
}
public void Assert_ReturnOneIf100()
{
PatternInfo info = m_lib.GetPatternInfo(100, 100);
Assert.AreEqual(1, info.patternCount);
Assert.AreEqual("O", info.defaultMode);
Assert.AreEqual("H", info.alternateMode);
}
public static PatternInfo getRandomPattern()
{
PatternInfo info = new PatternInfo();
// for simplify, NumElementsPerLine must be multiplied by width and height of array
info.NumElementsPerBlock = 4;
info.PatternData = generateRandomPattern();// pattern1;
return(info);
}
public PatternInfo Build()
{
var result = new PatternInfo();
result.BarsCount = GetValueOrFail(barsCount, nameof(barsCount));
result.BeatsPerBar = GetValueOrFail(beatsPerBar, nameof(beatsPerBar));
result.SuggestedBpm = GetValueOrFail(suggestedBpm, nameof(suggestedBpm));
result.UnitsPerBeat = GetValueOrFail(unitsPerBeat, nameof(unitsPerBeat));
return(result);
}
private void PerformUnregisterPattern(PatternInfo info)
{
bus.Unregister(new ObjectPath(info.Path));
var disposable = info.ProviderWrapper as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
/// <summary>
/// Reports the zero-based index of the first occurrence of the specified pattern in the specified bytes source.
/// The search starts at the specified position and examines a specified number of <see cref="byte"/> positions.
/// </summary>
/// <param name="source">The bytes to search for an occurrence.</param>
/// <param name="pattern">The bytes pattern to seek.</param>
/// <param name="startIndex">The search starting position.</param>
/// <param name="count">The number of <see cref="byte"/> positions to examine.</param>
/// <returns>The zero-based index position of the occurrence if the <paramref name="pattern"/> is found, otherwise, -1.</returns>
/// <exception cref="ArgumentException">
/// <paramref name="source"/> is null or empty.
/// <para>- Or -</para>
/// <paramref name="pattern"/> is null or empty.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="startIndex"/> is less than 0.
/// <para>- Or -</para>
/// <paramref name="startIndex"/> is greater than or equal to the length of <paramref name="source"/>.
/// <para>- Or -</para>
/// <paramref name="count"/> is less than or equal to 0.
/// <para>- Or -</para>
/// <paramref name="count"/> is greater than the length of source minus <paramref name="startIndex"/>.
/// </exception>
public static int FindIndex(byte[] source, byte[] pattern, int startIndex, int count)
{
if (pattern == null || pattern.Length == 0)
{
throw new ArgumentException("pattern is null or empty.", nameof(pattern));
}
Ensure_source_startIndex_count(source, startIndex, count);
using (var pattInfo = new PatternInfo(pattern))
{
return(InnerFindIndex(source, in pattInfo, startIndex, count));
}
}
/// <summary>
/// Reports the zero-based index of the first occurrence of the specified pattern in the specified bytes source.
/// </summary>
/// <param name="source">The bytes to search for an occurrence.</param>
/// <param name="pattern">The bytes pattern to seek.</param>
/// <returns>The zero-based index position of the occurrence if the <paramref name="pattern"/> is found, otherwise, -1.</returns>
/// <exception cref="ArgumentException">
/// <paramref name="source"/> is null or empty.
/// <para>- Or -</para>
/// <paramref name="pattern"/> is null or empty.
/// </exception>
public static int FindIndex(byte[] source, byte[] pattern)
{
if (source == null || source.Length == 0)
{
throw new ArgumentException("source is null or empty.", nameof(source));
}
if (pattern == null || pattern.Length == 0)
{
throw new ArgumentException("pattern is null or empty.", nameof(pattern));
}
using (var pattInfo = new PatternInfo(pattern))
{
return(InnerFindIndex(source, in pattInfo, 0, source.Length));
}
}
private void TranslateScript(XElement schSchema, OCLScript oclScript, TranslationSettings translationSettings,
ref Dictionary <PSMClass, List <PatternInfo> > patterns)
{
OclCompilerResult compilerResult = oclScript.CompileToAst();
compilerResult.CompileExpressionsInMessages();
if (!compilerResult.Errors.HasError)
{
XComment comment = new XComment(string.Format("Below follow constraints from OCL script '{0}'. ", oclScript.Name));
schSchema.Add(comment);
foreach (ClassifierConstraintBlock classifierConstraintBlock in compilerResult.Constraints.ClassifierConstraintBlocks)
{
PSMClass contextClass = (PSMClass)classifierConstraintBlock.Context.Tag;
patterns.CreateSubCollectionIfNeeded(contextClass);
string patternName = NameSuggestor <PatternInfo> .SuggestUniqueName(patterns[contextClass], contextClass.Name, p => p.PatternName, true, false);
PatternInfo patternInfo = new PatternInfo {
PatternName = patternName
};
XElement patternElement = schSchema.SchematronPattern(patternInfo.PatternName);
patterns[contextClass].Add(patternInfo);
bool abstractPattern = !contextClass.GeneralizationsAsGeneral.IsEmpty();
if (abstractPattern)
{
patternElement.AddAttributeWithValue("abstract", "true");
}
string context = !abstractPattern?contextClass.GetXPathFull(true).ToString() : "$" + classifierConstraintBlock.Self.Name;
XElement ruleElement = patternElement.SchematronRule(context);
patternInfo.ContextVariableName = classifierConstraintBlock.Self.Name;
if (!abstractPattern)
{
ruleElement.SchematronLet(patternInfo.ContextVariableName, @".");
}
TranslateInvariantsToXPath(classifierConstraintBlock, ruleElement, (PSMBridge)compilerResult.Bridge, translationSettings);
}
}
else
{
XComment comment = new XComment(string.Format("OCL script '{0}' contains errors and thus can not be translated. ", oclScript.Name));
schSchema.Add(comment);
}
}
private void AssertReturnValueWhenTarget(decimal target, int populationSize, PatternInfo returnValue)
{
PatternInfo info = m_lib.GetPatternInfo(target, populationSize);
Assert.AreEqual(returnValue.patternCount, info.patternCount);
Assert.AreEqual(returnValue.defaultMode, info.defaultMode);
Assert.AreEqual(returnValue.alternateMode, info.alternateMode);
if (returnValue.defaultMode.Equals("O"))
{
Assert.IsTrue((1 / returnValue.patternCount) <= target);
}
else
{
Assert.IsTrue((1 - (1 / returnValue.patternCount)) <= target);
}
}
public void Assert_ThrowErrorIfMoreThan100()
{
// when
string error = "";
try
{
PatternInfo info = m_lib.GetPatternInfo((decimal)100.01, 100);
}
catch (Exception ex)
{
error = ex.Message;
}
// then
Assert.IsFalse(string.IsNullOrEmpty(error));
}
public static Pattern GetRandomClothingPattern(Sim sim)
{
ResourceKey reskeyPattern;
SewingSkill sewingSkill = sim.SkillManager.AddElement(SewingSkill.kSewingSkillGUID) as SewingSkill;
do
{
reskeyPattern = RandomUtil.GetRandomObjectFromList(ObjectLoader.mStoredClothingPattern);
if (!SewingSkill.HasAlreadyDiscoveredThis(sim.mSimDescription.mSimDescriptionId, reskeyPattern))
{
break;
}
}while (true);
if (reskeyPattern != ResourceKey.kInvalidResourceKey)
{
PatternInfo mPatternInfoInit = new PatternInfo();
mPatternInfoInit.resKeyPattern = reskeyPattern;
ObjectLoader.sewableSetting sSetting = ObjectLoader.dictSettings[reskeyPattern];
mPatternInfoInit.fabricsNeeded = sSetting.typeFabric;
mPatternInfoInit.IsMagic = sSetting.isMagicProject;
mPatternInfoInit.amountOfFabricToRemove = sSetting.amountRemoveFabric;
mPatternInfoInit.isClothing = sSetting.isClothing;
mPatternInfoInit.mClothingName = sSetting.clothingName;
mPatternInfoInit.mWasPatternGifted = false;
if (mPatternInfoInit.isClothing)
{
mPatternInfoInit.mSimOutfit = new CASPart(mPatternInfoInit.resKeyPattern);
}
ResourceKey reskey1 = new ResourceKey(0x19D4F5930F26B2D8, 0x319E4F1D, 0x00000000);
Pattern.PatternObjectInitParams initData = new Pattern.PatternObjectInitParams(mPatternInfoInit.fabricsNeeded, mPatternInfoInit.IsMagic, mPatternInfoInit.amountOfFabricToRemove, mPatternInfoInit.mSkilllevel, mPatternInfoInit.resKeyPattern, mPatternInfoInit.isClothing, mPatternInfoInit.mSimOutfit, mPatternInfoInit.mClothingName, mPatternInfoInit.mWasPatternGifted);
Pattern pattern = (Pattern)GlobalFunctions.CreateObjectOutOfWorld(reskey1, null, initData);
mPatternInfoInit.Name = mPatternInfoInit.mClothingName;
pattern.NameComponent.SetName(mPatternInfoInit.mClothingName);
pattern.mPatternInfo = mPatternInfoInit;
sim.Inventory.TryToAdd(pattern);
sewingSkill.AddPatternCount(1);
return(pattern);
}
return(null);
}
private static int GetNumberOfPatternsToGenerate()
{
ISchedulerLibrary lib = new SchedulerLibrary();
PatternInfo pattern = lib.GetPatternInfo(m_target.Value, m_populationSize.Value);
m_isDefaultWorkFromHome = pattern.defaultMode.Equals("H");
m_default = pattern.defaultMode;
m_alternate = pattern.alternateMode;
Console.WriteLine(string.Format("Number of patterns to generate : {0}", Math.Abs(pattern.patternCount)));
Console.WriteLine(string.Format("Default working mode is (O for office, H for Home): {0}", m_default));
decimal effective = m_isDefaultWorkFromHome ? (100 / Math.Abs(pattern.patternCount)) : 100 - (100 / pattern.patternCount);
Console.WriteLine(string.Format("Max number of people in office will be : {0:N2}%", effective));
return(Math.Abs(pattern.patternCount));
}
public GridDrawer(Settings settings, PatternInfo patternInfo, int subdivisions, IInstrumentId[] instruments)
{
if (patternInfo.UnitsPerBeat.Index % subdivisions != 0)
{
throw new ArgumentException("Subdivision not compatible with pattern");
}
timeUnitWidth = (int)Math.Round(settings.BeatWidth / (float)patternInfo.UnitsPerBeat.Index);
settings.BeatWidth = timeUnitWidth * patternInfo.UnitsPerBeat.Index;
this.settings = settings;
this.info = patternInfo;
this.instruments = instruments;
this.subdivisions = subdivisions;
this.textPaint = BuildInstrumentNamePaint();
this.gridRect = BuildGridRect();
this.gridPaints = BuildGridPaints();
this.backgroundPaint = BuildBackgroudPaint();
}
public static CrossStitchPatternModel Parse(IElement root, Uri uri)
{
var model = new CrossStitchPatternModel();
var id = GetId(root, uri);
ItemImage image = GetImageInfo(root, uri);
PatternAuthor author = GetAuthorInfo(root, id.ToString());
PatternInfo patternInfo = GetPatternDescriptionInfo(root);
PatternPrice patternPrice = GetPriceInfo(root);
PatternDistributionStatus status = GetStatus(root, patternPrice);
//
model.PatternId = id;
model.Image = image;
model.Author = author;
model.Info = patternInfo;
model.PriceInfo = patternPrice;
model.Status = status;
return(model);
}
IEnumerator RunPattern(PatternInfo pattern)
{
float elapstedTime = pattern.summonInterval;
int Count = 0;
while (pattern.data.Length > Count)
{
elapstedTime += Time.deltaTime;
if (elapstedTime >= pattern.summonInterval)
{
SummonWindow(pattern.data[Count]);
elapstedTime -= pattern.summonInterval;
++Count;
}
yield return(null);
}
yield return(new WaitForSeconds(pattern.coolTime));
onPatternEnd?.Invoke();
}
/// <summary>
/// Associates a marker with an identifier so that the identifier can be used to find this
/// marker after processing the image.
/// </summary>
/// <param name="markerConfigs">A set of parameters that identifies a maker. (e.g., for
/// ARTag, this parameter would be the marker array name or marker ID)</param>
/// <returns>An identifier for this marker object</returns>
public Object AssociateMarker(params Object[] markerConfigs)
{
// make sure we are initialized
if (!initialized)
throw new MarkerException("ARToolkitTracker is not initialized. Call InitTracker(...)");
if (!(markerConfigs.Length == 2 || markerConfigs.Length == 5))
throw new MarkerException(GetAssocMarkerUsage());
MarkerInfo markerInfo = new MarkerInfo();
if (markerConfigs.Length == 2)
{
string arrayName = "";
ComputationMethod method = ComputationMethod.Average;
try
{
arrayName = (String)markerConfigs[0];
method = (ComputationMethod)markerConfigs[1];
}
catch (Exception)
{
throw new MarkerException(GetAssocMarkerUsage());
}
ParseArray(arrayName, ref markerInfo);
markerInfo.Method = method;
}
else
{
int pattWidth = 0, pattHeight = 0;
float pattSize = 0, conf = 0;
String pattName = "";
try
{
pattName = (String)markerConfigs[0];
pattWidth = (int)markerConfigs[1];
pattHeight = (int)markerConfigs[2];
pattSize = (float)markerConfigs[3];
conf = (float)markerConfigs[4];
}
catch (Exception)
{
throw new MarkerException(GetAssocMarkerUsage());
}
NyARCode code = new NyARCode(pattWidth, pattHeight);
code.loadARPatt(new System.IO.StreamReader(TitleContainer.OpenStream(pattName)));
codes.Add(code);
pattSizes.Add(pattSize);
PatternInfo info = new PatternInfo();
info.ConfidenceThreshold = conf;
int id = codes.Count - 1;
markerInfo.PatternInfos.Add(id, info);
markerInfo.RelativeTransforms.Add(id, Matrix.Identity);
markerInfo.Method = ComputationMethod.Average;
markerInfoMap.Add(id, markerInfo);
}
markerInfoList.Add(markerInfo);
// reinitialize the multi marker detector if the programmer adds new marker node
// after the initialization phase
if (started)
{
multiDetector = new MarkerDetector(param, codes.ToArray(), pattSizes.ToArray(),
codes.Count, raster.getBufferType());
multiDetector.setContinueMode(continuousMode);
}
return markerInfo;
}
private bool Match(DynamicBuffer <Pattern> pattern, ref PatternInfo patternInfo,
int2 gridPos, NativeArray <int> matchedBlocks)
{
var level = levelBufferLookup[levelInfo.entity];
var blockToMatch = level[MathHelpers.To1D(gridPos, levelInfo.size.x)];
var height = patternInfo.size.y;
var width = patternInfo.size.x;
var matchAll = true;
var blockMatched = 0;
for (int patternY = 0; patternY < height; ++patternY)
{
for (int patternX = 0; patternX < width; ++patternX)
{
// First : loop on the pattern to get the position in the level
// from which to start the pattern match
matchAll = true;
blockMatched = 0;
var patternOffset = new int2(patternX, patternY);
var levelStart = gridPos - patternOffset;
for (int levelY = 0; levelY < height; ++levelY)
{
for (int levelX = 0; levelX < width; ++levelX)
{
// Second : loop on the pattern and level at the same time to check if block match
var localPos = new int2(levelX, levelY);
var blockPos = levelStart + localPos;
if (blockPos.x < 0 || blockPos.x >= levelInfo.size.x ||
blockPos.y < 0 || blockPos.y >= levelInfo.size.y
)
{
matchAll = false;
break;
}
var levelBufferId = MathHelpers.To1D(blockPos, levelInfo.size.x);
var block = level[levelBufferId];
var shouldMatch = pattern[MathHelpers.To1D(localPos, width)].match;
var matchThis = !shouldMatch || block.blockId == blockToMatch.blockId;
matchAll = matchAll && matchThis;
if (matchThis && shouldMatch)
{
matchedBlocks[blockMatched] = levelBufferId + 1;
blockMatched++;
}
// Debug.Log($"Pos : {blockPos} | Local : {localPos} | Should match ? {shouldMatch} | Match {blockToMatch.blockId} with {block.blockId} | Match this ? {matchThis} | All ? {matchAll}");
// TODO break early if no match
}
}
if (matchAll)
{
break;
}
}
if (matchAll)
{
break;
}
}
// Debug.Log($"Match ? {matchAll}");
return(matchAll);
}
private void ParseArray(string arrayName, ref MarkerInfo markerInfo)
{
XElement markerArray = XElement.Load(@"" + arrayName);
int pattWidth = 0, pattHeight = 0;
float pattSize = 0, conf = 0;
String pattName = "";
Vector3 upperLeftCorner = Vector3.Zero;
string[] tmp = null;
foreach (XElement markerElement in markerArray.Elements("marker"))
{
try
{
pattName = markerElement.Attribute("patternName").Value;
pattWidth = int.Parse(markerElement.Attribute("patternWidth").Value);
pattHeight = int.Parse(markerElement.Attribute("patternHeight").Value);
pattSize = float.Parse(markerElement.Attribute("patternSize").Value);
conf = float.Parse(markerElement.Attribute("confidence").Value);
tmp = markerElement.Attribute("upperLeftCorner").Value.Split(',');
upperLeftCorner.X = -float.Parse(tmp[0]);
upperLeftCorner.Y = float.Parse(tmp[1]);
}
catch (Exception exp)
{
throw new MarkerException("Wrong marker array format: " + exp.Message);
}
NyARCode code = new NyARCode(pattWidth, pattHeight);
code.loadARPatt(new System.IO.StreamReader(TitleContainer.OpenStream(pattName)));
codes.Add(code);
pattSizes.Add(pattSize);
PatternInfo info = new PatternInfo();
info.ConfidenceThreshold = conf;
int id = codes.Count - 1;
markerInfo.PatternInfos.Add(id, info);
markerInfo.RelativeTransforms.Add(id, Matrix.CreateTranslation(upperLeftCorner));
markerInfoMap.Add(id, markerInfo);
}
}
private PatternInfo DecodePattern()
{
var result = new PatternInfo();
int level = 0;
bool flag = true;
while (flag)
{
if (_currentIndex >= _runningDna.Length)
{
lock (_runningMutex)
{
_state = RunningState.Stoped;
return null;
}
}
if (_runningDna.HasPatternAtPosition(
new[]
{
"C"
},
_currentIndex))
{
++_currentIndex;
result.AppendBack('I');
continue;
}
if (_runningDna.HasPatternAtPosition(
new[]
{
"F"
},
_currentIndex))
{
++_currentIndex;
result.AppendBack('C');
continue;
}
if (_runningDna.HasPatternAtPosition(
new[]
{
"P"
},
_currentIndex))
{
++_currentIndex;
result.AppendBack('F');
continue;
}
if (_runningDna.HasPatternAtPosition(
new[]
{
"IC"
},
_currentIndex))
{
_currentIndex += 2;
result.AppendBack('P');
continue;
}
if (_runningDna.HasPatternAtPosition(
new[]
{
"IP"
},
_currentIndex))
{
_currentIndex += 2;
int number = DecodeNumber();
result.AppendSkip(number);
continue;
}
if (_runningDna.HasPatternAtPosition(
new[]
{
"IF"
},
_currentIndex))
{
_currentIndex += 3;
string consts = DecodeConsts();
result.AppendSearch(consts);
continue;
}
if (_runningDna.HasPatternAtPosition(
new[]
{
"IIP"
},
_currentIndex))
{
_currentIndex += 3;
++level;
result.IncreaseLevel();
continue;
}
if (_runningDna.HasPatternAtPosition(
new[]
{
"IIC", "IIF"
},
_currentIndex))
{
_currentIndex += 3;
if (level == 0)
{
flag = false;
continue;
}
--level;
result.DecreaseLevel();
continue;
}
if (_runningDna.HasPatternAtPosition(
new[]
{
"III"
},
_currentIndex))
{
string toRna = _runningDna.Substring(_currentIndex + 3, 7).ToString();
OutputToRna(toRna);
_currentIndex += 10;
continue;
}
// Else stop.
lock (_runningMutex)
{
_state = RunningState.Stoped;
return null;
}
}
return result;
}
private void PerformUnregisterPattern (PatternInfo info)
{
bus.Unregister (new ObjectPath (info.Path));
var disposable = info.ProviderWrapper as IDisposable;
if (disposable != null)
disposable.Dispose ();
}
public void Assert_Returns4If79()
{
PatternInfo expected = new PatternInfo(4, "O", "H");
AssertReturnValueWhenTarget((decimal)79.0, 100, expected);
}
public void Assert_Returns6If85()
{
PatternInfo expected = new PatternInfo(6, "O", "H");
AssertReturnValueWhenTarget((decimal)85.0, 100, expected);
}
private void ParseArray(string arrayName, ref MarkerInfo markerInfo)
{
XElement markerArray = XElement.Load(@"" + arrayName);
float pattSize = 0;
int pattId;
Vector3 center = Vector3.Zero;
string[] tmp = null;
foreach (XElement markerElement in markerArray.Elements("marker"))
{
try
{
pattId = int.Parse(markerElement.Attribute("patternId").Value);
pattSize = float.Parse(markerElement.Attribute("patternSize").Value);
tmp = markerElement.Attribute("center").Value.Split(',');
center.X = -float.Parse(tmp[0]);
center.Y = float.Parse(tmp[1]);
}
catch (Exception exp)
{
throw new MarkerException("Wrong marker array format: " + exp.Message);
}
IdCode code = new IdCode();
code.Id = pattId;
code.Size = pattSize;
code.MID = markerSystem.addNyIdMarker(code.Id, code.Size);
codes.Add(code);
pattSizes.Add(pattSize);
PatternInfo info = new PatternInfo();
markerInfo.PatternInfos.Add(code.MID, info);
markerInfo.RelativeTransforms.Add(code.MID, Matrix.CreateTranslation(center));
markerInfo.Method = ComputationMethod.Average;
markerInfoMap.Add(code.MID, markerInfo);
}
}
public object AssociateMarker(params object[] markerConfigs)
{
// make sure we are initialized
if (!initialized)
throw new MarkerException("NewNyAR is not initialized. Call InitTracker(...)");
if (!(markerConfigs.Length == 2 || markerConfigs.Length == 5))
throw new MarkerException("Problem in AssociateMarker in NewNyAR");
MarkerInfo markerInfo = new MarkerInfo();
if (markerConfigs.Length == 2)
{
string arrayName = "";
ComputationMethod method = ComputationMethod.Average;
try
{
arrayName = (String)markerConfigs[0];
method = (ComputationMethod)markerConfigs[1];
}
catch (Exception exception)
{
throw new MarkerException("Problem in AssociateMarker in NewNyAR");
}
ParseArray(arrayName, ref markerInfo);
markerInfo.Method = method;
}
else
{
float pattSize = 0, conf = 0;
String pattId = "";
try
{
pattId = (String)(markerConfigs[0]);
pattSize = (float)markerConfigs[3];
conf = (float)markerConfigs[4];
}
catch (Exception)
{
throw new MarkerException("Problem in AssociateMarker in NewNyAR");
}
IdCode code = new IdCode();
code.Id = int.Parse(pattId);
code.Size = pattSize;
code.MID = markerSystem.addNyIdMarker(code.Id, code.Size);
codes.Add(code);
pattSizes.Add(pattSize);
PatternInfo info = new PatternInfo();
info.ConfidenceThreshold = conf;
markerInfo.PatternInfos.Add(code.MID, info);
markerInfo.RelativeTransforms.Add(code.MID, Matrix.Identity);
markerInfo.Method = ComputationMethod.Average;
markerInfoMap.Add(code.MID, markerInfo);
}
markerInfoList.Add(markerInfo);
/*
// reinitialize the multi marker detector if the programmer adds new marker node
// after the initialization phase
if (started)
{
}
* */
return markerInfo;
}
public static Pattern DiscoverPattern(Sim actor)
{
//int skillLevel = actor.SkillManager.GetSkillLevel(SewingSkill.kSewingSkillGUID);
ResourceKey getPattern = GetUnregisteredpattern(actor, false);
ResourceKey emptyRes = new ResourceKey(0uL, 0u, 0u);
PatternInfo mPatternInfoInit = new PatternInfo();
SewingSkill sewingSkill = actor.SkillManager.AddElement(SewingSkill.kSewingSkillGUID) as SewingSkill;
try
{
ObjectLoader.sewableSetting sSetting = ObjectLoader.dictSettings[getPattern];
mPatternInfoInit.resKeyPattern = getPattern;
mPatternInfoInit.fabricsNeeded = sSetting.typeFabric;
mPatternInfoInit.IsMagic = sSetting.isMagicProject;
mPatternInfoInit.amountOfFabricToRemove = sSetting.amountRemoveFabric;
mPatternInfoInit.isClothing = sSetting.isClothing;
mPatternInfoInit.mClothingName = sSetting.clothingName;
mPatternInfoInit.mWasPatternGifted = false;
//mPatternInfoInit.mSkilllevel = 0;
if (mPatternInfoInit.isClothing)
{
mPatternInfoInit.mSimOutfit = new CASPart(mPatternInfoInit.resKeyPattern);
}
// Pattern OBJD key.
ResourceKey reskey1 = new ResourceKey(0x19D4F5930F26B2D8, 0x319E4F1D, 0x00000000);
Pattern.PatternObjectInitParams initData = new Pattern.PatternObjectInitParams(mPatternInfoInit.fabricsNeeded, mPatternInfoInit.IsMagic, mPatternInfoInit.amountOfFabricToRemove, mPatternInfoInit.mSkilllevel, mPatternInfoInit.resKeyPattern, mPatternInfoInit.isClothing, mPatternInfoInit.mSimOutfit, mPatternInfoInit.mClothingName, mPatternInfoInit.mWasPatternGifted);
Pattern pattern = (Pattern)GlobalFunctions.CreateObjectOutOfWorld(reskey1, null, initData);
if (pattern.GetType() == typeof(FailureObject))
{
return(null);
}
if (pattern != null)
{
IGameObject getname = (GameObject)GlobalFunctions.CreateObjectOutOfWorld(mPatternInfoInit.resKeyPattern, null, initData);
if (getname != null)
{
// Currently uses the pattern object's name. We need to concatinate the sewable's name here as well. Since EA never made a function to get the name direction from the resource key, we need to do this.
mPatternInfoInit.Name = pattern.GetLocalizedName() + ": " + getname.GetLocalizedName();
pattern.NameComponent.SetName(pattern.GetLocalizedName() + ": " + getname.GetLocalizedName());
// Now we finally got the name and can destroy the object.
getname.Destroy();
}
SimDescription desc = actor.SimDescription;
pattern.mPatternInfo = mPatternInfoInit;
SewingSkill.AddItemsToDiscoveredList(desc.mSimDescriptionId, mPatternInfoInit.resKeyPattern);
actor.Inventory.TryToAdd(pattern);
sewingSkill.AddPatternCount(1);
return(pattern);
}
else if (pattern != null && mPatternInfoInit.isClothing)
{
mPatternInfoInit.Name = mPatternInfoInit.mClothingName;
pattern.NameComponent.SetName(mPatternInfoInit.mClothingName);
pattern.mPatternInfo = mPatternInfoInit;
actor.Inventory.TryToAdd(pattern);
sewingSkill.AddPatternCount(1);
return(pattern);
}
else
{
GlobalOptionsSewingTable.print("Lyralei's Sewing table: \n \n The pattern doesn't exist! Did you delete things from the sewing table .package? Else, contact Lyralei.");
return(null);
}
}
catch (Exception ex2)
{
GlobalOptionsSewingTable.print("Lyralei's Sewing table: \n \n REPORT THIS TO LYRALEI: " + ex2.ToString());
return(null);
}
}
public int Compare(string pattern1, string pattern2)
{
PatternInfo info1 = new PatternInfo(pattern1);
PatternInfo info2 = new PatternInfo(pattern2);
if (info1.IsLeastSpecific && info2.IsLeastSpecific)
{
return(0);
}
else if (info1.IsLeastSpecific)
{
return(1);
}
else if (info2.IsLeastSpecific)
{
return(-1);
}
bool pattern1EqualsPath = pattern1.Equals(path);
bool pattern2EqualsPath = pattern2.Equals(path);
if (pattern1EqualsPath && pattern2EqualsPath)
{
return(0);
}
else if (pattern1EqualsPath)
{
return(-1);
}
else if (pattern2EqualsPath)
{
return(1);
}
if (info1.IsPrefixPattern && info2.DoubleWildcards == 0)
{
return(1);
}
else if (info2.IsPrefixPattern && info1.DoubleWildcards == 0)
{
return(-1);
}
if (info1.TotalCount != info2.TotalCount)
{
return(info1.TotalCount - info2.TotalCount);
}
if (info1.Length != info2.Length)
{
return(info2.Length - info1.Length);
}
if (info1.SingleWildcards < info2.SingleWildcards)
{
return(-1);
}
else if (info2.SingleWildcards < info1.SingleWildcards)
{
return(1);
}
if (info1.UriVars < info2.UriVars)
{
return(-1);
}
else if (info2.UriVars < info1.UriVars)
{
return(1);
}
return(0);
}
private PatternInfo GetOrCreatePatternInfo (int id, object provider,
string path,
CreateWrapperFromProvider wrapperCreator)
{
PatternInfo oldInfo;
if (patternMapping.TryGetValue (id, out oldInfo)) {
if (oldInfo.Provider == provider)
return oldInfo;
}
object wrapper = wrapperCreator (provider);
PatternInfo newInfo = new PatternInfo {
Path = path,
Provider = provider,
ProviderWrapper = wrapper
};
patternMapping [id] = newInfo;
bus.Register (new ObjectPath (path), wrapper);
return newInfo;
}
private void MatchReplace(PatternInfo pattern, TemplateInfo template)
{
long index = _currentIndex;
var environment = new List<StringManager>();
var counters = new List<int>();
foreach (PatternItemInfo pat in pattern)
{
if (pat.IsBase)
{
if (index >= _runningDna.Length)
return;
if (_runningDna.HasPatternAtPosition(
new[]
{
new string(pat.Symbol, 1)
},
(int) index))
++index;
else
return;
continue;
}
if (pat.IsSkip)
{
index += pat.SkipCount;
if (index >= _runningDna.Length)
return;
continue;
}
if (pat.IsSearch)
{
int patterIndex = _runningDna.IndexOf(pat.SearchPattern, (int) index);
if (patterIndex != -1)
index = patterIndex + pat.SearchPattern.Length;
else
return;
continue;
}
if (pat.IsLevelUp)
{
counters.Insert(0, (int) index);
continue;
}
if (pat.IsLevelDown)
{
environment.Add(_runningDna.Substring(counters[0], (int) index - counters[0]));
counters.RemoveAt(0);
continue;
}
}
_currentIndex = (int) index;
Replace(template, environment);
}
public void ToYaml(MaterialAnim materialAnim, FMAA.AnimationType animType)
{
MaterialAnimConfigs = new List <MatAnimConfig>();
Name = materialAnim.Name;
Path = materialAnim.Path;
FrameCount = materialAnim.FrameCount;
Loop = materialAnim.Loop;
foreach (var mat in materialAnim.MaterialAnimDataList)
{
MatAnimConfig matConfig = new MatAnimConfig();
matConfig.Name = mat.Name;
MaterialAnimConfigs.Add(matConfig);
foreach (var paramInfo in mat.ParamAnimInfos)
{
ParamInfo paramCfg = new ParamInfo();
paramCfg.Name = paramInfo.Name;
paramCfg.IsConstant = paramInfo.ConstantCount != 0;
matConfig.ParamInfos.Add(paramCfg);
if (paramInfo.ConstantCount != 0)
{
paramCfg.Constants = new List <ConstantConfig>();
for (int i = 0; i < paramInfo.ConstantCount; i++)
{
AnimConstant constant = mat.Constants[paramInfo.BeginConstant + i];
ConstantConfig ConstantValue = new ConstantConfig();
ConstantValue.Offset = ConvertParamOffset(constant.AnimDataOffset, animType);
ConstantValue.Value = constant.Value;
paramCfg.Constants.Add(ConstantValue);
}
}
if (paramInfo.BeginCurve != ushort.MaxValue)
{
paramCfg.CurveData = new List <CurveConfig>();
for (int i = 0; i < paramInfo.IntCurveCount + paramInfo.FloatCurveCount; i++)
{
var curve = mat.Curves[(int)paramInfo.BeginCurve + i];
var CurveCfg = new CurveConfig();
CurveCfg.Offset = ConvertParamOffset(curve.AnimDataOffset, animType);
if (curve.Scale == 0)
{
curve.Scale = 1;
}
for (int f = 0; f < curve.Frames.Length; f++)
{
int frame = (int)curve.Frames[f];
float Value = curve.Offset + curve.Keys[f, 0] * curve.Scale;
CurveCfg.KeyFrames.Add(frame, Value);
}
paramCfg.CurveData.Add(CurveCfg);
}
}
}
foreach (var patternInfo in mat.TexturePatternAnimInfos)
{
PatternInfo infoCfg = new PatternInfo();
infoCfg.Name = patternInfo.Name;
infoCfg.IsConstant = patternInfo.BeginConstant != ushort.MaxValue;
matConfig.TexturePatternInfos.Add(infoCfg);
if (infoCfg.IsConstant)
{
infoCfg.ConstantValue = new ConstantTPConfig();
int Index = (int)mat.Constants[(int)patternInfo.BeginConstant].Value;
infoCfg.ConstantValue.Texture = materialAnim.TextureNames[Index];
}
if (patternInfo.CurveIndex != ushort.MaxValue)
{
var curve = mat.Curves[(int)patternInfo.CurveIndex];
infoCfg.CurveData = new CurveTPConfig();
if (curve.Scale == 0)
{
curve.Scale = 1;
}
for (int f = 0; f < curve.Frames.Length; f++)
{
int frame = (int)curve.Frames[f];
int Value = (int)curve.Offset + (int)curve.Keys[f, 0] * (int)curve.Scale;
infoCfg.CurveData.KeyFrames.Add(frame, materialAnim.TextureNames[Value]);
}
}
}
}
}
public void Assert_Return5If80()
{
PatternInfo expected = new PatternInfo(5, "O", "H");
AssertReturnValueWhenTarget((decimal)80.0, 100, expected);
}
public void Assert_Returns3If34()
{
PatternInfo expected = new PatternInfo(3, "H", "O");
AssertReturnValueWhenTarget((decimal)34.0, 200, expected);
}
