public RenderObjectGroup GetRenderObjects(Table.Table table, Origin origin, bool asRightHanded)
{
var mesh = GetBaseMesh();
var(preMatrix, _) = GetPreMatrix(table, origin, asRightHanded);
var postMatrix = GetPostMatrix(table, origin);
return(new RenderObjectGroup(_data.Name, "HitTargets", postMatrix, new RenderObject(
_data.Name,
mesh.Transform(preMatrix),
new PbrMaterial(table.GetMaterial(_data.Material), table.GetTexture(_data.Image)),
_data.IsVisible
)));
}
public RenderObjectGroup GetRenderObjects(Table.Table table, Origin origin, bool asRightHanded = true)
{
var mesh = GetMesh(table);
var(preVertexMatrix, preNormalsMatrix) = GetPreMatrix(table, origin, asRightHanded);
var postMatrix = GetPostMatrix(table, origin);
return(new RenderObjectGroup(_data.Name, "Rubbers", postMatrix, new RenderObject(
_data.Name,
mesh.Transform(preVertexMatrix, preNormalsMatrix),
new PbrMaterial(table.GetMaterial(_data.Material), table.GetTexture(_data.Image)),
_data.IsVisible
)));
}
public static Trigger GetDefault(Table.Table table)
{
var triggerData = new TriggerData(table.GetNewName <Trigger>("Trigger"), table.Width / 2f, table.Height / 2f)
{
DragPoints = new[] {
new DragPointData(table.Width / 2f - 50f, table.Height / 2f - 50f),
new DragPointData(table.Width / 2f - 50f, table.Height / 2f + 50f),
new DragPointData(table.Width / 2f + 50f, table.Height / 2f + 50f),
new DragPointData(table.Width / 2f + 50f, table.Height / 2f - 50f)
}
};
return(new Trigger(triggerData));
}
/// <summary>
/// Updates the hit object with parameters common to the surface.
/// </summary>
/// <param name="hitObjects"></param>
/// <param name="events"></param>
/// <param name="table"></param>
/// <returns></returns>
private HitObject[] UpdateCommonParameters(HitObject[] hitObjects, Table.Table table)
{
foreach (var obj in hitObjects)
{
obj.ApplyPhysics(_data, table);
if (_data.HitEvent)
{
obj.FireEvents = true;
obj.Threshold = _data.Threshold;
}
}
return(hitObjects);
}
public static Surface GetDefault(Table.Table table)
{
var surfaceData = new SurfaceData(
table.GetNewName <Surface>("Wall"),
new[] {
new DragPointData(table.Width / 2f - 50f, table.Height / 2f - 50f),
new DragPointData(table.Width / 2f - 50f, table.Height / 2f + 50f),
new DragPointData(table.Width / 2f + 50f, table.Height / 2f + 50f),
new DragPointData(table.Width / 2f + 50f, table.Height / 2f - 50f)
}
);
return(new Surface(surfaceData));
}
public Mesh GetMesh(string id, Table.Table table, Origin origin, bool asRightHanded)
{
switch (id)
{
case Bulb:
var bulbMesh = GetBulbMesh(table, origin);
return(asRightHanded ? bulbMesh.Transform(Matrix3D.RightHanded) : bulbMesh);
case Socket:
var socketMesh = GetSocketMesh(table, origin);
return(asRightHanded ? socketMesh.Transform(Matrix3D.RightHanded) : socketMesh);
}
throw new ArgumentException("Unknown light mesh \"" + id + "\".");
}
public static void ResolveJumpStatement(JumpStatement jumpStatement, Table.Table table)
{
if (jumpStatement.IsContinue() | jumpStatement.IsBreak())
{
if (!jumpStatement.IsSituatedInLoop())
{
ReportError(new OperatorMustBeSituatedInLoop(jumpStatement.IsContinue() ? "сontinue" : "break", jumpStatement.SourceContext));
}
}
else
if (((ReturnStatement)jumpStatement).ReturnBody != null)
{
ResolveExpression(((ReturnStatement)jumpStatement).ReturnBody, table);
}
}
public static void ResolveMethodDeclaration(MethodDeclaration method)
{
Table.Table MethodTable = Table.Table.CreateTable(GlobalTable.Table);
ResolveMainMethodDeclaration(method);
ResolveMethodArguments(method.Arguments, MethodTable);
if (!method.IsExternal)
{
if (!(method.ReturnType is Void))
{
ResolveReturnInBody(method.Body);
}
ResolveEmbeddedStatement(method.Body, MethodTable);
}
}
private Mesh GetSocketMesh(Table.Table table, Origin origin)
{
var socketMesh = SocketMesh.Clone();
var height = table.GetSurfaceHeight(_data.Surface, _data.Center.X, _data.Center.Y) * table.GetScaleZ();
var transX = origin == Origin.Global ? _data.Center.X : 0f;
var transY = origin == Origin.Global ? _data.Center.Y : 0f;
var transZ = origin == Origin.Global ? height : 0f;
foreach (var vertex in socketMesh.Vertices) {
vertex.X = vertex.X * _data.MeshRadius + transX;
vertex.Y = vertex.Y * _data.MeshRadius + transY;
vertex.Z = vertex.Z * _data.MeshRadius * table.GetScaleZ() + transZ;
}
return socketMesh;
}
public Orchestrator(ILogger logger)
{
var cells = new List <Cell.Cell>();
var index = 1;
_numberOfCells.GenerateForLoop(() => { cells.Add(new EmptyCell(index)); index++; });
var robot = new Robot.Robot(index, _validMove, _calculateIndex);
cells.Add(robot);
var table = new Table.Table(logger, cells);
_boss = new Boss.Boss(logger, table, robot);
}
private Dictionary <string, Mesh> GetMeshes(Table.Table table, Origin origin)
{
if (_data.Center == null)
{
throw new InvalidOperationException($"Cannot export bumper {_data.Name} without center.");
}
var matrix = new Matrix3D().RotateZMatrix(MathF.DegToRad(_data.Orientation));
var height = table.GetSurfaceHeight(_data.Surface, _data.Center.X, _data.Center.Y) * table.GetScaleZ();
return(new Dictionary <string, Mesh> {
{ "Base", GenerateMesh(_scaledBaseMesh, matrix, z => z * table.GetScaleZ() + height, origin) },
{ "Ring", GenerateMesh(_scaledRingMesh, matrix, z => z * table.GetScaleZ() + height, origin) },
{ "Skirt", GenerateMesh(_scaledSocketMesh, matrix, z => z * table.GetScaleZ() + (height + 5.0f), origin) },
{ "Cap", GenerateMesh(_scaledCapMesh, matrix, z => (z + _data.HeightScale) * table.GetScaleZ() + height, origin) }
});
}
public RenderObjectGroup GetRenderObjects(Table.Table table, Origin origin, bool asRightHanded = true,
string parent = null, PbrMaterial material = null)
{
var postMatrix = GetPostMatrix(table, origin);
return(new RenderObjectGroup(_data.Name, parent ?? "Primitives", postMatrix, new RenderObject(
_data.Name,
GetTransformedMesh(table, origin, asRightHanded),
material ?? new PbrMaterial(
table.GetMaterial(_data.Material),
table.GetTexture(_data.Image),
table.GetTexture(_data.NormalMap)
),
_data.IsVisible
)));
}
Matrix3D IRenderable.TransformationMatrix(Table.Table table, Origin origin)
{
switch (origin)
{
case Origin.Original:
var rotMatrix = new Matrix3D().RotateZMatrix(MathF.DegToRad(Data.Orientation));
var transMatrix = new Matrix3D().SetTranslation(Data.Center.X, Data.Center.Y, 0f);
return(rotMatrix.Multiply(transMatrix));
case Origin.Global:
return(Matrix3D.Identity);
default:
throw new ArgumentOutOfRangeException(nameof(origin), origin, "Unknown origin " + origin);
}
}
private bool _solState; // m_solState
public FlipperMover(FlipperData data, Table.Table table, IItem item)
{
var tableData = table.Data;
if (data.FlipperRadiusMin > 0 && data.FlipperRadiusMax > data.FlipperRadiusMin)
{
data.FlipperRadius = data.FlipperRadiusMax - (data.FlipperRadiusMax - data.FlipperRadiusMin) /* m_ptable->m_globalDifficulty*/;
data.FlipperRadius = MathF.Max(data.FlipperRadius, data.BaseRadius - data.EndRadius + 0.05f);
}
else
{
data.FlipperRadius = data.FlipperRadiusMax;
}
EndRadius = MathF.Max(data.EndRadius, 0.01f); // radius of flipper end
FlipperRadius = MathF.Max(data.FlipperRadius, 0.01f); // radius of flipper arc, center-to-center radius
AngleStart = MathF.DegToRad(data.StartAngle);
AngleEnd = MathF.DegToRad(data.EndAngle);
if (AngleEnd == AngleStart)
{
// otherwise hangs forever in collisions/updates
AngleEnd += 0.0001f;
}
var height = table.GetSurfaceHeight(data.Surface, data.Center.X, data.Center.Y);
var baseRadius = MathF.Max(data.BaseRadius, 0.01f);
HitCircleBase = new HitCircle(data.Center, baseRadius, height, height + data.Height, ItemType.Flipper, item);
EnableRotateEvent = 0;
AngleSpeed = 0;
_solState = false;
var ratio = (baseRadius - EndRadius) / FlipperRadius;
// model inertia of flipper as that of rod of length flipr around its end
var mass = data.GetFlipperMass(tableData);
Inertia = (float)(1.0 / 3.0) * mass * (FlipperRadius * FlipperRadius);
// F2 Norm, used in Green's transform, in FPM time search // = sinf(faceNormOffset)
ZeroAngNorm.X = MathF.Sqrt(1.0f - ratio * ratio);
// F1 norm, change sign of x component, i.E -zeroAngNorm.X // = -cosf(faceNormOffset)
ZeroAngNorm.Y = -ratio;
}
private Mesh GetSocketMesh(Table.Table table, Origin origin)
{
var socketMesh = SocketMesh.Clone();
var height = table.GetSurfaceHeight(_data.Surface, _data.Center.X, _data.Center.Y) * table.GetScaleZ();
var transX = origin == Origin.Global ? _data.Center.X : 0f;
var transY = origin == Origin.Global ? _data.Center.Y : 0f;
var transZ = origin == Origin.Global ? height : 0f;
for (var i = 0; i < socketMesh.Vertices.Length; i++)
{
socketMesh.Vertices[i].X = socketMesh.Vertices[i].X * _data.MeshRadius + transX;
socketMesh.Vertices[i].Y = socketMesh.Vertices[i].Y * _data.MeshRadius + transY;
socketMesh.Vertices[i].Z = socketMesh.Vertices[i].Z * _data.MeshRadius * table.GetScaleZ() + transZ;
}
return(socketMesh);
}
/// <summary>
/// Initializes the effect.
/// Resolves object references, extracts source image data.
/// </summary>
/// <param name="Table">Table object containing the effect.</param>
public override void Init(Table.Table Table)
{
InitOK = false;
Pixels = null;
base.Init(Table);
//TODO: Insert replace values for file pattern
if (BitmapFilePattern.IsValid)
{
FileInfo FI = BitmapFilePattern.GetFirstMatchingFile(Table.Pinball.GlobalConfig.GetReplaceValuesDictionary());
if (FI != null && FI.Exists)
{
FastImage BM;
try
{
BM = Table.Bitmaps[FI.FullName];
}
catch (Exception E)
{
Log.Exception("MatrixBitmapEffectBase {0} cant initialize. Could not load file {1}.".Build(Name, FI.FullName), E);
return;
}
if (BM.Frames.ContainsKey(BitmapFrameNumber))
{
Log.Debug("BitmapEffectBase. Grabbing image clip: W: {0}, H:{1}, BML: {2}, BMT: {3}, BMW: {4}, BMH: {5}".Build(new object[] { AreaWidth, AreaHeight, BitmapLeft, BitmapTop, BitmapWidth, BitmapHeight }));
Pixels = BM.Frames[BitmapFrameNumber].GetClip(AreaWidth, AreaHeight, BitmapLeft, BitmapTop, BitmapWidth, BitmapHeight, DataExtractMode).Pixels;
}
else
{
Log.Warning("MatrixBitmapEffectBase {0} cant initialize. Frame {1} does not exist in source image {2}.".Build(Name, BitmapFrameNumber, FI.FullName));
}
}
else
{
Log.Warning("MatrixBitmapEffectBase {0} cant initialize. No file matches the BitmapFilePattern {1} is invalid".Build(Name, BitmapFilePattern.ToString()));
}
}
else
{
Log.Warning("MatrixBitmapEffectBase {0} cant initialize. The BitmapFilePattern {1} is invalid".Build(Name, BitmapFilePattern.ToString()));
}
InitOK = (Pixels != null && MatrixLayer != null);
}
public Matrix3D GetPostMatrix(Table.Table table, Origin origin)
{
switch (origin) {
case Origin.Original:
return new Matrix3D().SetTranslation(
_data.Center.X,
_data.Center.Y,
table.GetSurfaceHeight(_data.Surface, _data.Center.X, _data.Center.Y) * table.GetScaleZ()
);
case Origin.Global:
return Matrix3D.Identity;
default:
throw new ArgumentOutOfRangeException(nameof(origin), origin, "Unknown origin " + origin);
}
}
private Mesh GetBulbMesh(Table.Table table, Origin origin)
{
var bulbMesh = BulbMesh.Clone();
var height = table.GetSurfaceHeight(_data.Surface, _data.Center.X, _data.Center.Y);
var transX = origin == Origin.Global ? _data.Center.X : 0f;
var transY = origin == Origin.Global ? _data.Center.Y : 0f;
var transZ = origin == Origin.Global ? height : 0f;
for (var i = 0; i < bulbMesh.Vertices.Length; i++)
{
bulbMesh.Vertices[i].X = bulbMesh.Vertices[i].X * _data.MeshRadius + transX;
bulbMesh.Vertices[i].Y = bulbMesh.Vertices[i].Y * _data.MeshRadius + transY;
bulbMesh.Vertices[i].Z = bulbMesh.Vertices[i].Z * _data.MeshRadius + transZ;
}
return(bulbMesh);
}
public RenderObjectGroup GetRenderObjects(Table.Table table, bool asRightHanded = true)
{
var renderObjects = new List <RenderObject>();
var sideMesh = GenerateSideMesh(table);
var topMesh = GenerateTopMesh(table);
if (sideMesh != null)
{
renderObjects.Add(GetRenderObject(table, Side, asRightHanded, sideMesh));
}
if (topMesh != null)
{
renderObjects.Add(GetRenderObject(table, Top, asRightHanded, topMesh));
}
return(new RenderObjectGroup(_data.Name, "Surfaces", Matrix3D.Identity, renderObjects.ToArray()));
}
public PbrMaterial GetMaterial(string id, Table.Table table)
{
switch (id)
{
case Base:
return(new PbrMaterial(table.GetMaterial(_data.BaseMaterial), Texture.BumperBase));
case Cap:
return(new PbrMaterial(table.GetMaterial(_data.CapMaterial), Texture.BumperCap));
case Ring:
return(new PbrMaterial(table.GetMaterial(_data.RingMaterial), Texture.BumperRing));
case Skirt:
return(new PbrMaterial(table.GetMaterial(_data.SocketMaterial), Texture.BumperSocket));
}
throw new ArgumentException("Unknown bumper id \"" + id + "\".");
}
public KickerHit(KickerData data, float radius, float height, Table.Table table) : base(data.Center.Clone(), radius, height, height + data.HitHeight, ItemType.Kicker)
{
HitMesh = new Vertex3D[KickerHitMesh.Vertices.Length];
if (!data.LegacyMode)
{
var rad = Radius * 0.8f;
for (var t = 0; t < KickerHitMesh.Vertices.Length; t++)
{
// find the right normal by calculating the distance from current ball position to vertex of the kicker mesh
var vPos = new Vertex3D(KickerHitMesh.Vertices[t].X, KickerHitMesh.Vertices[t].Y, KickerHitMesh.Vertices[t].Z);
vPos.X = vPos.X * rad + data.Center.X;
vPos.Y = vPos.Y * rad + data.Center.Y;
vPos.Z = vPos.Z * rad * table.GetScaleZ() + height;
HitMesh[t] = vPos;
}
}
IsEnabled = data.IsEnabled;
}
public static Rubber GetDefault(Table.Table table)
{
var x = table.Width / 2f;
var y = table.Height / 2f;
var rubberData = new RubberData(table.GetNewName <Rubber>("Rubber"))
{
DragPoints = new[] {
new DragPointData(x, y - 50f)
{
IsSmooth = true
},
new DragPointData(x - 50f * MathF.Cos(MathF.PI / 4), y - 50f * MathF.Sin(MathF.PI / 4))
{
IsSmooth = true
},
new DragPointData(x - 50f, y)
{
IsSmooth = true
},
new DragPointData(x - 50f * MathF.Cos(MathF.PI / 4), y + 50f * MathF.Sin(MathF.PI / 4))
{
IsSmooth = true
},
new DragPointData(x, y + 50f)
{
IsSmooth = true
},
new DragPointData(x + 50f * MathF.Cos(MathF.PI / 4), y + 50f * MathF.Sin(MathF.PI / 4))
{
IsSmooth = true
},
new DragPointData(x + 50f, y)
{
IsSmooth = true
},
new DragPointData(x + 50f * MathF.Cos(MathF.PI / 4), y - 50f * MathF.Sin(MathF.PI / 4))
{
IsSmooth = true
},
}
};
return(new Rubber(rubberData));
}
public static Light GetDefault(Table.Table table)
{
var x = table.Width / 2f;
var y = table.Height / 2f;
var lightData = new LightData(table.GetNewName <Light>("Light"), table.Width / 2f, table.Height / 2f)
{
DragPoints = new[] {
new DragPointData(x, y - 50f)
{
IsSmooth = true
},
new DragPointData(x - 50f * MathF.Cos(MathF.PI / 4), y - 50f * MathF.Sin(MathF.PI / 4))
{
IsSmooth = true
},
new DragPointData(x - 50f, y)
{
IsSmooth = true
},
new DragPointData(x - 50f * MathF.Cos(MathF.PI / 4), y + 50f * MathF.Sin(MathF.PI / 4))
{
IsSmooth = true
},
new DragPointData(x, y + 50f)
{
IsSmooth = true
},
new DragPointData(x + 50f * MathF.Cos(MathF.PI / 4), y + 50f * MathF.Sin(MathF.PI / 4))
{
IsSmooth = true
},
new DragPointData(x + 50f, y)
{
IsSmooth = true
},
new DragPointData(x + 50f * MathF.Cos(MathF.PI / 4), y - 50f * MathF.Sin(MathF.PI / 4))
{
IsSmooth = true
},
}
};
return(new Light(lightData));
}
private HitObject SetupHitObject(HitObject obj, Table.Table table)
{
if (!_primitive.UseAsPlayfield)
{
obj.ApplyPhysics(_data, table);
}
else
{
obj.SetElasticity(table.Data.Elasticity, table.Data.ElasticityFalloff);
obj.SetFriction(table.Data.Friction);
obj.SetScatter(MathF.DegToRad(table.Data.Scatter));
obj.SetEnabled(true);
}
obj.Threshold = _data.Threshold;
obj.E = true;
obj.FireEvents = _data.HitEvent;
return(obj);
}
public RenderObjectGroup GetRenderObjects(Table.Table table, Origin origin, bool asRightHanded)
{
var(preMatrix, _) = GetPreMatrix(table, origin, asRightHanded);
var postMatrix = GetPostMatrix(table, origin);
return(new RenderObjectGroup(_data.Name, "Gates", postMatrix, new RenderObject(
"Wire",
GetBaseMesh().Transform(preMatrix),
new PbrMaterial(table.GetMaterial(_data.Material)),
_data.IsVisible
),
new RenderObject(
"Bracket",
GateBracketMesh.Clone().Transform(preMatrix),
new PbrMaterial(table.GetMaterial(_data.Material)),
_data.IsVisible && _data.ShowBracket
)
));
}
public RenderObjectGroup GetRenderObjects(Table.Table table, Origin origin, bool asRightHanded)
{
var(preMatrix, _) = GetPreMatrix(table, origin, asRightHanded);
var postMatrix = GetPostMatrix(table, origin);
return(new RenderObjectGroup(_data.Name, "Spinners", postMatrix, new RenderObject(
"Plate",
SpinnerPlateMesh.Clone().Transform(preMatrix),
new PbrMaterial(table.GetMaterial(_data.Material), table.GetTexture(_data.Image)),
_data.IsVisible
),
new RenderObject(
"Bracket",
SpinnerBracketMesh.Clone().Transform(preMatrix),
new PbrMaterial(GetBracketMaterial(), table.GetTexture(_data.Image)),
_data.IsVisible && _data.ShowBracket
)
));
}
private Dictionary <string, Mesh> GenerateFlatMesh(Table.Table table)
{
var meshes = new Dictionary <string, Mesh>();
var rv = GetRampVertex(table, -1, true);
meshes["Floor"] = GenerateFlatFloorMesh(table, rv);
if (_data.RightWallHeightVisible > 0.0)
{
meshes["RightWall"] = GenerateFlatRightWall(table, rv);
}
if (_data.LeftWallHeightVisible > 0.0)
{
meshes["LeftWall"] = GenerateFlatLeftWall(table, rv);
}
return(meshes);
}
protected override Tuple <Matrix3D, Matrix3D> GetTransformationMatrix(Table.Table table)
{
// scale matrix
var scaleMatrix = new Matrix3D();
scaleMatrix.SetScaling(Scale.X, Scale.Y, Scale.Z);
// translation matrix
var transMatrix = new Matrix3D();
transMatrix.SetTranslation(Position.X, Position.Y, Position.Z + table.TableHeight);
// translation + rotation matrix
var rotTransMatrix = new Matrix3D();
rotTransMatrix.SetTranslation(_data.RotAndTra[3], _data.RotAndTra[4], _data.RotAndTra[5]);
var tempMatrix = new Matrix3D();
tempMatrix.RotateZMatrix(MathF.DegToRad(_data.RotAndTra[2]));
rotTransMatrix.Multiply(tempMatrix);
tempMatrix.RotateYMatrix(MathF.DegToRad(_data.RotAndTra[1]));
rotTransMatrix.Multiply(tempMatrix);
tempMatrix.RotateXMatrix(MathF.DegToRad(_data.RotAndTra[0]));
rotTransMatrix.Multiply(tempMatrix);
tempMatrix.RotateZMatrix(MathF.DegToRad(_data.RotAndTra[8]));
rotTransMatrix.Multiply(tempMatrix);
tempMatrix.RotateYMatrix(MathF.DegToRad(_data.RotAndTra[7]));
rotTransMatrix.Multiply(tempMatrix);
tempMatrix.RotateXMatrix(MathF.DegToRad(_data.RotAndTra[6]));
rotTransMatrix.Multiply(tempMatrix);
var fullMatrix = scaleMatrix.Clone();
fullMatrix.Multiply(rotTransMatrix);
fullMatrix.Multiply(transMatrix); // fullMatrix = Smatrix * RTmatrix * Tmatrix
scaleMatrix.SetScaling(1.0f, 1.0f, table.GetScaleZ());
fullMatrix.Multiply(scaleMatrix);
return(new Tuple <Matrix3D, Matrix3D>(fullMatrix, null));
}
private static void AddTable(IDbConnection inMemoryConnection, Table.Table table)
{
var sb = new StringBuilder();
sb.Append("CREATE TABLE["); sb.Append(table.NameDB); sb.Append("](");
Column primaryColumn = null;
foreach (var column in table.Columns)
{
sb.Append('['); sb.Append(column.NameDB); sb.Append(']');
var typeName = GetSingleColumnType(column);
sb.Append(typeName);
if (column.Length > 0)
{
sb.Append('('); sb.Append(column.Length); sb.Append(')');
}
sb.Append(',');
if (column.IsPrimary)
{
primaryColumn = column;
}
}
sb.Length--;
if (primaryColumn != null)
{
}
sb.Append(')');
var command = inMemoryConnection.CreateCommand();
command.CommandText = sb.ToString();
command.ExecuteNonQuery();
}
public static MetalWireGuide GetDefault(Table.Table table)
{
var x = table.Width / 2f;
var y = table.Height / 2f;
var metalWireGuideData = new MetalWireGuideData(table.GetNewName <MetalWireGuide>("MetalWireGuide"))
{
DragPoints = new[] {
new DragPointData(x, y - 100f)
{
IsSmooth = true
},
new DragPointData(x, y)
{
IsSmooth = true
},
}
};
return(new MetalWireGuide(metalWireGuideData));
}
protected FirstlySolutionMethod(Supplier[] suppliers, Consumer[] consumers)
{
_table = new Table.Table(suppliers, consumers);
}
public PotentialsMethod(Table.Table table)
{
_table = table;
}
/// <summary>
/// Finishes the EffectEffect.<br/>
/// Releases the references to the target effect and to the table object.
/// </summary>
public override void Finish()
{
TargetEffect = null;
Table = null;
base.Finish();
}
/// <summary>
/// Initializes the EffectEffect. <br/>
/// Resolves the name of the TargetEffect.
/// </summary>
/// <param name="Table">Table object containing the effect.</param>
public override void Init(Table.Table Table)
{
this.Table = Table;
ResolveEffectName(Table);
}
/// <summary>
/// Finish does all necessary cleanupwork before the effect is discarded.
/// </summary>
public override void Finish()
{
base.Finish();
Toy = null;
this.Table = null;
}
