private Dictionary <Position, PositionValue> getCharacteristicsValues(SqlConnection con, int expandableTextId)
{
Dictionary <Position, PositionValue> positon = new Dictionary <Position, PositionValue>();
String sqlSelect = String.Format("SELECT CharacteristicsNames.Id AS CharacteristicId, " +
"CharacteristicsNames.Name AS CharacteristicName, " +
"CharacteristicsValues.Id AS CharacteristicValueId, " +
"CharacteristicsValues.Value AS CharacteristicValue " +
"FROM ExpandableTextsCharacteristics " +
"LEFT JOIN CharacteristicsNames " +
"ON ExpandableTextsCharacteristics.CharacteristicsNameId = CharacteristicsNames.Id " +
"LEFT JOIN CharacteristicsValues " +
"ON ExpandableTextsCharacteristics.CharacteristicsValueId = CharacteristicsValues.Id " +
"AND ExpandableTextsCharacteristics.CharacteristicsNameId = CharacteristicsValues.CharacteristicsNameId " +
"WHERE ExpandableTextsCharacteristics.ExpandableTextId = {0}", expandableTextId);
SqlCommand command = new SqlCommand(sqlSelect, con);
SqlDataReader reader = command.ExecuteReader();
if (reader.HasRows) // если есть данные
{
while (reader.Read()) // построчно считываем данные
{
Position characteristic = new Position(reader.GetInt32(0), reader.GetString(1));
PositionValue characteristicValue = new PositionValue(reader.GetInt32(2), reader.GetString(3));
positon[characteristic] = characteristicValue;
}
}
return(positon);
}
private void CheckCapture(PositionValue position)
{
if (_playedpieces.ContainsKey(position))
{
_captured.Add(_playedpieces[position].Piece);
}
}
// create moves for this piece and position on this board
internal IList <MoveModel> CreateMoves(PositionValue position, BoardModel board, MoveTypeValue movetype)
{
Logger.WriteLine(5, "Create moves piece:{0} position:{1}", _piecedef.Piece, position);
return(_movecodes
.SelectMany(c => c.CreateMoves(MoveKinds.Move, _piecedef.Piece, position, board, movetype))
.ToList());
}
// main entry point for generating moves for player, piece and position
// note that a gencode block can contain multiple sections and generate multiple moves for the position
// CHECK: the state block persists and must be reinitialised
internal IList <MoveModel> Exec(MoveKinds kind, PieceValue piece, PositionValue position, BoardModel board)
{
_board = board;
_state = MoveGenState.Create(kind, piece, position, board);
EvalExec();
return(_state.MoveList);
}
// test for piece occupying position
internal bool IsOccupied(PlayerKinds kind, PieceValue piece, PositionValue position)
{
return(IsPiece(piece, position) &&
(kind == PlayerKinds.Friend ? IsFriend(position)
: kind == PlayerKinds.Enemy ? IsEnemy(position)
: true));
}
//--- impl board creation
internal PositionValue GetPosition(string name)
{
var position = PositionValue.Create(name);
SetPosition(position);
return(position);
}
// Create any kind of move except set attribute
internal static MovePartModel Create(MoveKinds kind, PlayerValue player, PositionValue position, PieceValue piece,
PositionValue final = null)
{
return(new MovePartModel {
Kind = kind, Player = player, Piece = piece, Position = position, Final = final,
});
}
internal static MoveGenState Create(MoveKinds kind, PieceValue piece, PositionValue position, BoardModel board)
{
//internal static MoveGenState Create(MoveKinds kind, PlayerValue turnplayer, PlayerValue asplayer, PieceValue piece, PositionValue position) {
return(new MoveGenState {
_board = board, Kind = kind, Position = position, Piece = piece,
Current = position, Mark = position,
}.Reset());
}
/// <summary>
/// Sets the kickoff position for (player, direction).
/// </summary>
private void setAttackPosition(int playerNumber, DirectionType playingDirection, Position position, double direction)
{
var key = new PositionKey(playerNumber, playingDirection);
var value = new PositionValue {
position = position, direction = direction
};
this.attackPositions[key] = value;
}
// Create set attribute move
internal static MovePartModel CreateSetAttribute(PlayerValue player, PositionValue position, PieceValue piece,
IdentValue ident, TypedValue value)
{
var mpm = Create(MoveKinds.Attrib, player, position, piece);
mpm.Attribute = ident;
mpm.Value = value;
return(mpm);
}
// reset after Add
MoveGenState Reset()
{
From = Position;
To = null;
_move = MoveModel.Create(TurnPlayer, Position, Piece);
_changes.Clear();
_captures.Clear();
return(this);
}
public void IncorrectPositionStringIsNotTransformedIntoDomainObjects()
{
IPositionConverter converter = new PositionConverter();
PositionValue retValue = (PositionValue)converter.Convert("Stupid name that doesn't exist in the file");
Assert.IsFalse(retValue.Value.HasValue, $"Value should have been null because the supplied name doesn't exist.");
retValue = (PositionValue)converter.Convert(null);
Assert.IsFalse(retValue.Value.HasValue, $"Value should have been null because null was supplied as the value to translate.");
}
void SetPosition(PositionValue position)
{
if (!PositionLookup.ContainsKey(position))
{
PositionLookup[position] = new PositionDef {
Position = position
}
}
;
}
// get position from position and direction
internal PositionValue GetPosition(PositionValue position, PlayerValue player, DirectionValue direction)
{
if (!LinkLookup.ContainsKey(position))
{
return(null);
}
var newdir = SymmetryLookup.SafeLookup(Pair.Create(player, direction)) ?? direction;
var link = LinkLookup[position].FirstOrDefault(k => k.Direction == newdir);
return((link == null) ? null : link.To);
}
internal void SetPositionFlag(IdentValue name, PositionValue position, bool isset)
{
if (isset)
{
_position_flag_set.Add(Pair.Create(position, name));
}
else
{
_position_flag_set.Remove(Pair.Create(position, name));
}
}
private Dictionary <Position, PositionValue> getPositionsValues(IRow row, List <Position> positions)
{
Dictionary <Position, PositionValue> positionsValues = new Dictionary <Position, PositionValue>();
for (int i = 1; i < row.LastCellNum; i++)
{
positionsValues[positions[(i - 1)]] = new PositionValue(row.GetCell(i).StringCellValue);
}
return(positionsValues);
}
// iterate all adjacent positions for player
internal IEnumerable <PositionValue> AdjacentIter(PositionValue position, PlayerValue player)
{
var links = LinkLookup.SafeLookup(position); // might be no links on this position
if (links != null)
{
foreach (var link in links)
{
yield return(link.To);
}
}
}
internal static PolyPlayedPiece Create(PositionValue position, PieceModel piece, int index = 0)
{
var images = piece.Def.GetImages(piece.Player);
return(new PolyPlayedPiece {
Player = piece.Player.Value,
Piece = piece.Piece.Value,
Position = position.Value,
Flags = piece.AttributeLookup == null ? null
: piece.AttributeLookup.Where(a => a.Value == BoolValue.True).Select(a => a.Key).Join(" "),
Image = images[index % images.Count].Value,
});
}
// remove link by direction
internal void RemoveLink(PositionValue position, DirectionValue direction)
{
var links = LinkLookup.GetMulti(position);
if (links != null)
{
links.RemoveAll(l => l.Direction == direction);
if (links.Count == 0)
{
LinkLookup.Remove(position);
}
}
}
// Remove all links between two positions
internal void RemoveLink(PositionValue frompos, PositionValue topos)
{
var links = LinkLookup.GetMulti(frompos);
if (links != null)
{
links.RemoveAll(l => l.To == topos);
if (links.Count == 0)
{
LinkLookup.Remove(frompos);
}
}
}
protected override void _PreRender()
{
_effectIntents = new EffectIntents();
foreach (ElementNode node in TargetNodes)
{
foreach (Element element in node.GetElementEnumerator())
{
PositionValue startPosition = new PositionValue(StartPosition);
PositionValue endPosition = new PositionValue(EndPosition);
IIntent intent = new PositionIntent(startPosition, endPosition, TimeSpan);
_effectIntents.AddIntentForElement(element.Id, intent, TimeSpan.Zero);
}
}
}
// Remove all links for position
internal void RemoveLink(PositionValue frompos)
{
var links = LinkLookup.GetMulti(frompos);
if (links != null)
{
// remove back link
foreach (var link in links.ToArray()) // copy collection to insulate from removals
//foreach (var link in links) -- cannot repro error
{
RemoveLink(link.To, link.From);
}
// remove key
LinkLookup.Remove(frompos);
}
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
Pose pose = (Pose)target;
if (previewSkeleton != null)
{
var bones = previewSkeleton.GetComponentsInChildren <Bone>();
GL.Begin(GL.LINES);
foreach (Bone b in bones)
{
PositionValue pv = Array.Find(pose.positions, x => x.name == b.name);
if (pv != null)
{
RotationValue rv = Array.Find(pose.rotations, x => x.name == b.name);
Vector3 v = pv.position + (rv.rotation * new Vector3(0, 1, 0)) * b.length * 40;
GL.Color(new Color(1, 0, 0, 1));
GL.Vertex(pv.position * 40 + (Vector3)r.center);
GL.Vertex(v + (Vector3)r.center);
}
}
GL.End();
}
//GL.Begin(GL.LINES);
//GameObject go = GameObject.Find("orc_3");
//SpriteRenderer sr = go.GetComponent<SpriteRenderer>();
//Texture2D tex = sr.sprite.texture;
//Sprite spr = sr.sprite;
//Rect source = new Rect(spr.rect.x / tex.width, spr.rect.y / tex.height, spr.rect.width / tex.width, spr.rect.height / tex.height);
//GL.Color(Color.red);
//GL.Vertex(new Vector3(r.x, r.y, 0));
//GL.Vertex(new Vector3(r.x + r.width, r.y + r.height, 0));
//GL.End();
//Graphics.DrawTexture(r, tex, source, 0, 0, 0, 0, sr.sharedMaterial);
}
private IEnumerable<string> ApplyPattern(IEnumerable<string> results, string pattern, PositionValue position)
{
var list = new List<string>();
Func<string, string, string> patternizer=null;
switch (position)
{
case PositionValue.Suffix:
patternizer = ApplyPatternAsSuffix;
break;
case PositionValue.Prefix:
patternizer = ApplyPatternAsPrefix;
break;
}
foreach (var value in results)
list.Add(patternizer(pattern, value));
return list;
}
public void PositionStringsAreCorrectlyTransformedIntoDomainObjects()
{
IPositionConverter converter;
foreach (var language in languages)
{
converter = (IPositionConverter)Activator.CreateInstance(language.Value);
string json = File.ReadAllText($@"{SettingsFolderPath}\{language.Key}\{SettingsFile}");
var definition = new { Language = default(string), Set = new[] { new { Name = default(string), DO = default(string) } } };
var deserializedJSON = JsonConvert.DeserializeAnonymousType(json, definition);
foreach (var item in deserializedJSON.Set)
{
PositionValue retValue = (PositionValue)converter.Convert(item.Name);
Assert.IsTrue(retValue.Value.HasValue, $"The Position string \"{item.Name}\" didn't translate into a Position type domain object.");
}
}
}
private void insertPossibleValue(SqlConnection con, Position positon, PositionValue positonValue)
{
if (positonValue != null &&
!positonValue.getValue().Equals(""))
{
// try to find Value in DB
int newCharacteristicValueId = searchCharacteristicPossibleValue(con, positon, positonValue);
if (newCharacteristicValueId == -1)
{ // not found -> insert it
newCharacteristicValueId = getLastCharacteristicPossibleValueId(con, positon) + 1;
String sqlInsert = String.Format("INSERT INTO CharacteristicsValues (Id, CharacteristicsNameId, Value) VALUES ({0}, {1}, '{2}')", newCharacteristicValueId, positon.getId(), positonValue.getValue());
SqlCommand command = new SqlCommand(sqlInsert, con);
int numberOfinserted = command.ExecuteNonQuery();
}
// set inserted row Id to CharacteristicValue
positonValue.setId(newCharacteristicValueId);
}
}
// Return true if list of occupiers satisfied for this position
private bool IsRelative(PositionValue position, List <OccupierDef> occupiers)
{
var curpos = position;
foreach (var def in occupiers)
{
if (def.IsDirection)
{
curpos = _board.Def.GetPosition(curpos, _board.CurrentPlayer, def.Direction);
if (curpos == null)
{
return(false); // off board
}
}
else if (!_board.IsOccupied(def.PlayerKind, def.Piece, curpos))
{
return(false); // piece mismatch
}
}
return(true);
}
// recursively add symbols
void AddPositions(int index, string prefix, IList <string> dims)
{
foreach (var frag in dims[index].Split('/'))
{
var name = prefix + frag;
if (index + 1 < dims.Count)
{
AddPositions(index + 1, name, dims);
}
else
{
var sym = Symbols.Find(name);
if (sym == null)
{
Symbols.DefineValue(name, PositionValue.Create(name));
}
else if (!(sym.Kind == SymKinds.VALUE && sym.DataType == DataTypes.Position))
{
_currentparser.Syntax("cannot define {0} as position", name);
}
}
}
}
protected List <PositionValue> SelectToCompleteSummary(List <BaseSolution> population,
BaseSolution best)
{
var phrasesList = new List <PositionValue>();
foreach (var t in population)
{
foreach (var phrase in t.SelectedPhrases)
{
if (phrasesList.Exists(x => x.Position == phrase))
{
var currentPhrase = phrasesList.Find(x
=> x.Position == phrase);
currentPhrase.Value = currentPhrase.Value + 1;
}
else
{
var newPhrase = new PositionValue(phrase, 1);
phrasesList.Add(newPhrase);
}
}
}
phrasesList.Sort((x, y) => - 1 *
x.Value.CompareTo(y.Value));
foreach (var phrase in best.SelectedPhrases)
{
if (phrasesList.Exists(x => x.Position == phrase))
{
var currentPhrase = phrasesList.Find(x =>
x.Position == phrase);
phrasesList.Remove(currentPhrase);
}
}
return(phrasesList);
}
// factory: parts default to empty
internal static MoveModel Create(PlayerValue player, PositionValue position, PieceValue piece)
{
return(new MoveModel {
Player = player, Position = position, Piece = piece,
});
}
internal bool IsAttributeSet(IdentValue attribute, PositionValue position)
{
return(IsPlayed(position) && _playedpieces[position].IsSet(attribute));
}
