public override void Enter()
{
_targetSystem = InputSystem.Game.GetSystem <TargetSystem>();
_targetAttribute = InputSystem.ActiveCard.Card.GetAttribute <ManualTarget>();
_targets = new List <CardView>();
_targetAttribute.Selected = new List <Card>();
var candidates = _targetSystem.GetTargetCandidates(InputSystem.ActiveCard.Card, _targetAttribute.Allowed);
_candidateViews = InputSystem.GameView.FindCardViews(candidates);
InputSystem.ActiveCard.Highlight(_targetAttribute.RequiredAmount == 0 ? Colors.HasTargets : Colors.NeedsTargets);
_candidateViews.Highlight(Colors.IsTargetCandidate);
if (_targetAttribute.Allowed.Zones.HasZone(Zones.Deck | Zones.Discard | Zones.Hand))
{
// NOTE: We only expect one of the above zones to be targetable at once, bad assumption?
var player = _candidateViews.Select(c => c.Card.Owner).Distinct().Single();
var zoneToPreview = _candidateViews.Select(c => c.Card.Zone).Distinct().Single();
if (player.Index != MatchData.LOCAL_PLAYER_INDEX || zoneToPreview != Zones.Hand)
{
var zoneView = InputSystem.GameView.FindZoneView(player, zoneToPreview);
zoneView.GetPreviewSequence(sortOrder: PreviewSortOrder.ByType);
_zoneInPreview = zoneView;
}
}
}
void Start()
{
playing = false;
index = 0;
frame = 0;
updatePerFrame = 10;
try {
system = new TargetSystem();
} catch (System.Exception e) {
Debug.Log(e.Message);
}
prefab_container = new GameObject("Prefabs");
prefab_container.SetActive(false);
// prefab_container.GetComponent<MeshRenderer>().enabled = false;
prefabs = new Dictionary <string, GameObject>();
particles = new Dictionary <ParticleID, GameObject>();
not_updated = new List <ParticleID>();
stepViewer.GetComponent <Text>().text = index.ToString();
foreach (Particle particle in system[index])
{
Vector3 position = Real2Vector(particle.coordinate);
particles.Add(particle.pid, CreateParticle(position, particle.radius, particle.species));
}
}
public static void serialize(TargetSystem value, XSteam steam)
{
// null
boolBuffer.serialize(value == null, steam);
if (value == null)
{
return;
}
// systemType
intBuffer.serialize(value.systemType, steam);
// param1
intBuffer.serialize(value.param1, steam);
// param2
intBuffer.serialize(value.param2, steam);
// param3
intBuffer.serialize(value.param3, steam);
}
private string MapColumnType(TargetSystem targetSystem, Column column)
{
ColumnType columnType = column.ColumnType;
Target target = null;
string enumTypeName = null;
while (target == null && columnType != null && enumTypeName == null)
{
enumTypeName = columnType.EnumTypeName;
target = columnType.Targets[targetSystem.Name];
if (target == null)
{
columnType = columnType.BaseType;
}
}
string typeString;
if (enumTypeName != null)
{
typeString = enumTypeName;
}
else
{
if (target == null)
{
throw new DataSchemaException("Target type not found for column " + column.Name);
}
typeString = target.DataType;
}
return MacroResolver.Resolve(column, typeString);
}
public string GetColumnTypeString(TargetSystem targetSystem, Column column)
{
string result = MapColumnType(targetSystem, column);
if (!column.CanBeNull)
{
result += " not null";
}
return result;
}
public override void Exit()
{
_targets = null;
_candidateViews = null;
_targetAttribute = null;
_targetSystem = null;
if (_zoneInPreview != null)
{
_zoneInPreview.GetZoneLayoutSequence();
_zoneInPreview = null;
}
}
/// <summary>
/// Gets the effective target of this column given the specified targetSystem.
/// </summary>
/// <param name="targetSystem"></param>
/// <returns></returns>
public Target GetEffectiveTarget(TargetSystem targetSystem)
{
ColumnType columnType = this.ColumnType;
Target target = null;
while (target == null && columnType != null)
{
target = columnType.Targets[targetSystem.Name];
if (target == null)
{
columnType = columnType.BaseType;
}
}
return target;
}
public static TargetSystem deserialize(byte[] buffer, ref uint offset)
{
// null
bool _null = boolBuffer.deserialize(buffer, ref offset);
if (_null)
{
return(null);
}
// systemType
int _systemType = intBuffer.deserialize(buffer, ref offset);
// param1
int _param1 = intBuffer.deserialize(buffer, ref offset);
// param2
int _param2 = intBuffer.deserialize(buffer, ref offset);
// param3
int _param3 = intBuffer.deserialize(buffer, ref offset);
TargetSystem _TargetSystem = new TargetSystem();
_TargetSystem.systemType = _systemType;
_TargetSystem.param1 = _param1;
_TargetSystem.param2 = _param2;
_TargetSystem.param3 = _param3;
return(_TargetSystem);
}
public void NoMap_NoTile()
{
var entity = SetMouseInput(float2.zero);
if (TargetSystem.HasSingleton <MapSettings>() == false)
{
TargetSystem.SetSingleton(new MapSettings()
{
MapEdgeSize = 5
});
}
Update();
var tileUnderMouse = _entityManager.GetComponentData <TileUnderMouse>(entity);
AreEqual(new Entity(), tileUnderMouse.Tile);
False(_entityManager.Exists(tileUnderMouse.Tile));
}
private void SetMap(int edgeSize)
{
var mapSize = edgeSize * edgeSize;
var tile = _entityManager.CreateEntity(typeof(GroundType));
_entityManager.SetComponentData(tile, new GroundType(BlobsMemory.Instance.ReferencesOf <GroundTypeBlob>()[0]));
var tiles = new BlitableArray <Entity>(mapSize, Unity.Collections.Allocator.Temp);
for (int i = 0; i < mapSize; i++)
{
tiles[i] = tile;
}
_entityManager.CreateEntity(typeof(MapSettings));
TargetSystem.SetSingleton(new MapSettings()
{
Tiles = tiles, MapEdgeSize = edgeSize
});
}
public void EndTurn()
{
Console.WriteLine($"{GetType().Name} - ExecuteOption - End");
TurnSystem.End();
while (TurnSystem.Active is Enemy enemy && !enemy.IsDead && enemy.EnemyType != EnemyType.Enviroment)
{
enemyAISysytem.ExecuteEnemyTurn(this, TurnSystem.Active);
}
TargetSystem.Cleanup();
if (Enemies.TrueForAll(enemy => enemy.IsDead))
{
BattleStateStore.State = BattleState.ENDED;
Enemies.ForEach(enemy => enemy.OnKilled -= Enemy_OnKilled);
}
ActionMenu.Process();
HealthCounter.Show();
}
public TargetSystem Add(TargetSystem parent)
{
// ignore parent as at the moment there is no requirment for hierarchy here
TargetSystem detail = new TargetSystem();
detail.Default(Context.UserName);
detail.Approve(Context.UserName);
if (Context.TargetSystems.Local.Any())
{
detail.TargetSystemID = Context.TargetSystems.Local.Max(x => x.TargetSystemID) + 1;
}
else
{
detail.TargetSystemID = 1;
}
Context.TargetSystems.Add(detail);
detail.Name = "Target System Name";
return detail;
}
public void Transform(DataSchema dataSchema, string name, TargetSystem targetSystem, System.Xml.Linq.XElement transformationElement, IScriptDocumentGeneratorFactory docGenFactory)
{
throw new NotImplementedException();
}
private void SetTargetSystemNode(TreeNode node, TargetSystem targetSystem)
{
node.Text = targetSystem.Name;
node.ImageKey = ImageKeyTargetSystem;
node.SelectedImageKey = node.ImageKey;
node.Tag = targetSystem;
}
public Arbitrate(GameObject agent)
: base(agent, TaskType.Arbitrate)
{
stats = agent.GetComponent<Stats>();
targetSystem = new TargetSystem(agent);
}
private void ApplyParsedSchema(Parsing.DataSchema parsedSchema, IVerificationContext context)
{
const string PropertyMacroDefault = "(default)";
// Column types
foreach (Parsing.DataSchemaColumnType parsedColumnType in parsedSchema.ColumnTypes)
{
ColumnType columnType = new ColumnType();
columnType.Name = parsedColumnType.name;
columnType.Description = parsedColumnType.description;
if (parsedColumnType.baseType != null)
{
ColumnType baseType = this.ColumnTypes[parsedColumnType.baseType];
if (baseType == null)
{
context.Add(new VerificationMessage(Verification.Severity.Error,
string.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.ColumnTypeBaseTypeUnkown, parsedColumnType.name, parsedColumnType.baseType)));
continue;
}
columnType.BaseType = baseType;
Debug.Assert(columnType.BaseType != null);
}
// Set default values when no base type
if (columnType.BaseType == null)
{
columnType.CanBeNull = false;
columnType.IsDbGenerated = false;
}
if (parsedColumnType.canBeNullSpecified)
{
columnType.CanBeNull = parsedColumnType.canBeNull;
}
if (parsedColumnType.isDbGeneratedSpecified)
{
columnType.IsDbGenerated = parsedColumnType.isDbGenerated;
}
if (parsedColumnType.maxLengthSpecified)
{
columnType.MaxLength = parsedColumnType.maxLength;
}
if (parsedColumnType.enumType != null)
{
columnType.EnumTypeName = parsedColumnType.enumType;
}
if (parsedColumnType.precisionSpecified)
{
columnType.Precision = parsedColumnType.precision;
}
if (parsedColumnType.scaleSpecified)
{
columnType.Scale = parsedColumnType.scale;
}
if (parsedColumnType.Target != null)
{
foreach (var parsedTarget in parsedColumnType.Target)
{
TargetSystem targetSystem = this.TargetSystems[parsedTarget.name];
if (targetSystem == null)
{
targetSystem = new TargetSystem { Name = parsedTarget.name };
this.TargetSystems.Add(targetSystem);
}
Target target = new Target
{
TargetSystem = targetSystem,
DataType = parsedTarget.dataType,
DataTypeWhenReferenced = parsedTarget.dataTypeWhenReferenced,
DotNetType = parsedTarget.dotNetType,
DotNetTypeNullable = parsedTarget.dotNetTypeNullable
};
if (parsedTarget.ExtendedProperties != null && parsedTarget.ExtendedProperties.Length > 0)
{
target.ExtendedProperties.Clear();
foreach (var property in parsedTarget.ExtendedProperties)
{
target.ExtendedProperties.Add(property.name, property.Value);
}
}
try
{
columnType.Targets.Add(target);
}
catch (ArgumentException)
{
context.Add(new VerificationMessage(Severity.Error,
string.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.ColumnTypeTargetDuplicates, target.TargetSystem.Name, columnType.Name)));
}
}
}
columnType.Verify(context);
if (!this.ColumnTypes.Contains(columnType.Name))
{
this.ColumnTypes.Add(columnType);
}
else
{
context.Add(new VerificationMessage(Severity.Error,
string.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.ColumnTypeDuplicates, columnType.Name)));
}
}
if (parsedSchema.Tables != null)
{
// Tables: First pass - references are skipped until second pass.
foreach (var parsedTable in parsedSchema.Tables)
{
Table table = new Table();
table.Name = parsedTable.name;
try
{
this.Tables.Add(table);
}
catch (ArgumentException)
{
context.Add(new VerificationTableMessage(Severity.Error, table.Name, Properties.Resources.SchemaTableExists));
}
table.Description = parsedTable.description;
// Columns
foreach (var parsedColumn in parsedTable.Columns)
{
Column column = new Column();
column.Name = parsedColumn.name;
column.Description = parsedColumn.description;
if (parsedColumn.canBeNullSpecified)
{
column.CanBeNull = parsedColumn.canBeNull;
}
if (parsedColumn.inPrimaryKeySpecified)
{
column.InPrimaryKey = parsedColumn.inPrimaryKey;
}
if (!string.IsNullOrWhiteSpace(parsedColumn.columnType))
{
ColumnType columnType = this.ColumnTypes[parsedColumn.columnType];
if (columnType != null)
{
column.ColumnType = columnType;
}
else
{
context.Add(new VerificationTableMessage(Severity.Error, table.Name, column.Name,
string.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.ColumnTypeUnknown, parsedColumn.columnType)));
}
}
table.Columns.Add(column);
}
// Indices
if (parsedTable.Indices != null)
{
foreach (var parsedIndex in parsedTable.Indices)
{
Index index = new Index(table);
if (!string.IsNullOrWhiteSpace(parsedIndex.name))
{
index.Name = parsedIndex.name;
}
if (parsedIndex.uniqueSpecified)
{
index.IsUnique = parsedIndex.unique;
}
foreach (var parsedIndexColumn in parsedIndex.Column)
{
Column column = table.Columns[parsedIndexColumn.name];
if (column != null)
{
index.Columns.Add(column);
}
else
{
context.Add(new VerificationTableMessage(Severity.Error, table.Name,
string.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.IndexColumnUnknown, parsedIndexColumn.name)));
}
}
table.Indices.Add(index);
}
}
}
// Tables: Second pass - resolve references
foreach (var parsedTable in parsedSchema.Tables)
{
Table table = this.Tables[parsedTable.name];
foreach (var parsedColumn in parsedTable.Columns)
{
if (!string.IsNullOrWhiteSpace(parsedColumn.references))
{
Column column = table.Columns[parsedColumn.name];
string toTableName;
string toColumnName;
SplitReference(parsedColumn.references, out toTableName, out toColumnName);
Table toTable = this.Tables[toTableName];
if (toTable == null)
{
context.Add(new VerificationTableMessage(Severity.Error, table.Name, column.Name,
string.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.ReferencedTableNotExists,
parsedColumn.references)));
continue;
}
Column toColumn = toTable.Columns[toColumnName];
if (toColumn == null)
{
context.Add(new VerificationTableMessage(Severity.Error, table.Name, column.Name,
string.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.ReferencedColumnNotExists, parsedColumn.references)));
continue;
}
ForeignKey foreignKey = new ForeignKey();
foreignKey.FromTable = table;
foreignKey.ToTable = toTable;
foreignKey.Columns.Add(new ForeignKey.ColumnPair { FromColumn = column, ToColumn = toColumn });
if (!string.IsNullOrEmpty(parsedColumn.referenceName))
{
foreignKey.Name = parsedColumn.referenceName;
}
table.ForeignKeys.Add(foreignKey);
column.ColumnType = this.GetReferenceToColumnType(toColumn.ColumnType);
column.CanBeNull = false;
if (parsedColumn.canBeNullSpecified)
column.CanBeNull = parsedColumn.canBeNull;
// Association properties
foreignKey.AssociationProperty = new AssociationProperty();
if (parsedColumn.AssociationCode != null)
{
if (parsedColumn.AssociationCode.Child != null)
{
ParsedAssociationEndPointToNative(parsedColumn.AssociationCode.Child, foreignKey.AssociationProperty.Child);
}
else
{
foreignKey.AssociationProperty.Child = null;
}
ParsedAssociationEndPointToNative(parsedColumn.AssociationCode.Parent, foreignKey.AssociationProperty.Parent);
}
else
{
// Check the quick-attributes for association properties
if (string.IsNullOrEmpty(parsedColumn.childProperty))
{
foreignKey.AssociationProperty.Child = null;
}
else
{
if (string.Compare(parsedColumn.childProperty, PropertyMacroDefault, StringComparison.Ordinal) != 0)
{
foreignKey.AssociationProperty.Child.Name = parsedColumn.childProperty;
}
else
{
// Using default
foreignKey.AssociationProperty.Child.Name = null;
}
}
if (string.IsNullOrEmpty(parsedColumn.parentProperty))
{
foreignKey.AssociationProperty.Parent = null;
}
else
{
if (string.Compare(parsedColumn.parentProperty, PropertyMacroDefault, StringComparison.Ordinal) != 0)
{
foreignKey.AssociationProperty.Parent.Name = parsedColumn.parentProperty;
}
else
{
// Using default
foreignKey.AssociationProperty.Parent.Name = null;
}
}
}
}
} // end foreach (var parsedColumn in parsedTable.Columns)
// Foreign keys
if (parsedTable.ForeignKeys != null)
{
foreach (var parsedForeignKey in parsedTable.ForeignKeys)
{
ForeignKey foreignKey = new ForeignKey();
foreignKey.Name = parsedForeignKey.name;
foreignKey.FromTable = table;
Table toTable = this.Tables[parsedForeignKey.toTable];
if (toTable == null)
{
context.Add(new VerificationTableMessage(Severity.Error, table.Name,
string.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.ForeignKeyTableNotExists, parsedForeignKey.toTable)));
continue;
}
foreignKey.ToTable = toTable;
foreach (var columnPair in parsedForeignKey.ColumnPairs)
{
Column fromColumn = table.Columns[columnPair.from];
if (fromColumn == null)
{
context.Add(new VerificationTableMessage(Severity.Error, table.Name,
string.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.ForeignKeyFromColumnNotExists, columnPair.from)));
continue;
}
Column toColumn = toTable.Columns[columnPair.to];
if (toColumn == null)
{
context.Add(new VerificationTableMessage(Severity.Error, table.Name,
string.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.ForeignKeyToColumnNotExists, columnPair.to)));
continue;
}
foreignKey.Columns.Add(new ForeignKey.ColumnPair { FromColumn = fromColumn, ToColumn = toColumn });
}
table.ForeignKeys.Add(foreignKey);
}
}
// Table settings
if (parsedTable.Settings != null)
{
foreach (var parsedSetting in parsedTable.Settings)
{
if (!this.TargetSystems.Contains(parsedSetting.target))
{
context.Add(new VerificationTableMessage(Severity.Error, table.Name,
string.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.TableSettingsTargetNotExists, parsedSetting.target)));
continue;
}
table.Settings.Add(parsedSetting.target, parsedSetting.property, parsedSetting.value);
}
}
}
}
}
void Awake()
{
SI = this.GetComponent<statInformation>();
TS = this.GetComponent<TargetSystem>();
}
public string GetColumnTypeString(TargetSystem targetSystem, Column column)
{
return MapColumnType(targetSystem, column);
}
