private void Snap()
{
var handle = target as SnappingSetOwner;
if (options != null)
{
options.Itterate();
}
else
{
options = new Snapper(handle, selectedFilter, selectedVertex);
}
Snapper.SnapMode snapMode;
switch (Tools.current)
{
case Tool.Move:
snapMode = Snapper.SnapMode.position;
break;
case Tool.Rotate:
snapMode = Snapper.SnapMode.rotation;
break;
case Tool.Transform:
snapMode = Snapper.SnapMode.both;
break;
default:
snapMode = Snapper.SnapMode.none;
break;
}
options.Snap(handle.gameObject, snapMode);
}
private void DrawSelectionHandles(SnappingSetOwner handle)
{
foreach (var set in handle.GetComponentsInChildren <SnappingSet>())
{
foreach (var filter in set.GetComponentsInChildren <MeshFilter>())
{
var mesh = filter.sharedMesh;
for (int i = 0; i < mesh.vertexCount; i++)
{
Vector3 vertex = mesh.vertices[i];
Vector3 normal = mesh.normals[i];
Vector3 worldSpaceVertex = filter.transform.localToWorldMatrix.MultiplyPoint(vertex);
Vector3 worldSpaceNormal = filter.transform.localToWorldMatrix.MultiplyVector(normal);
Color color = Handles.color;
if (selectedFilter == filter && selectedVertex == i)
{
Handles.color = Color.green;
}
if (Handles.Button(worldSpaceVertex, Quaternion.LookRotation(worldSpaceNormal, Vector3.up), 0.06f, 0.1f, Handles.CircleHandleCap))
{
selectedFilter = filter;
selectedVertex = i;
options = null;
}
Handles.color = color;
}
}
}
}
// Start is called before the first frame update
void Start()
{
startingRotation = transform.rotation; //Set current rotation as the starting rotation
rb = GetComponent <Rigidbody>();
snapper = GetComponent <Snapper>();
defaultScale = transform.localScale;
}
public void Awake() {
_characterCollider = GetComponent<BoxCollider>();
_characterRigidbody = GetComponent<Rigidbody>();
_slothSnapper = GetComponent<Snapper>();
_slothController = GetComponent<SlothController>();
ragdolled = false;
}
public new void Awake() {
base.Awake();
_path = transform.Find("Path").GetComponent<BoxCollider>();
_cursor = transform.Find("Path/Cursor").GetComponent<Joint>();
_slothSnapper = GameObject.FindGameObjectWithTag("SlothNinja").GetComponent<Snapper>();
}
static void Main(string[] args)
{
var s = new Snapper();
s.InputTxt();
s.CalcAllCase();
s.OutputResult();
}
public float DashSpeed = 0.9f; // per ms
public SimulatorBasic2d(
SnapInputManager <InputBasic2d, InputPackerBasic2d> input,
Snapper <NentBasic2d, NentStaticBasic2d, PackerBasic2d, PackInfoBasic2d> nents)
{
Input = input;
Nents = nents;
NentDatas = new ReArrayIdPool <SnapHistory <NentBasic2d, NentStaticBasic2d> > [2];
NentDatas[0] = nents.FirstData;
NentDatas[1] = nents.SecondData;
}
public static void SendCompletion(Snapper snapsnap)
{
if (snap == snapsnap && snap.col.gameObject == snap.correctObject && snap.neededSequence == snap.seq.currentBodyPart)
{
snap.OnFinish();
Debug.Log("correct object");
}
else
{
snap.Canceled();
Debug.Log("not the correct object");
}
}
public SimulatorBasic2d(
SnapInputManager <InputBasic2d, InputPackerBasic2d> input,
Snapper <NentBasic2d, NentStaticBasic2d, PackerBasic2d, PackInfoBasic2d> nents,
AdvancerConfigBasic2d config)
{
Input = input;
Nents = nents;
Logician = new SnapInLogician <NentBasic2d, NentStaticBasic2d, PackerBasic2d, PackInfoBasic2d,
InputBasic2d, InputPackerBasic2d,
InAdvancerBasic2d, AdvancerConfigBasic2d>
(input, nents, config);
}
protected override void WndProc(ref Message m)
{
switch (m.Msg)
{
case Snapper.WM_WINDOWPOSCHANGING:
Snapper.SnapToDesktopBorder(this, m.LParam, 0, 5, 5);
break;
default:
break;
}
base.WndProc(ref m);
}
private static object ConvertImpl(object value, Type targetType)
{
if (value is Dock && targetType == typeof(SnapSide))
{
return(Snapper.ConvertDock((Dock)value));
}
if (value is SnapSide && targetType == typeof(Dock))
{
return(Snapper.ConvertSnapSide((SnapSide)value));
}
return(value);
}
private void CurrentEditor_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
var position = e.GetPosition(CurrentEditor);
_currentAtomVisual = CurrentEditor.GetTargetedVisual(position) as AtomVisual;
if (_currentAtomVisual == null)
{
_angleSnapper = new Snapper(position, EditViewModel);
}
else
{
Mouse.Capture(CurrentEditor);
_angleSnapper = new Snapper(_currentAtomVisual.ParentAtom.Position, EditViewModel);
_lastAtomVisual = _currentAtomVisual;
}
IsDrawing = true;
}
public static void SendNonCompletion(Snapper snapsnap)
{
try
{
if (snap == snapsnap)
{
snap.circleHand.CancelCircle();
snap = null;
}
else
{
snap.Canceled();
snap = null;
Debug.Log("a non current snapper got disconected from somewhere, this is not a problem. dont worry, be happy");
}
}catch { }
}
bool SnapOnApplyDirectlyToTheForehead(GameObject gameObject)
{
Vector3 dir;
bool snap = GetSnappingDirection(gameObject.transform, out dir);
if (!snap)
{
return(false);
}
gameObject.transform.position += dir;
gameObject.transform.SetParent(Core.Instance.transform);
Destroy(gameObject.GetComponent <Rigidbody2D>());
Snapper snapper = gameObject.AddComponent <Snapper>();
Consts.Dir snapDir = Consts.GetDir(dir);
//Debug.Log(transform.name + " " + snapDir);
Core.Instance.RegisterUnit(gameObject);
return(true);
}
public WorldTileSnapper(TileSnapInformationBuilder builder)
{
this.builder = builder;
snapper = new Snapper();
snapper.AddSnapper(new SnapperPointPoint());
}
private void SetCentroid()
{
_centroid = GetCentroid(CurrentEditor.GetMoleculeBoundingBox(AdornedMolecules));
_rotateSnapper = new Snapper(_centroid, CurrentEditor.Chemistry as EditViewModel);
}
// Use this for initialization
void Start()
{
_iosShadows = GameObject.Find("iosShadows");
if(_backgroundImg == null) Debug.LogError(DEBUGTAG+"Background Image"+PC.MISSING_REF);
GameObject cameraGameObject = GameObject.Find ("PlanCamera");
_planCamera = cameraGameObject.GetComponent<Camera>();
_mainCamera = GameObject.Find ("mainCam");
_renderCamera = Camera.main;
_polyDrawer = cameraGameObject.GetComponent <PolygonDrawer> ();
_snapper = cameraGameObject.GetComponent <Snapper> ();
_planTransformation = cameraGameObject.GetComponent <PlanTransformation> ();
_planCamera.GetComponent<Camera>().enabled = false;
_polyDrawer.enabled = false;
_planTransformation.enabled = false;
enabled = false;
Point2 prevBgPoint = new Point2 (UnityEngine.Screen.width / 2 - 50, UnityEngine.Screen.height / 2);
Point2 nextBgPoint = new Point2 (UnityEngine.Screen.width / 2 + 50, UnityEngine.Screen.height / 2);
_backgroundEdge = new Edge2 (prevBgPoint, nextBgPoint);
prevBgPoint.SetNextEdge (_backgroundEdge);
nextBgPoint.SetPrevEdge (_backgroundEdge);
}
public static void Set(Snapper snapsnap)
{
snap = snapsnap;
snap.StartBuilding();
Debug.Log(snap);
}
private void RepeatTestLogic(int clients, int amount, int runs)
{
SnapBasic2dEnvironment senv = new SnapBasic2dEnvironment(clients);
senv.Activate();
senv.FastTick();
// have the server ghost some new entities
List <byte> eids = new List <byte>();
for (int i = 0; i < amount; i++)
{
senv.AddEntityFirst(new NentBasic2d()
{
X = 10f + i,
Y = 5f + i,
XVel = 3f
},
new NentStaticBasic2d()
{
Id1 = 0,
Id2 = 0
}, out byte eid);
eids.Add(eid);
}
ushort timeAdded = senv.NetSnappers[0].CurrentTime;
senv.FastTick();
ushort nextTimeChecked = 0;
ushort timeChecked = senv.NetSnappers[0].CurrentTime;
Snapper <NentBasic2d, NentStaticBasic2d, PackerBasic2d, PackInfoBasic2d> checkNent =
senv.Nents[0];
for (int r = 0; r < runs; r++)
{
nextTimeChecked = senv.NetSnappers[0].CurrentTime;
senv.FastTick(); // allow extra time to be sure the clients
// have these timestamps
// verify that the client has the entities
for (int c = 1; c < senv.NetSnappers.Count; c++)
{
NetExecutorSnapper ns = senv.NetSnappers[c];
Snapper <NentBasic2d, NentStaticBasic2d, PackerBasic2d, PackInfoBasic2d> nent = senv.Nents[c];
for (int i = 0; i < eids.Count; i++)
{
byte eid = eids[i];
// pull the entity from the source so we can compare
SnapHistory <NentBasic2d, NentStaticBasic2d> checkH = checkNent.GetFirstEntity(eid);
Assert.AreNotEqual(null, checkH);
// does this ent exist?
SnapHistory <NentBasic2d, NentStaticBasic2d> h = nent.GetFirstEntity(eid);
Assert.AreNotEqual(null, h);
// do we have snapshots for the latest timestamp?
int checkIndex = h.FindIndex(timeChecked);
Assert.IsTrue(checkIndex != -1);
int checkAgainstIndex = checkH.FindIndex(timeChecked);
Assert.IsTrue(checkAgainstIndex != -1);
// are the values in it correct?
Assert.AreEqual(checkH.Shots[checkAgainstIndex].X, h.Shots[checkIndex].X);
Assert.AreEqual(5f + i, h.Shots[checkIndex].Y);
Assert.AreEqual(3f, h.Shots[checkIndex].XVel);
}
}
timeChecked = nextTimeChecked;
}
}
protected override Rect ArrangeOverride(Size desiredSize)
{
return(Snapper.Snap(ScreenBoundsCore, new Rect(_mousePoint, XamlConstants.ZeroSize), desiredSize.Rect(), SnapOptions.Fit | SnapOptions.Move, SnapDefinition.Default, SnapAdjustment.ZeroAdjustment, SnapAdjustment.ZeroAdjustment, SnapSide.Bottom));
}
public void TestSnapTo()
{
XNAGame game = new XNAGame();
var snapper = new Snapper();
snapper.AddSnapper(new SnapperPointPoint());
var builder = new TileSnapInformationBuilder();
var tileData1 = new TileData(Guid.NewGuid());
tileData1.Dimensions = new Vector3(1, 2, 3);
var tileData2 = new TileData(Guid.NewGuid());
tileData2.Dimensions = new Vector3(2, 2, 5);
var faceSnapType1 = new TileFaceType(Guid.NewGuid())
{
Name = "type1"
};
var faceSnapType2 = new TileFaceType(Guid.NewGuid())
{
Name = "type2"
};
tileData1.SetFaceType(TileFace.Front, faceSnapType1);
tileData1.SetFaceType(TileFace.Right, faceSnapType2);
tileData2.SetFaceType(TileFace.Front, faceSnapType1);
tileData2.SetFaceType(TileFace.Back, faceSnapType1);
var list = new List <ISnappableWorldTarget>();
var worldTarget1 = new SimpleSnappableWorldTarget()
{
TileData = tileData1,
SnapInformation = builder.CreateFromTile(tileData1),
Transformation = new Transformation(Vector3.One, Quaternion.Identity, new Vector3(2, 1, 3))
};
var worldTarget2 = new SimpleSnappableWorldTarget()
{
TileData = tileData2,
SnapInformation = builder.CreateFromTile(tileData2),
Transformation = new Transformation(Vector3.One, Quaternion.Identity, new Vector3(-2, 1, 1))
};
list.Add(worldTarget1);
list.Add(worldTarget2);
var tileData1SnapInformation = builder.CreateFromTile(tileData1);
var transformations = snapper.SnapTo(builder.CreateFromTile(tileData1), list);
var colorTypeMap = new Dictionary <SnapType, Color>();
colorTypeMap.Add(worldTarget1.SnapInformation.SnapList[0].SnapType, Color.Red);
colorTypeMap.Add(worldTarget1.SnapInformation.SnapList[1].SnapType, Color.Green);
game.DrawEvent += delegate
{
for (int i = 0; i < list.Count; i++)
{
var iTarget = (SimpleSnappableWorldTarget)list[i];
renderTile(game, iTarget.Transformation.CreateMatrix(), iTarget.TileData, Color.White);
renderSnapInformation(game, iTarget.Transformation.CreateMatrix(), iTarget.SnapInformation, colorTypeMap);
}
for (int i = 0; i < transformations.Count; i++)
{
var iTransformation = transformations[i];
renderTile(game, iTransformation.CreateMatrix(), tileData1, Color.Yellow);
renderSnapInformation(game, iTransformation.CreateMatrix(), tileData1SnapInformation, colorTypeMap);
}
};
game.Run();
}
public SnapBasic2dEnvironment(int clientCount)
{
Tenv = TestEnvironment.AutoConnected(clientCount,
(serv) =>
{
NetExecutorSnapper netSnap = new NetExecutorSnapper();
NetSnappers.Add(netSnap);
serv.AddExecutor(netSnap);
SnapInputManager <InputBasic2d, InputPackerBasic2d> input =
InputManagerBasic2d.Make();
netSnap.AddInputManager(input);
Inputs.Add(input);
Snapper <NentBasic2d, NentStaticBasic2d, PackerBasic2d, PackInfoBasic2d> nent =
SnapperBasic2d.Make();
netSnap.AddSnapper(nent);
Nents.Add(nent);
SimulatorBasic2d sim = new SimulatorBasic2d(input, nent, new AdvancerConfigBasic2d());
netSnap.LoadSimulator(sim);
Sims.Add(sim);
});
}
private void SetCentroid()
{
_centroid = BasicGeometry.GetCentroid(CurrentEditor.GetMoleculeBoundingBox(AdornedMolecules));
_rotateSnapper = new Snapper(_centroid, CurrentEditor.ViewModel as EditViewModel);
}
// Use this for initialization
void Start()
{
//NEW UI ----------------------------------------------
m_headerRect = new Rect(0,0,Screen.width,m_btnH);
m_drawRect = new Rect(0,-m_drawMenus.Length* m_btnH,m_btnWL,m_drawMenus.Length* m_btnH);
m_tmpDrawRect = new Rect(0,m_btnH,m_btnWL,m_btnH);
// m_planRect = new Rect(m_btnW,-m_planMenus.Length* m_btnH,m_btnWL,m_planMenus.Length* m_btnH);
m_planRect = new Rect(m_btnW,-m_planMenus.Length* m_btnH,m_btnWL,m_btnH);
m_tmpPlanRect = new Rect(0,m_btnH,m_btnWL,m_btnH);
m_paramRect = new Rect(2*m_btnW,-m_paramMenus.Length* m_btnH,m_btnWL*1.25f,m_paramMenus.Length* m_btnH);
m_tmpParamRect = new Rect(0,m_btnH,m_btnWL*1.25f,m_btnH);
m_mainView = new Rect(0,m_btnH,Screen.width,Screen.height-(2*m_btnH));
m_askRect = new Rect(Screen.width/3f,Screen.height/4f,Screen.width/3f,Screen.height/4f);
//NEW UI ----------------------------------------------
if(_backgroundImg == null) Debug.LogError(DEBUGTAG+"Background Image"+PC.MISSING_REF);
GameObject cameraGameObject = GameObject.Find ("PlanCamera");
_planCamera = cameraGameObject.GetComponent<Camera>();
_mainCamera = GameObject.Find ("mainCam");
_renderCamera = Camera.main;
_polyDrawer = cameraGameObject.GetComponent <PolygonDrawer> ();
_snapper = cameraGameObject.GetComponent <Snapper> ();
_planTransformation = cameraGameObject.GetComponent <PlanTransformation> ();
_planCamera.GetComponent<Camera>().enabled = false;
_polyDrawer.enabled = false;
_planTransformation.enabled = false;
enabled = false;
Point2 prevBgPoint = new Point2 (UnityEngine.Screen.width / 2 - 50, UnityEngine.Screen.height / 2);
Point2 nextBgPoint = new Point2 (UnityEngine.Screen.width / 2 + 50, UnityEngine.Screen.height / 2);
_backgroundEdge = new Edge2 (prevBgPoint, nextBgPoint);
prevBgPoint.SetNextEdge (_backgroundEdge);
nextBgPoint.SetPrevEdge (_backgroundEdge);
}
protected override Rect ArrangeOverride(Size desiredSize)
{
return(Snapper.Snap(ScreenBoundsCore, new Rect(Point, XamlConstants.ZeroSize), desiredSize.Rect(), ConvertOptions(Popup.PlacementOptions), SnapDefinition.Default, SnapAdjustment.ZeroAdjustment, SnapAdjustment.ZeroAdjustment, SnapSide.Bottom));
}
// Update is called once per frame
void Update()
{
if (!EnableSnap)
{
return;
}
Snapper.TickPerFrame();
SelfData.PlayerPosition = GameSystem.Instance.Player.transform.position;
SelfData.PlayerVelocity = GameSystem.Instance.Player.velocity;
SelfData.ViewRect = CameraManager.Instance.ViewportTileRect;
SelfData.Flush();
bool shouldUpdateConnection = true;
var connectActiveInstanceThrough = SelfData.ConnectActiveThrough;
if (connectActiveInstanceThrough != 0 && AttachedInstances.Contains(connectActiveInstanceThrough))
{
var instanceData = GetGameData(connectActiveInstanceThrough);
if (instanceData.ConnectActiveThrough != 0 || PublicData.ActiveInstancePID == connectActiveInstanceThrough)
{
shouldUpdateConnection = false;
}
}
if (Input.GetKeyDown(KeyCode.F3))
{
GameMap.Instance.FillBorder(CameraManager.Instance.ViewportTileRect);
}
if (Input.GetKeyDown(KeyCode.F4))
{
GameMap.Instance.ResetBorder(CameraManager.Instance.ViewportTileRect);
}
// Update connection to active instance by searching all attached instance
// Thees values will propergate to all attached game instance.
if (shouldUpdateConnection)
{
var activePID = PublicData.ActiveInstancePID;
SelfData.ConnectActiveThrough = 0;
foreach (var attached in AttachedInstances)
{
var instanceData = GetGameData(attached);
if (attached == activePID)
{
SelfData.ConnectActiveThrough = attached;
break;
}
else if (instanceData.ConnectActiveThrough != 0 && instanceData.ConnectActiveThrough != PID)
{
SelfData.ConnectActiveThrough = attached;
break;
}
}
}
SelfData.Flush();
var connectThrough = SelfData.ConnectActiveThrough;
if (connectThrough != 0)
{
var instanceData = GetGameData(connectThrough);
var offset = -AttachedData[connectThrough].AttachPoint;
if (connectThrough == PublicData.ActiveInstancePID)
{
SelfData.TileOffsetToActiveInstance = offset;
}
else
{
SelfData.TileOffsetToActiveInstance = instanceData.TileOffsetToActiveInstance + offset;
}
}
}
// Use this for initialization
protected void Start()
{
EdgeDrawer.SOLID_EDGE_TEXTURE = Resources.Load ("PoolDesigner/edge") as Texture2D;
_snapper = GetComponent<Snapper> ();
_planTransformation = GetComponent<PlanTransformation> ();
// _gui = GameObject.Find("MainScene").GetComponent<PoolDesignerUI> ();
_gui = GameObject.Find("MainScene").GetComponent<PoolUIv2>();
ResizeRectsToScreen();
m_cotationW = m_cotationH = new Rect(0,0,0,0);
}
