private void Reset()
{
if (_collisionTrigger == null)
{
_collisionTrigger = new CollisionTrigger();
}
_collisionTrigger.IsLast = true;
_collisionTrigger.SaveLastCollision = true;
_highlightGrabTarget = true;
_grabButtonTrigger.StylusButton = StylusButton.Grip;
_grabButtonTrigger.InputButtonEvent = EButtonEvent.OnButton;
_scaleButtonTrigger.TrackedDeviceProvider.TrackedDevice = Handedness.NonDominant;
_scaleButtonTrigger.StylusButton = StylusButton.Grip;
_scaleButtonTrigger.InputButtonEvent = EButtonEvent.OnButton;
_followObjectPositionAction.FollowTargetPosition = (EAxis)(-1);
_followObjectPositionAction.PositionIsOffset = true;
_followObjectRotationAction.FollowTargetRotation = (EAxis)(-1);
_followObjectRotationAction.RotationIsOffset = true;
_followObjectRotationAction.PivotAroundTarget = (EAxis)(-1);
_2ControllerScale = true;
_scaleAction.ScaleMultiplier = 5;
}
public override void Init()
{
if (containingAtom.type != "Person")
{
throw new Exception("This must be added to a Person");
}
_labiaTrigger = containingAtom.GetComponentsInChildren <CollisionTrigger>().FirstOrDefault(t => t.name == "LabiaTrigger");
_labiaHandler = _labiaTrigger.gameObject.GetComponentInChildren <CollisionTriggerEventHandler>();
_abdomen = containingAtom.freeControllers.FirstOrDefault(fc => fc.name == "abdomen2Control");
_animators = new List <LabiaAnimator>();
_animators.Add(LabiaAnimator.Create(containingAtom, "Labia minora-size", isInwardMorph: false, inwardMax: 0.7f, outwardMax: 2));
_animators.Add(LabiaAnimator.Create(containingAtom, "Labia minora-style1", isInwardMorph: false, inwardMax: 0.7f, outwardMax: 2f));
_animators.Add(LabiaAnimator.Create(containingAtom, "Labia minora-exstrophy", isInwardMorph: true, inwardMax: 0.1f, outwardMax: 1f));
_animators.Add(LabiaAnimator.Create(containingAtom, "Labia majora-relaxation", isInwardMorph: false, inwardMax: 1f, outwardMax: 0f));
_animators.Add(LabiaAnimator.Create(containingAtom, "Gen_Innie", isInwardMorph: true, inwardMax: 0.10f, outwardMax: 0.25f, easing: (p) => p * p * p));
_animators.Add(LabiaAnimator.Create(containingAtom, "Gens In - Out", isInwardMorph: true, inwardMax: 1.0f, outwardMax: 0f, enabled: false));
_animators = _animators.Where(a => a != null).ToList(); // remove any null entries
_animators.ForEach(a => a.Morph.SetDefaultValue());
FrictionStorable = new JSONStorableFloat("Friction", 1f, (f) => { _friction = f; }, 0, 1);
_friction = FrictionStorable.val;
CreateSlider(FrictionStorable);
RegisterFloat(FrictionStorable);
InwardExaggerationStorable = new JSONStorableFloat(
"Inward Exaggeration",
0f,
(val) => {
_animators.ForEach(a => a.InwardMax = a.InwardMaxDefault + val);
},
0, 1);
InwardExaggerationStorable.val = 0;
CreateSlider(InwardExaggerationStorable);
RegisterFloat(InwardExaggerationStorable);
OutwardExaggerationStorable = new JSONStorableFloat(
"Outward Exaggeration",
0f,
(val) => {
_animators.ForEach(a => a.OutwardMax = a.OutwardMaxDefault + val);
},
0, 1);
OutwardExaggerationStorable.val = 0;
CreateSlider(OutwardExaggerationStorable);
RegisterFloat(OutwardExaggerationStorable);
foreach (var a in _animators)
{
var storable = new JSONStorableBool(a.Morph.displayName, a.Enabled, (b) => {
a.Enabled = b;
a.Morph.SetDefaultValue();
});
storable.val = a.Enabled;
CreateToggle(storable, rightSide: true);
RegisterBool(storable);
}
}
public void Start()
{
if (_pickupCollider == null)
{
_pickupCollider = GetComponent <Collider>();
}
CollisionTrigger trigger = _pickupCollider.gameObject.AddComponent <CollisionTrigger>();
trigger.onTrigger.AddListener(_OnTrigger);
}
public void OnEnable()
{
if (_pickupCollider == null)
{
return;
}
CollisionTrigger trigger = _pickupCollider.GetComponent <CollisionTrigger>();
trigger.enabled = false;
NonStandard.Clock.setTimeout(() => trigger.enabled = true, 500);
}
private static GameObject CreateTrigger(Vector2 start, Vector2 end, string name, Action onEnter, Color c)
{
GameObject gameObject = CollisionTrigger.CreatePlane(new Vector3[]
{
new Vector3(start.x, start.y),
new Vector3(start.x, end.y),
new Vector3(end.x, start.y),
new Vector3(end.x, end.y)
}, name, c);
PlayerCollisionHandler playerPosTrigger = gameObject.AddComponent <PlayerCollisionHandler>();
playerPosTrigger.onEnter = onEnter;
gameObject.SetActive(true);
return(gameObject);
}
void clearTriggers(string triggerName)
{
CollisionTrigger trig = containingAtom.GetStorableByID(triggerName) as CollisionTrigger;
JSONClass trigClass = trig.trigger.GetJSON();
JSONArray trigArray = trigClass["startActions"].AsArray;
for (int i = 0; i < trigArray.Count; i++)
{
if (trigArray[i]["name"].Value == "ExpRandTrigger")
{
trigArray.Remove(i);
}
}
trig.trigger.RestoreFromJSON(trigClass);
}
public void attack()
{
string stateName = troll.getCurrentAniStateName(2);
if (troll.attackAniNameToTriggerDiactionary.
ContainsKey(stateName))
{
collideTrigger = troll.collisionTriggers[
troll.attackAniNameToTriggerDiactionary[stateName]];
collideTrigger.gameObject.SetActive(true);
}
lock (troll.decisionTree)
{
troll.decisionTree.renewAttackProbablity(2);
}
}
bool checkIfTriggerExists(CollisionTrigger trig)
{
JSONNode presentTriggers = trig.trigger.GetJSON();
JSONArray asArray = presentTriggers["startActions"].AsArray;
for (int i = 0; i < asArray.Count; i++)
{
JSONClass asObject = asArray[i].AsObject;
string name = asObject["name"];
if (name == "ExpRandTrigger" && asObject["receiver"] != null)
{
return(true);
}
}
return(false);
}
private static bool DoesTriggerActionExist(CollisionTrigger trigger, string triggerActionName, string triggerActionType = StartTriggerAction)
{
JSONNode presentTriggers = trigger.trigger.GetJSON();
var asArray = triggerActionType == StartTriggerAction ? presentTriggers["startActions"].AsArray : presentTriggers["endActions"].AsArray;
for (var i = 0; i < asArray.Count; i++)
{
var asObject = asArray[i].AsObject;
string name = asObject["name"];
if (name == triggerActionName && asObject["receiver"] != null)
{
return(true);
}
}
return(false);
}
public void OnEnable()
{
if (_pickupCollider == null)
{
return;
}
CollisionTrigger trigger = _pickupCollider.GetComponent <CollisionTrigger>();
trigger.enabled = false;
GameClock.Delay(500, () => { if (trigger != null)
{
trigger.enabled = true;
}
});
//NonStandard.Clock.setTimeout(() => { if (trigger != null) trigger.enabled = true; }, 500);
}
public void RegisterOnTriggerExit2D(CollisionMatch type, GameObject obj, CollisionTrigger callback, bool inclusive = false)
{
if (type != CollisionMatch.Instantion)
{
throw new InvalidMethodException("wrong method - problem in code logic");
}
CollisionEntry en;
en.type = type;
en.inclusive = inclusive;
en.name = null;
en.obj = obj;
en.callback = callback;
collisionsExit.Add(en);
}
void createTrigger(string triggerName)
{
CollisionTrigger trig = containingAtom.GetStorableByID(triggerName) as CollisionTrigger;
if (!checkIfTriggerExists(trig))
{
if (trig != null)
{
trig.enabled = true;
TriggerActionDiscrete startTrigger;
startTrigger = trig.trigger.CreateDiscreteActionStartInternal();
startTrigger.name = "ExpRandTrigger";
startTrigger.receiverAtom = containingAtom;
startTrigger.receiver = GetPluginStorableById(GetContainingAtom(), "ExpressionRandomizer");
startTrigger.receiverTargetName = "Trigger transition";
}
}
}
private void InitializeObjects()
{
for (int i = 0; i < 5; i++)
{
normalBlocks[i] = new GeneralObject(1)
{
GroupIDs = new int[] { i + 1 },
Color1ID = i + 1,
Color2ID = i + 21,
};
moveTriggers[i] = new MoveTrigger(0, i + 1);
pickupItems[i] = new PickupItem(1275)
{
TargetItemID = i + 1,
};
pickupTriggers[i] = new PickupTrigger(i + 1, 0);
colorTriggers[i] = new ColorTrigger(i + 1)
{
CopiedColorID = i + 21,
};
instantCountTriggers[i] = new InstantCountTrigger(i + 1, i + 1, 0);
collisionBlocks[i] = new CollisionBlock
{
BlockID = i + 1,
};
collisionTriggers[i] = new CollisionTrigger(i + 1, i + 21, i + 1);
}
allObjects = new LevelObjectCollection(normalBlocks.Concat(moveTriggers).Concat(pickupItems).Concat(pickupTriggers).Concat(colorTriggers).Concat(instantCountTriggers).Concat(collisionBlocks).Concat(collisionTriggers));
}
void Update()
{
// Check if there are new collisions every frame the GameObject moves
/*****************************************
*****************************************/
if (transform.hasChanged) {
Collision = this.transform.GetComponent<CollisionTrigger>();
}
// Set HasChanged to false for functions that will not
// execute when the object does not move
/*****************************************
*****************************************/
transform.hasChanged = false;
/*****************************************
*****************************************/
// Jump Handling
/*****************************************
*****************************************/
if (Jump && grounded) {
Z_Speed = Z_MaxSpeed;
grounded = false;
}
Jump = false;
YZ_Last_Displacement = YZ_New_Displacement;
/*****************************************
*****************************************/
// X-Axis Movement
/*****************************************
*****************************************/
if (X_MaxSpeed < 0) {
if ((X_Speed - X_Accel * Time.deltaTime) <= X_MaxSpeed) {
X_Speed = X_MaxSpeed;
} else {
X_Speed -= X_Accel * Time.deltaTime;
}
} else if (X_MaxSpeed > 0){
if ((X_Speed + X_Accel * Time.deltaTime) >= X_MaxSpeed) {
X_Speed = X_MaxSpeed;
} else {
X_Speed += X_Accel * Time.deltaTime;
}
} else { // Decelerate
X_Speed = 0;
}
//Handle Collision
if (X_Speed > 0 && Collision.Collision_Right) {// Prevent Right movement
X_Speed = 0;
}
if(X_Speed < 0 && Collision.Collision_Left){// Prevent Left movement
X_Speed = 0;
}
/*****************************************
*****************************************/
// Y-Axis Movement
/*****************************************
*****************************************/
if (Y_MaxSpeed < 0) {
if ((Y_Speed - Y_Accel * Time.deltaTime) <= Y_MaxSpeed) {
Y_Speed = Y_MaxSpeed;
} else {
Y_Speed -= Y_Accel * Time.deltaTime;
}
} else if (Y_MaxSpeed > 0) {
if ((Y_Speed + Y_Accel * Time.deltaTime) >= Y_MaxSpeed) {
Y_Speed = Y_MaxSpeed;
} else {
Y_Speed += Y_Accel * Time.deltaTime;
}
} else { // Decelerate
Y_Speed = 0;
}
//Handle Collision
if (Y_Speed > 0 && Collision.Collision_Up) {// Prevent Up movement
Y_Speed = 0;
}
if(Y_Speed < 0 && Collision.Collision_Down){// Prevent Down movement
Y_Speed = 0;
}
YZ_New_Displacement = -transform.position.z * YZ_Factor;
/*****************************************
*****************************************/
// Z-Axis Movement
/*****************************************
*****************************************/
if (Z_MaxSpeed < 0) {
if ((Z_Speed - Z_Accel * Time.deltaTime) <= Z_MaxSpeed) {
Z_Speed = Z_MaxSpeed;
} else {
Z_Speed -= Z_Accel * Time.deltaTime;
}
} else if (Z_MaxSpeed > 0) {
if ((Z_Speed + Z_Accel * Time.deltaTime) >= Z_MaxSpeed) {
Z_Speed = Z_MaxSpeed;
} else {
Z_Speed += Z_Accel * Time.deltaTime;
}
} else { // Decelerate
Z_Speed = 0;
}
//Handle Collision
if (Z_Speed > 0 && Collision.Collision_Below) {// Prevent movement Below
Z_Speed = 0;
grounded = true;
}
if(Z_Speed < 0 && Collision.Collision_Over){// Prevent movement Over
Z_Speed = 0;
}
/*****************************************
*****************************************/
// Write the result
/*****************************************
*****************************************/
Vector3 CurrentPosition = transform.position;
CurrentPosition.x += X_Speed * Time.deltaTime;
CurrentPosition.y += Y_Speed * Time.deltaTime - YZ_Last_Displacement + YZ_New_Displacement;
CurrentPosition.z += Z_Speed * Time.deltaTime;
transform.position = CurrentPosition;
}
public void GetUsedIDs()
{
// Part 0
var moveTrigger = new MoveTrigger();
moveTrigger.GroupIDs = groupIDs;
moveTrigger.TargetGroupID = 163;
moveTrigger.TargetPosGroupID = 321;
var used = moveTrigger.UsedGroupIDs;
Assert.IsTrue(used.AssignedIDs.Contains(4));
Assert.IsTrue(used.AssignedIDs.Contains(1));
Assert.IsTrue(used.AssignedIDs.Contains(412));
Assert.IsTrue(used.AssignedIDs.Contains(3));
Assert.AreEqual(163, used.PrimaryID);
Assert.AreEqual(321, used.SecondaryID);
var block = new GeneralObject();
block.GroupIDs = groupIDs;
used = block.UsedGroupIDs;
Assert.IsTrue(used.AssignedIDs.Contains(4));
Assert.IsTrue(used.AssignedIDs.Contains(1));
Assert.IsTrue(used.AssignedIDs.Contains(412));
Assert.IsTrue(used.AssignedIDs.Contains(3));
Assert.AreEqual(0, used.PrimaryID);
Assert.AreEqual(0, used.SecondaryID);
// Part 1
var pulse = new PulseTrigger();
var pickupItem = new PickupItem(ObjectLists.PickupItemList[0]);
var pickup = new PickupTrigger();
var collision = new CollisionTrigger();
pulse.PulseTargetType = PulseTargetType.Group;
pulse.TargetGroupID = 3;
var groups = pulse.UsedGroupIDs;
pulse.PulseTargetType = PulseTargetType.ColorChannel;
pulse.TargetColorID = 4;
pulse.CopiedColorID = 5;
var colors = pulse.UsedColorIDs;
pickupItem.TargetItemID = 41;
pickup.TargetItemID = 42;
var items0 = pickupItem.UsedItemIDs;
var items1 = pickup.UsedItemIDs;
collision.PrimaryBlockID = 50;
collision.SecondaryBlockID = 51;
var blocks = collision.UsedBlockIDs;
Assert.AreEqual(3, groups.PrimaryID);
Assert.AreEqual(0, groups.SecondaryID);
Assert.AreEqual(4, colors.PrimaryID);
Assert.AreEqual(5, colors.SecondaryID);
Assert.AreEqual(41, items0.PrimaryID);
Assert.AreEqual(0, items0.SecondaryID);
Assert.AreEqual(42, items1.PrimaryID);
Assert.AreEqual(0, items1.SecondaryID);
Assert.AreEqual(50, blocks.PrimaryID);
Assert.AreEqual(51, blocks.SecondaryID);
}
public TestSceneIDMigrationBackend()
{
Children = new Drawable[]
{
new SpriteText
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Font = new FontUsage(size: 26),
Text = "Nothing to see here, too bored to make friendly visualized messages indicating test cases"
}
};
var normalBlocks = new GeneralObject[5];
var moveTriggers = new MoveTrigger[5];
var pickupItems = new PickupItem[5];
var pickupTriggers = new PickupTrigger[5];
var colorTriggers = new ColorTrigger[5];
var instantCountTriggers = new InstantCountTrigger[5];
var collisionBlocks = new CollisionBlock[5];
var collisionTriggers = new CollisionTrigger[5];
for (var i = 0; i < 5; i++)
{
normalBlocks[i] = new GeneralObject(1)
{
GroupIDs = new[] { i + 1 },
Color1ID = i + 1,
Color2ID = i + 21
}
}
;
for (var i = 0; i < 5; i++)
{
moveTriggers[i] = new MoveTrigger(0, i + 1);
}
for (var i = 0; i < 5; i++)
{
pickupItems[i] = new PickupItem(1275)
{
TargetItemID = i + 1
}
}
;
for (var i = 0; i < 5; i++)
{
pickupTriggers[i] = new PickupTrigger(i + 1, 0);
}
for (var i = 0; i < 5; i++)
{
colorTriggers[i] = new ColorTrigger(i + 1)
{
CopiedColorID = i + 21
}
}
;
for (var i = 0; i < 5; i++)
{
instantCountTriggers[i] = new InstantCountTrigger(i + 1, i + 1, 0);
}
for (var i = 0; i < 5; i++)
{
collisionBlocks[i] = new CollisionBlock
{
BlockID = i + 1
}
}
;
for (var i = 0; i < 5; i++)
{
collisionTriggers[i] = new CollisionTrigger(i + 1, i + 21, i + 1);
}
var allObjects = new LevelObjectCollection(normalBlocks.Concat(moveTriggers).Concat(pickupItems)
.Concat(pickupTriggers).Concat(colorTriggers).Concat(instantCountTriggers).Concat(collisionBlocks)
.Concat(collisionTriggers).ToList());
var level = new Level
{
Name = "ID Migration Test Level",
Description = "This is a test level to help testing the ID migration feature in the backend",
LevelObjects = allObjects
};
var editor = new Editor(level);
var step0 = new SourceTargetRange(1, 5, 6);
var step1 = new SourceTargetRange(21, 25, 46);
var step2 = new SourceTargetRange(1, 25, 26);
var step3 = new SourceTargetRange(8, 8, 10);
AddStep("Perform Group ID migration 1-5 > 6-10",
() => editor.PerformGroupIDMigration(new List <SourceTargetRange> {
step0
}));
AddAssert("Verify Group ID migration", () => VerifyGroupIDMigration(step0.TargetFrom));
AddStep("Perform Color ID migration 1-25 > 26-50",
() => editor.PerformColorIDMigration(new List <SourceTargetRange> {
step2
}));
AddAssert("Verify Color ID migration", () => VerifyColorIDMigration(step2.TargetFrom, step1.TargetFrom));
AddStep("Perform Item ID migration 1-5 > 6-10",
() => editor.PerformItemIDMigration(new List <SourceTargetRange> {
step0
}));
AddAssert("Verify Item ID migration", () => VerifyItemIDMigration(step0.TargetFrom));
AddStep("Perform Block ID migration 21-25 > 46-50",
() => editor.PerformBlockIDMigration(new List <SourceTargetRange> {
step1
}));
AddAssert("Verify Block ID migration", () => VerifyBlockIDMigration(step0.SourceFrom, step1.TargetFrom));
// TODO: Add more test steps with multiple step ID migrations
bool VerifyGroupIDMigration(int targetFrom)
{
for (var i = 0; i < 5; i++)
{
if (normalBlocks[i].GetGroupID(0) != i + targetFrom)
{
return(false);
}
}
for (var i = 0; i < 5; i++)
{
if (moveTriggers[i].TargetGroupID != i + targetFrom)
{
return(false);
}
}
for (var i = 0; i < 5; i++)
{
if (instantCountTriggers[i].TargetGroupID != i + targetFrom)
{
return(false);
}
}
for (var i = 0; i < 5; i++)
{
if (collisionTriggers[i].TargetGroupID != i + targetFrom)
{
return(false);
}
}
return(true);
}
bool VerifyColorIDMigration(int targetFromA, int targetFromB)
{
for (var i = 0; i < 5; i++)
{
if (normalBlocks[i].Color1ID != i + targetFromA)
{
return(false);
}
if (normalBlocks[i].Color2ID != i + targetFromB)
{
return(false);
}
}
for (var i = 0; i < 5; i++)
{
if (colorTriggers[i].TargetColorID != i + targetFromA)
{
return(false);
}
if (colorTriggers[i].CopiedColorID != i + targetFromB)
{
return(false);
}
}
return(true);
}
bool VerifyItemIDMigration(int targetFrom)
{
for (var i = 0; i < 5; i++)
{
if (pickupItems[i].TargetItemID != i + targetFrom)
{
return(false);
}
}
for (var i = 0; i < 5; i++)
{
if (pickupTriggers[i].TargetItemID != i + targetFrom)
{
return(false);
}
}
return(true);
}
bool VerifyBlockIDMigration(int targetFromA, int targetFromB)
{
for (var i = 0; i < 5; i++)
{
if (collisionBlocks[i].BlockID != i + targetFromA)
{
return(false);
}
}
for (var i = 0; i < 5; i++)
{
if (collisionTriggers[i].PrimaryBlockID != i + targetFromA)
{
return(false);
}
if (collisionTriggers[i].SecondaryBlockID != i + targetFromB)
{
return(false);
}
}
return(true);
}
}
}
}
public PlacedEntity(BuildingView view, CollisionTrigger trigger, BuidingProfile profile)
{
_view = view;
_trigger = trigger;
_profile = profile;
}
public void IDMigration()
{
var normalBlocks = new GeneralObject[5];
var moveTriggers = new MoveTrigger[5];
var pickupItems = new PickupItem[5];
var pickupTriggers = new PickupTrigger[5];
var colorTriggers = new ColorTrigger[5];
var instantCountTriggers = new InstantCountTrigger[5];
var collisionBlocks = new CollisionBlock[5];
var collisionTriggers = new CollisionTrigger[5];
for (int i = 0; i < 5; i++)
{
normalBlocks[i] = new GeneralObject(1)
{
GroupIDs = new int[] { i + 1 },
Color1ID = i + 1,
Color2ID = i + 21,
}
}
;
for (int i = 0; i < 5; i++)
{
moveTriggers[i] = new MoveTrigger(0, i + 1);
}
for (int i = 0; i < 5; i++)
{
pickupItems[i] = new PickupItem(1275)
{
TargetItemID = i + 1,
}
}
;
for (int i = 0; i < 5; i++)
{
pickupTriggers[i] = new PickupTrigger(i + 1, 0);
}
for (int i = 0; i < 5; i++)
{
colorTriggers[i] = new ColorTrigger(i + 1)
{
CopiedColorID = i + 21,
}
}
;
for (int i = 0; i < 5; i++)
{
instantCountTriggers[i] = new InstantCountTrigger(i + 1, i + 1, 0);
}
for (int i = 0; i < 5; i++)
{
collisionBlocks[i] = new CollisionBlock
{
BlockID = i + 1,
}
}
;
for (int i = 0; i < 5; i++)
{
collisionTriggers[i] = new CollisionTrigger(i + 1, i + 21, i + 1);
}
var allObjects = new LevelObjectCollection(normalBlocks.Concat(moveTriggers).Concat(pickupItems).Concat(pickupTriggers).Concat(colorTriggers).Concat(instantCountTriggers).Concat(collisionBlocks).Concat(collisionTriggers).ToList());
var level = new Level
{
Name = "ID Migration Test Level",
Description = "This is a test level to help testing the ID migration feature in the backend",
LevelObjects = allObjects,
};
var editor = new Editor(level);
var step0 = new SourceTargetRange(1, 5, 6);
var step1 = new SourceTargetRange(21, 25, 46);
var step2 = new SourceTargetRange(1, 25, 26);
var step3 = new SourceTargetRange(8, 8, 10);
editor.PerformGroupIDMigration(new List <SourceTargetRange> {
step0
});
Assert.IsTrue(VerifyGroupIDMigration(step0.TargetFrom));
editor.PerformColorIDMigration(new List <SourceTargetRange> {
step2
});
Assert.IsTrue(VerifyColorIDMigration(step2.TargetFrom, step1.TargetFrom));
editor.PerformItemIDMigration(new List <SourceTargetRange> {
step0
});
Assert.IsTrue(VerifyItemIDMigration(step0.TargetFrom));
editor.PerformBlockIDMigration(new List <SourceTargetRange> {
step1
});
Assert.IsTrue(VerifyBlockIDMigration(step0.SourceFrom, step1.TargetFrom));
// TODO: Add more test steps with multiple step ID migrations
bool VerifyGroupIDMigration(int targetFrom)
{
for (int i = 0; i < 5; i++)
{
if (normalBlocks[i].GetGroupID(0) != i + targetFrom)
{
return(false);
}
}
for (int i = 0; i < 5; i++)
{
if (moveTriggers[i].TargetGroupID != i + targetFrom)
{
return(false);
}
}
for (int i = 0; i < 5; i++)
{
if (instantCountTriggers[i].TargetGroupID != i + targetFrom)
{
return(false);
}
}
for (int i = 0; i < 5; i++)
{
if (collisionTriggers[i].TargetGroupID != i + targetFrom)
{
return(false);
}
}
return(true);
}
bool VerifyColorIDMigration(int targetFromA, int targetFromB)
{
for (int i = 0; i < 5; i++)
{
if (normalBlocks[i].Color1ID != i + targetFromA)
{
return(false);
}
if (normalBlocks[i].Color2ID != i + targetFromB)
{
return(false);
}
}
for (int i = 0; i < 5; i++)
{
if (colorTriggers[i].TargetColorID != i + targetFromA)
{
return(false);
}
if (colorTriggers[i].CopiedColorID != i + targetFromB)
{
return(false);
}
}
return(true);
}
bool VerifyItemIDMigration(int targetFrom)
{
for (int i = 0; i < 5; i++)
{
if (pickupItems[i].TargetItemID != i + targetFrom)
{
return(false);
}
}
for (int i = 0; i < 5; i++)
{
if (pickupTriggers[i].TargetItemID != i + targetFrom)
{
return(false);
}
}
return(true);
}
bool VerifyBlockIDMigration(int targetFromA, int targetFromB)
{
for (int i = 0; i < 5; i++)
{
if (collisionBlocks[i].BlockID != i + targetFromA)
{
return(false);
}
}
for (int i = 0; i < 5; i++)
{
if (collisionTriggers[i].PrimaryBlockID != i + targetFromA)
{
return(false);
}
if (collisionTriggers[i].SecondaryBlockID != i + targetFromB)
{
return(false);
}
}
return(true);
}
}
}
}
private void Start()
{
colTrigger = GetComponentInChildren <CollisionTrigger>();
}
