public TrainerPokemonTeamRun(IDataModel model, int start, SortedSpan <int> sources) : base(start, sources)
{
this.model = model;
// trainer format (abbreviated):
// 0 1 2 3 4-15 16 18 20 22 24 28 32 36 40 total
// [structType. class. introMusic. sprite. name\"\"12 item1: item2: item3: item4: doubleBattle:: ai:: pokemonCount:: pokemon<>]
StructType = 0;
ElementCount = 1;
foreach (var source in sources)
{
if (!(model.GetNextRun(source) is ITableRun))
{
continue;
}
StructType = model[source - TrainerFormat_PointerOffset];
ElementCount = model.ReadMultiByteValue(source - TrainerFormat_PointerOffset + TrainerFormat_PokemonCountOffset, 4);
break;
}
var segments = Initialize();
ElementContent = segments;
ElementLength = ElementContent.Sum(segment => segment.Length);
}
private void ElementContent_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
if (IsEnabled)
{
_leftButtonDown = false;
ElementContent.ReleaseMouseCapture();
}
}
/// <summary>
/// 判断指定位置的元素类型
/// </summary>
/// <param name="x">元素所在位置的x</param>
/// <param name="y">元素所在位置的x</param>
/// <param name="content">需要比较的类型</param>
/// <returns>比较结果</returns>
public bool IsSameContent(int x, int y, ElementContent content)
{
if (x >= 0 && x < w && y >= 0 && y < h)
{
return(mapArray[x, y].elementContent == content);
}
return(false);
}
private TrainerPokemonTeamRun(IDataModel model, int start, SortedSpan <int> sources, int primarySource) : base(start, sources)
{
this.model = model;
StructType = model[primarySource - TrainerFormat_PointerOffset];
ElementCount = model[primarySource - TrainerFormat_PointerOffset + TrainerFormat_PokemonCountOffset];
var segments = Initialize();
ElementContent = segments;
ElementLength = ElementContent.Sum(segment => segment.Length);
}
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
// Get album content
ElementContent content = new ElementContent {
PartialViewName = "Album"
};
// Return result
return(content);
}
public ArrayRun GrowBitArraySegment(int bitSegmentIndex, int additionalBytes)
{
// all the data has been moved already
// just return a new ArrayRun with the desired change.
var content = ElementContent.ToList();
var oldSegment = (ArrayRunBitArraySegment)content[bitSegmentIndex];
content[bitSegmentIndex] = new ArrayRunBitArraySegment(oldSegment.Name, oldSegment.Length + additionalBytes, oldSegment.SourceArrayName);
return(new ArrayRun(owner, FormatString, LengthFromAnchor, Start, ElementCount, content, PointerSources, PointerSourcesForInnerElements));
}
private void ElementContent_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (IsEnabled)
{
IsTabStop = true;
Focus();
_leftButtonDown = true;
ElementContent.CaptureMouse();
_lastMouseDownPosition = e.GetPosition(ElementRoot);
}
}
/// <summary>
/// Gets the height of the control when expanded
/// </summary>
/// <returns>Height</returns>
private double GetExpandedHeight()
{
if (ElementRoot != null)
{
return((double)ElementContent.GetValue(Canvas.TopProperty) + (_contentSize.Height + ElementContent.Margin.Top + ElementContent.Margin.Bottom));
}
else
{
return(0);
}
}
/// <summary>
/// 设置元素类型
/// </summary>
/// <param name="index">元素所在位置的一维索引值</param>
/// <param name="content">需要设置的类型</param>
/// <returns>设置好的新类型的组件</returns>
private BaseElement SetElement(int index, ElementContent content)
{
int x, y;
GetPosition(index, out x, out y);
// 先移除旧的
GameObject tempGameObject = mapArray[x, y].gameObject;
Destroy(tempGameObject.GetComponent <BaseElement>());
// 添加新的游戏物体
switch (content)
{
case ElementContent.Trap:
mapArray[x, y] = tempGameObject.AddComponent <TrapElement>();
break;
case ElementContent.Number:
mapArray[x, y] = tempGameObject.AddComponent <NumberElement>();
break;
case ElementContent.Tool:
mapArray[x, y] = tempGameObject.AddComponent <ToolElement>();
break;
case ElementContent.Gold:
mapArray[x, y] = tempGameObject.AddComponent <GoldElement>();
break;
case ElementContent.Enemy:
mapArray[x, y] = tempGameObject.AddComponent <EnemyElement>();
break;
case ElementContent.Door:
mapArray[x, y] = tempGameObject.AddComponent <DoorElement>();
break;
case ElementContent.BigWall:
mapArray[x, y] = tempGameObject.AddComponent <BigWallElement>();
break;
case ElementContent.SmallWall:
mapArray[x, y] = tempGameObject.AddComponent <SmallWallElement>();
break;
case ElementContent.Exit:
mapArray[x, y] = tempGameObject.AddComponent <ExitElement>();
break;
default:
break;
}
return(mapArray[x, y]);
}
private string SerializeSingleElementStream()
{
Debug.Assert(endStream is FixedLengthStreamStrategy flss && flss.Count == 1);
var result = new StringBuilder();
int offset = Start;
var longestLabel = ElementContent.Select(seg => seg.Name.Length).Max();
for (int i = 0; i < ElementContent.Count; i++)
{
var segment = ElementContent[i];
var rawValue = model.ReadMultiByteValue(offset, segment.Length);
var value = rawValue.ToString();
if (segment is ArrayRunEnumSegment enumSeg)
{
var options = enumSeg.GetOptions(model).ToList();
if (options.Count > rawValue)
{
value = options[rawValue];
}
}
else if (segment is ArrayRunTupleSegment tupSeg)
{
value = tupSeg.ToText(model, offset);
}
else if (segment is ArrayRunHexSegment hexSeg)
{
value = "0x" + rawValue.ToString("X" + segment.Length * 2);
}
else if (segment.Type == ElementContentType.Pointer)
{
var pointerValue = rawValue - BaseModel.PointerOffset;
value = $"<{pointerValue:X6}>";
if (pointerValue == Pointer.NULL)
{
value = "<null>";
}
}
else if (segment.Type == ElementContentType.PCS)
{
value = model.TextConverter.Convert(model, offset, segment.Length);
}
var extraWhitespace = new string(' ', longestLabel - segment.Name.Length);
result.Append($"{segment.Name}:{extraWhitespace} {value}");
if (i < ElementContent.Count - 1)
{
result.AppendLine();
}
offset += segment.Length;
}
return(result.ToString());
}
/// <summary>
/// 设置元素的类型
/// </summary>
/// <param name="index">元素所在位置的一维索引值</param>
/// <param name="content">需要设置的类型</param>
/// <returns>设置好的新类型的组件</returns>
private BaseElement SetElement(int index, ElementContent content)
{
int x, y;
GetPosition(index, out x, out y);
GameObject tempGo = mapArray[x, y].gameObject; //找到地图里面的物体
Destroy(tempGo.GetComponent <BaseElement>()); //销毁当前泥土预制体
switch (content)
{
case ElementContent.Number:
mapArray[x, y] = tempGo.AddComponent <NumberElement>();
break;
case ElementContent.Trap:
mapArray[x, y] = tempGo.AddComponent <TrapElement>();
break;
case ElementContent.Tool:
mapArray[x, y] = tempGo.AddComponent <ToolElement>();
break;
case ElementContent.Gold:
mapArray[x, y] = tempGo.AddComponent <GoldElement>();
break;
case ElementContent.Enemy:
mapArray[x, y] = tempGo.AddComponent <EnemyElement>();
break;
case ElementContent.Door:
mapArray[x, y] = tempGo.AddComponent <DoorElement>();
break;
case ElementContent.BigWall:
mapArray[x, y] = tempGo.AddComponent <BigWallElement>();
break;
case ElementContent.SmallWall:
mapArray[x, y] = tempGo.AddComponent <SmallWallElement>();
break;
case ElementContent.Exit:
mapArray[x, y] = tempGo.AddComponent <ExitElement>();
break;
}
return(mapArray[x, y]);
}
protected void UpdateVisualState()
{
Rect clipping = new Rect(0, 0, Width, _panelSize.Height);
double opacity = (IsEnabled ? 1 : 0.8);
if (ElementRoot != null)
{
ElementBackground.SetValue(Canvas.TopProperty, _panelSize.Height);
ElementBackground.SetValue(Canvas.LeftProperty, 0d);
ElementContent.SetValue(Canvas.TopProperty, _panelSize.Height);
ElementText.Opacity = opacity;
ElementCheckBox.Opacity = opacity;
ElementExpand.IsEnabled = IsEnabled;
ElementExpand.Cursor = (IsEnabled ? Cursors.Hand : Cursors.Arrow);
ElementText.Cursor = ElementExpand.Cursor;
ElementBackground.Width = Width;
ElementBackground.Height = Height - _panelSize.Height;
clipping = new Rect(0, 0, Width, double.IsNaN(Height) ? _panelSize.Height : Height);
if (_expanded)
{
ElementBackground.Visibility = Visibility.Visible;
}
else if (_expandDirection == 0.0)
{
ElementBackground.Visibility = Visibility.Collapsed;
}
ElementClipping.SetValue(RectangleGeometry.RectProperty, clipping);
ElementText.Text = _text;
if (_enableCheckbox)
{
ElementCheckBox.IsChecked = _checked;
ElementCheckBox.Visibility = Visibility.Visible;
}
else
{
ElementCheckBox.Visibility = Visibility.Collapsed;
}
}
}
internal XdrBuilder(XmlReader reader, XmlNamespaceManager curmgr, SchemaInfo sinfo, string targetNamspace, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventhandler)
{
this._SchemaInfo = sinfo;
this._TargetNamespace = targetNamspace;
this._reader = reader;
this._CurNsMgr = curmgr;
this.validationEventHandler = eventhandler;
this._StateHistory = new HWStack(10);
this._ElementDef = new ElementContent();
this._AttributeDef = new AttributeContent();
this._GroupStack = new HWStack(10);
this._GroupDef = new GroupContent();
this._NameTable = nameTable;
this._SchemaNames = schemaNames;
this._CurState = S_SchemaEntries[0];
this.positionInfo = PositionInfo.GetPositionInfo(this._reader);
this.xmlResolver = new XmlUrlResolver();
}
private int CreateObstacle(int area, List <int> _avaliableIndex, out ElementContent obstacleType)
{
int sx = standAreaW + area * obstacleAreaW;
int ex = sx + obstacleAreaW - 1;
int x = Random.Range(sx, ex);
int y = Random.Range(0, h);
obstacleType = (ElementContent)Random.Range(4, 8);
switch (obstacleType)
{
case ElementContent.Enemy:
SetElement <EnemyElement>(x, y);
break;
case ElementContent.Door:
SetElement <DoorElement>(x, y);
break;
case ElementContent.BigWall:
SetElement <BigWallElement>(x, y);
break;
case ElementContent.SmallWall:
SetElement <SmallWallElement>(x, y);
break;
}
_avaliableIndex.Remove(GetIndexByPos(x, y));
for (int j = 0; j < h; j++)
{
var index = GetIndexByPos(x, j);
if (_avaliableIndex.Contains(index))
{
SetElement <BigWallElement>(x, j);
_avaliableIndex.Remove(index);
}
}
return(x);
}
private IReadOnlyList <AutocompleteItem> GetAutoCompleteOptionsForSingleElementStream(string line, int caretIndex)
{
var results = new List <AutocompleteItem>();
var lineStart = line.Substring(0, caretIndex);
var lineEnd = line.Substring(caretIndex);
if (lineStart.Count(':') != 1)
{
return(results);
}
var fieldName = lineStart.Split(':')[0].Trim();
var currentContent = lineStart.Split(':')[1].Trim();
var field = ElementContent.Where(segment => segment.Name == fieldName).FirstOrDefault();
if (field == null)
{
return(null);
}
if (field is ArrayRunEnumSegment enumSegment)
{
var optionText = enumSegment.GetOptions(model).Where(option => option.MatchesPartial(currentContent));
results.AddRange(CreateSingleElementEnumAutocompleteOptions(lineEnd, fieldName, optionText));
}
else if (field is ArrayRunTupleSegment tupleGroup)
{
var tupleTokens = currentContent.Split(" ").ToList();
Recombine(tupleTokens, "\"", "\"");
if (tupleTokens[0].StartsWith("("))
{
tupleTokens[0] = tupleTokens[0].Substring(1);
}
var visibleTupleElements = tupleGroup.Elements.Where(element => !string.IsNullOrEmpty(element.Name)).ToList();
if (visibleTupleElements.Count >= tupleTokens.Count)
{
var tupleToken = visibleTupleElements[tupleTokens.Count - 1];
var optionToken = tupleTokens.Last();
if (optionToken.StartsWith("\""))
{
optionToken = optionToken.Substring(1);
}
if (optionToken.EndsWith("\""))
{
optionToken = optionToken.Substring(0, optionToken.Length - 1);
}
tupleTokens = tupleTokens.Take(tupleTokens.Count - 1).ToList();
if (!string.IsNullOrEmpty(tupleToken.SourceName))
{
var optionText = ArrayRunEnumSegment.GetOptions(model, tupleToken.SourceName).Where(option => option.MatchesPartial(optionToken));
results.AddRange(CreateTupleEnumSingleElementAutocompleteOptions(fieldName, tupleGroup, tupleTokens, optionText, lineEnd));
}
else if (tupleToken.BitWidth == 1)
{
var optionText = new[] { "false", "true" }.Where(option => option.MatchesPartial(optionToken));
results.AddRange(CreateTupleEnumSingleElementAutocompleteOptions(fieldName, tupleGroup, tupleTokens, optionText, lineEnd));
}
}
}
return(results);
}
private ArrayRun(IDataModel data, string format, int start, IReadOnlyList <int> pointerSources) : base(start, pointerSources)
{
owner = data;
FormatString = format;
SupportsPointersToElements = format.StartsWith(AnchorStart.ToString());
if (SupportsPointersToElements)
{
format = format.Substring(1);
}
var closeArray = format.LastIndexOf(ArrayEnd.ToString());
if (!format.StartsWith(ArrayStart.ToString()) || closeArray == -1)
{
throw new ArrayRunParseException($"Array Content must be wrapped in {ArrayStart}{ArrayEnd}.");
}
var segments = format.Substring(1, closeArray - 1);
var length = format.Substring(closeArray + 1);
ElementContent = ParseSegments(segments, data);
if (ElementContent.Count == 0)
{
throw new ArrayRunParseException("Array Content must not be empty.");
}
ElementLength = ElementContent.Sum(e => e.Length);
FormatMatchFlags flags = default;
if (ElementContent.Count == 1)
{
flags |= FormatMatchFlags.IsSingleSegment;
}
if (length.Length == 0)
{
var nextRun = owner.GetNextRun(Start);
while (nextRun is NoInfoRun && nextRun.Start < owner.Count)
{
nextRun = owner.GetNextRun(nextRun.Start + 1);
}
var byteLength = 0;
var elementCount = 0;
while (Start + byteLength + ElementLength <= nextRun.Start && DataMatchesElementFormat(owner, Start + byteLength, ElementContent, flags, nextRun))
{
byteLength += ElementLength;
elementCount++;
}
LengthFromAnchor = string.Empty;
ElementCount = Math.Max(1, elementCount); // if the user said there's a format here, then there is, even if the format it wrong.
}
else if (int.TryParse(length, out int result))
{
// fixed length is easy
LengthFromAnchor = string.Empty;
ElementCount = Math.Max(1, result);
}
else
{
LengthFromAnchor = length;
ElementCount = Math.Max(1, ParseLengthFromAnchor());
}
Length = ElementLength * ElementCount;
}
protected override void Seed(NeuCMS.Repositories.EntityFramework.ContentRepository context)
{
var nameSpace = new NameSpace()
{
Id = 1,
Description = "Sample NeuCMS Content Data",
NameSpaceName = "NeuCMS.Samples"
};
context.NameSpaces.AddOrUpdate(
n => n.Id,
nameSpace);
var contentDef1 = new ContentDefinition()
{
Id = 1,
Name = "Message",
NameSpace = nameSpace,
AvailableOnAllViews = false
};
var contentDef2 = new ContentDefinition()
{
Id = 2,
Name = "Image",
NameSpace = nameSpace,
AvailableOnAllViews = false
};
var view = new View()
{
Id = 1,
NameSpace = nameSpace,
ViewName = "Home",
ContentDefinitions = new List <ContentDefinition>()
{
contentDef1,
contentDef2
}
};
var dimDef = new DimensionDefinition()
{
Id = 1, DimensionName = "Language", NameSpace = nameSpace
};
var elementContent = new ElementContent()
{
Id = 1,
Content = "Hello World!",
ContentElementDefinition = view.ContentDefinitions[0],
Dimensions = new List <DimensionValue>()
{
new DimensionValue()
{
Id = 1,
DimensionDefinition = dimDef,
Value = "English"
}
}
};
var converter = new ImageConverter();
var imgBytes = (byte[])converter.ConvertTo(TestData.Test, typeof(byte[]));
var mediaContent = new MediaContent()
{
Id = 2,
ContentElementDefinition = view.ContentDefinitions[1],
Dimensions = new List <DimensionValue>()
{
new DimensionValue()
{
Id = 1,
DimensionDefinition = dimDef,
Value = "English"
}
},
DigitalAsset = new DigitalAsset()
{
Id = 1,
ContentType = "image/jpeg",
Data = imgBytes
}
};
context.Views.AddOrUpdate(v => v.Id, view);
context.ContentDefinitions.AddOrUpdate(c => c.Name, contentDef1);
context.DimensionDefinitions.AddOrUpdate(d => d.DimensionName, dimDef);
context.Contents.AddOrUpdate(c => c.Id, elementContent);
context.Contents.AddOrUpdate(c => c.Id, mediaContent);
}
//=========================================================================================
public SingleElement(ElementContent content)
: base(null)
{
this.Content = content;
this.Text = string.Empty;
}
//=========================================================================================
public SingleElement(string text)
: base(null)
{
this.Content = ElementContent.Specified;
this.Text = text;
}
private void CreateTool(int _area, List <int> _avaliableIndex, ElementContent _elementContent)
{
int sx, ex;
_area -= 1;
if (_area < 0)
{
sx = 0;
ex = standAreaW - 1;
}
else
{
sx = standAreaW + _area * obstacleAreaW;
ex = sx + obstacleAreaW - 1;
}
int index = -1;
for (int i = 0; i < 10; i++)
{
int ranX = Random.Range(sx, ex + 1);
int ranY = Random.Range(0, h);
int tempIndex = GetIndexByPos(ranX, ranY);
if (_avaliableIndex.Contains(tempIndex))
{
index = tempIndex;
break;
}
}
if (index < 0)
{
List <int> randomList = new List <int>();
for (int y = 0; y < h; y++)
{
for (int x = sx; x < ex; x++)
{
int tempIndex = GetIndexByPos(x, y);
if (_avaliableIndex.Contains(tempIndex))
{
randomList.Add(tempIndex);
}
}
}
if (randomList.Count <= 0)
{
CreateTool(_area, _avaliableIndex, _elementContent);
return;
}
else
{
index = randomList[Random.Range(0, randomList.Count)];
}
}
if (index >= 0)
{
_avaliableIndex.Remove(index);
ToolType tt = (ToolType)_elementContent;
ToolElement tool = SetElement <ToolElement>(index);
tool.ReOnInit(tt);
}
}
//=========================================================================================
public SingleElement(string text)
: base(null)
{
this.Content = ElementContent.Specified;
this.Text = text;
}
//=========================================================================================
public SingleElement(ElementContent content)
: base(null)
{
this.Content = content;
this.Text = string.Empty;
}
public bool DependsOn(string anchorName)
{
return(ElementContent.OfType <ArrayRunEnumSegment>().Any(segment => segment.EnumName == anchorName));
}
internal XdrBuilder(
XmlReader reader,
XmlNamespaceManager curmgr,
SchemaInfo sinfo,
string targetNamspace,
XmlNameTable nameTable,
SchemaNames schemaNames,
ValidationEventHandler eventhandler
)
{
_SchemaInfo = sinfo;
_TargetNamespace = targetNamspace;
_reader = reader;
_CurNsMgr = curmgr;
_validationEventHandler = eventhandler;
_StateHistory = new HWStack(StackIncrement);
_ElementDef = new ElementContent();
_AttributeDef = new AttributeContent();
_GroupStack = new HWStack(StackIncrement);
_GroupDef = new GroupContent();
_NameTable = nameTable;
_SchemaNames = schemaNames;
_CurState = s_schemaEntries[0];
_positionInfo = PositionInfo.GetPositionInfo(_reader);
_xmlResolver = null;
}
