public Task <IChunkColumn> GetChunk(ChunkWorldPos pos)
{
IWorld world = AttachedObject.GetWorld();
var chunkColumnKey = world.MakeAddressByPartitionKey(new ChunkWorldPos(pos.X, pos.Z));
return(Task.FromResult(GrainFactory.GetGrain <IChunkColumn>(chunkColumnKey)));
}
protected override void OnEnter(PlayerInfo player)
{
if (TriggerOwner._state != CosmicInflationController.State.ReadyToCollapse)
{
return;
}
if (player.IsLocalPlayer)
{
AttachedObject.OnEntry -= OnEnterEvent;
AttachedObject.SetTriggerActivation(false);
TriggerOwner._probeDestroyTrigger.SetTriggerActivation(false);
var repelVolume = (WhiteHoleFluidVolume)TriggerOwner._repelVolume;
repelVolume._flowSpeed = -repelVolume._flowSpeed;
repelVolume._massiveFlowSpeed = -repelVolume._massiveFlowSpeed;
repelVolume.SetVolumeActivation(true);
QSBPlayerManager.HideAllPlayers();
ReticleController.Hide();
Locator.GetFlashlight().TurnOff(false);
Locator.GetPromptManager().SetPromptsVisible(false);
OWInput.ChangeInputMode(InputMode.None);
}
else
{
player.SetVisible(false, .3f);
}
if (Occupants.Count == QSBPlayerManager.PlayerList.Count)
{
StartCollapse();
}
}
protected override void OnAttached()
{
_loaded = false;
_chunkLoader = GrainFactory.GetGrain <IUserChunkLoader>(AttachedObject.GetPrimaryKey());
AttachedObject.RegisterPropertyChangedHandler(ViewDistanceComponent.ViewDistanceProperty, OnViewDistanceChanged);
AttachedObject.GetComponent <GameTickComponent>().Tick += OnGameTick;
}
async Task IHandle <PlayerLoggedIn> .Handle(PlayerLoggedIn message)
{
_loaded = false;
await _chunkLoader.JoinGame(AttachedObject.GetWorld(), AttachedObject);
_loaded = true;
}
Task IHandle <BeginLogin> .Handle(BeginLogin message)
{
AttachedObject.GetComponent <GameTickComponent>()
.Tick -= OnGameTick;
_isOnline = false;
return(Task.CompletedTask);
}
private void OnEntityWorldPositionChanged(object sender, PropertyChangedEventArgs <EntityWorldPos> e)
{
var generator = AttachedObject.GetComponent <ClientboundPacketComponent>().GetGenerator();
// Update Collider
var pos = e.NewValue;
var box = new Cuboid(new Point3d(pos.X, pos.Z, pos.Y), new Size(0.6f, 0.6f, 1.75f));
AttachedObject.SetLocalValue(ColliderComponent.ColliderShapeProperty, box);
// Check if we need to send UpdateViewPosition packet. If the player walk cross chunk borders, send it.
var oldChunkPos = e.OldValue.ToChunkWorldPos();
var newChunkPos = e.NewValue.ToChunkWorldPos();
if (oldChunkPos != newChunkPos)
{
generator.UpdateViewPosition(newChunkPos.X, newChunkPos.Z);
}
// Broadcast to trackers
_broadcastComponent = _broadcastComponent ?? AttachedObject.GetComponent <ChunkEventBroadcastComponent>();
_broadcastComponent.GetGenerator(AttachedObject)
.EntityRelativeMove(
AttachedObject.EntityId,
GetDelta(e.OldValue.X, e.NewValue.X),
GetDelta(e.OldValue.Y, e.NewValue.Y),
GetDelta(e.OldValue.Z, e.NewValue.Z),
AttachedObject.GetValue(EntityOnGroundComponent.IsOnGroundProperty));
}
public void PreviousSlide()
{
var hasChangedSlide = false;
if (AttachedObject._slideItem != null && AttachedObject._slideItem.slidesContainer.PrevSlideAvailable())
{
hasChangedSlide = AttachedObject._slideItem.slidesContainer.DecreaseSlideIndex();
if (hasChangedSlide)
{
if (AttachedObject._oneShotSource != null)
{
AttachedObject._oneShotSource.PlayOneShot(AudioType.Projector_Prev);
}
if (AttachedObject.IsProjectorFullyLit())
{
AttachedObject._slideItem.slidesContainer.SetCurrentRead();
AttachedObject._slideItem.slidesContainer.TryPlayMusicForCurrentSlideTransition(false);
}
}
}
if (AttachedObject._gearInterface != null)
{
var audioVolume = hasChangedSlide ? 0f : 0.5f;
AttachedObject._gearInterface.AddRotation(-45f, audioVolume);
}
}
public void SetRepaired()
{
if (!AttachedObject._damaged)
{
return;
}
DebugLog.DebugWrite($"[SATELLITE NODE] {AttachedObject} Set repaired.");
AttachedObject._damaged = false;
var component = Locator.GetPlayerTransform().GetComponent <ReferenceFrameTracker>();
if (component.GetReferenceFrame() == AttachedObject._rfVolume.GetReferenceFrame())
{
component.UntargetReferenceFrame();
}
if (AttachedObject._rfVolume != null)
{
AttachedObject._rfVolume.gameObject.SetActive(false);
}
if (AttachedObject._lanternLight != null)
{
AttachedObject._lanternLight.color = AttachedObject._lightRepairedColor;
}
if (AttachedObject._lanternEmissiveRenderer != null)
{
AttachedObject._lanternEmissiveRenderer.sharedMaterials.CopyTo(AttachedObject._lanternMaterials, 0);
AttachedObject._lanternMaterials[AttachedObject._lanternMaterialIndex] = AttachedObject._lanternRepairedMaterial;
AttachedObject._lanternEmissiveRenderer.sharedMaterials = AttachedObject._lanternMaterials;
}
AttachedObject.RaiseEvent(nameof(AttachedObject.OnRepaired), AttachedObject);
}
protected override Task SendSpawnPacket(ClientPlayPacketGenerator generator)
{
MobType type = AttachedObject.GetComponent <MobTypeComponent>().MobType;
return(generator.SpawnMob(AttachedObject.EntityId, AttachedObject.UUID, (byte)type, AttachedObject.Position, AttachedObject.Pitch, AttachedObject.Yaw, new EntityMetadata.Entity {
}));
}
public int FormatMessage(int dwFlags, IntPtr lpSource, int dwMessageId, int dwLanguageId, ref IntPtr lpBuffer, int nSize, IntPtr arguments)
{
var stopwatch = Stopwatch.StartNew();
var result = AttachedObject.FormatMessage(dwFlags, lpSource, dwMessageId, dwLanguageId, ref lpBuffer, nSize, arguments);
stopwatch.Stop();
var callEvent = new PInvokeInt32CallCompletedTraceEvent
{
DllName = Kernel32Dll,
Duration = stopwatch.Elapsed,
MethodName = nameof(FormatMessage),
Result = result
};
callEvent.Args.Add(nameof(dwFlags), dwFlags);
callEvent.Args.Add(nameof(lpSource), lpSource);
callEvent.Args.Add(nameof(dwMessageId), dwMessageId);
callEvent.Args.Add(nameof(dwLanguageId), dwLanguageId);
callEvent.Args.Add(nameof(nSize), nSize);
callEvent.Args.Add(nameof(arguments), arguments);
callEvent.OutArgs.Add(nameof(lpBuffer), lpBuffer);
LogVerbose(callEvent);
return(result);
}
protected override void OnAttached()
{
AttachedObject.GetComponent <AddressByPartitionKeyComponent>()
.KeyChanged += AddressByPartitionKeyChanged;
AttachedObject.RegisterPropertyChangedHandler(IsEnabledComponent.IsEnabledProperty, OnIsEnabledChanged);
AttachedObject.QueueOperation(TrySubscribe);
}
private Task DispatchPacket(PlayerPosition packet)
{
// TODO: check if player movement is valid
AttachedObject.SetLocalValue(EntityWorldPositionComponent.EntityWorldPositionProperty, new EntityWorldPos((float)packet.X, (float)packet.FeetY, (float)packet.Z));
AttachedObject.SetLocalValue(EntityOnGroundComponent.IsOnGroundProperty, packet.OnGround);
return(Task.CompletedTask);
}
public Task Teleport(EntityWorldPos position, float yaw, float pitch)
{
var generator = AttachedObject.GetComponent <ClientboundPacketComponent>().GetGenerator();
uint teleportId = AttachedObject.GetComponent <TeleportComponent>().StartNew();
return(generator.PositionAndLook(position.X, position.Y, position.Z, yaw, pitch, 0, teleportId));
}
private void StartCollapse()
{
var repelVolume = (WhiteHoleFluidVolume)TriggerOwner._repelVolume;
repelVolume.SetVolumeActivation(false);
QSBPlayerManager.ShowAllPlayers();
TriggerOwner._state = CosmicInflationController.State.Collapsing;
TriggerOwner._stateChangeTime = Time.time;
TriggerOwner._collapseStartPos = TriggerOwner._possibilitySphereRoot.localPosition;
AttachedObject.SetTriggerActivation(false);
TriggerOwner._inflationLight.FadeTo(1f, 1f);
TriggerOwner._possibilitySphereController.OnCollapse();
if (TriggerOwner._campsiteController.GetUseAltPostCollapseSocket())
{
TriggerOwner._playerPostCollapseSocket = TriggerOwner._altPlayerPostCollapseSocket;
TriggerOwner._altTravelerToHidePostCollapse.SetActive(false);
}
Locator.GetPlayerBody().SetPosition(TriggerOwner._playerPostCollapseSocket.position);
Locator.GetPlayerBody().SetRotation(TriggerOwner._playerPostCollapseSocket.rotation);
Locator.GetPlayerBody().SetVelocity(-TriggerOwner._playerPostCollapseSocket.forward);
Locator.GetPlayerTransform().GetRequiredComponent <PlayerLockOnTargeting>().LockOn(TriggerOwner._possibilitySphereRoot, 2f);
foreach (var particles in TriggerOwner._smokeSphereParticles)
{
particles.Stop();
}
}
public static void AttachObjectToPlayer(Client player, uint model, int bone, Vector3 posOffset, Vector3 rotOffset)
{
var attObj = new AttachedObject(model, bone, posOffset, rotOffset);
player.SetSharedData("attachedObject", JsonConvert.SerializeObject(attObj));
Trigger.ClientEventInRange(player.Position, 550, "attachObject", player);
}
public AttachedObject()
{
if (instance == null)
{
instance = this;
}
}
void DetachObject()
{
if (Parts.CheckIfNull())
{
return;
}
for (int i = 0; i < Parts.Fingers.Length; i++)
{
Parts.Fingers[i].IsHoldingObject = false;
}
if (AttachedObject == null)
{
return;
}
if (AttachedObject.Rigidbody != null)
{
Parts.IgnoreCollisions(AttachedObject.Rigidbody, false);
}
AttachedObject.Detach();
AttachedObject = null;
OnObjectDetached();
}
Task IHandle <KickPlayer> .Handle(KickPlayer message)
{
AttachedObject.GetComponent <GameTickComponent>()
.Tick -= OnGameTick;
_isOnline = false;
return(Task.CompletedTask);
}
public virtual bool AcceptsItem(IQSBOWItem item)
{
var itemType = item.GetItemType();
var acceptableType = AttachedObject.GetValue <ItemType>("_acceptableType");
return((itemType & acceptableType) == itemType);
}
private async Task ActionLook()
{
// 通知周围creature entity看着玩家
EntityWorldPos entityPos = AttachedObject.GetValue(EntityWorldPositionComponent.EntityWorldPositionProperty);
ChunkWorldPos chunkPos = entityPos.ToChunkWorldPos();
IChunkTrackingHub tracker = GrainFactory.GetGrain <IChunkTrackingHub>(AttachedObject.GetAddressByPartitionKey());
var list = await tracker.GetTrackedPlayers();
// TODO 多位玩家的话只看一位
foreach (IPlayer each in list)
{
EntityWorldPos playerPosition = await each.GetPosition();
// 三格内玩家
if (EntityWorldPos.Distance(playerPosition, entityPos) < 3)
{
(var yaw, var pitch) = VectorToYawAndPitch(entityPos, playerPosition);
await AttachedObject.SetLocalValue(EntityLookComponent.YawProperty, yaw);
await AttachedObject.SetLocalValue(EntityLookComponent.HeadYawProperty, yaw);
await AttachedObject.SetLocalValue(EntityLookComponent.PitchProperty, pitch);
break;
}
}
}
//-------------------------------------------------
// Attach a GameObject to this GameObject
//
// objectToAttach - The GameObject to attach
// flags - The flags to use for attaching the object
// attachmentPoint - Name of the GameObject in the hierarchy of this Hand which should act as the attachment point for this GameObject
//-------------------------------------------------
public void AttachObject(GameObject objectToAttach, AttachmentFlags flags = defaultAttachmentFlags, string attachmentPoint = "")
{
if (flags == 0)
{
flags = defaultAttachmentFlags;
}
//Make sure top object on stack is non-null
CleanUpAttachedObjectStack();
//Detach the object if it is already attached so that it can get re-attached at the top of the stack
DetachObject(objectToAttach);
//Detach from the other hand if requested
if (((flags & AttachmentFlags.DetachFromOtherHand) == AttachmentFlags.DetachFromOtherHand) && otherHand)
{
otherHand.DetachObject(objectToAttach);
}
if ((flags & AttachmentFlags.DetachOthers) == AttachmentFlags.DetachOthers)
{
//Detach all the objects from the stack
while (attachedObjects.Count > 0)
{
DetachObject(attachedObjects[0].attachedObject);
}
}
if (currentAttachedObject)
{
currentAttachedObject.SendMessage("OnHandFocusLost", this, SendMessageOptions.DontRequireReceiver);
}
AttachedObject attachedObject = new AttachedObject();
attachedObject.attachedObject = objectToAttach;
attachedObject.originalParent = objectToAttach.transform.parent != null ? objectToAttach.transform.parent.gameObject : null;
if ((flags & AttachmentFlags.ParentToHand) == AttachmentFlags.ParentToHand)
{
//Parent the object to the hand
objectToAttach.transform.parent = GetAttachmentTransform(attachmentPoint);
attachedObject.isParentedToHand = true;
}
else
{
attachedObject.isParentedToHand = false;
}
attachedObjects.Add(attachedObject);
if ((flags & AttachmentFlags.SnapOnAttach) == AttachmentFlags.SnapOnAttach)
{
objectToAttach.transform.localPosition = Vector3.zero;
objectToAttach.transform.localRotation = Quaternion.identity;
}
HandDebugLog("AttachObject " + objectToAttach);
objectToAttach.SendMessage("OnAttachedToHand", this, SendMessageOptions.DontRequireReceiver);
UpdateHovering();
}
protected override void OnAttached()
{
Register();
AttachedObject.SetLocalValue(EntityAiComponent.CreatureStateProperty, CreatureState.Stop);
CreateAi(MobType);
AttachedObject.RegisterPropertyChangedHandler(MobTypeComponent.MobTypeProperty, OnMobTypeChanged);
}
public LuerlockConnector(LuerlockAdapter.Side side, LuerlockAdapter luerlock, GameObject collider) : base(luerlock.transform)
{
GeneralItem = luerlock;
attached = new AttachedObject();
this.side = side;
this.Collider = collider;
}
public virtual void Detach()
{
if (null != AttachedObject)
{
AttachedObject.RemoveDataContextChangedHandler(DoDataContextChanged);
}
}
async Task IHandle <PlayerLoggedIn> .Handle(PlayerLoggedIn message)
{
var generator = AttachedObject.GetComponent <ClientboundPacketComponent>().GetGenerator();
// PositionAndLook
var position = AttachedObject.GetEntityWorldPosition();
var lookComponent = AttachedObject.GetComponent <EntityLookComponent>();
await generator.PositionAndLook(position.X, position.Y, position.Z, lookComponent.Yaw, lookComponent.Pitch, 0, AttachedObject.GetComponent <TeleportComponent>().StartNew());
// Health
var healthComponent = AttachedObject.GetComponent <HealthComponent>();
var foodComponent = AttachedObject.GetComponent <FoodComponent>();
await generator.UpdateHealth(healthComponent.Health, healthComponent.MaxHealth, foodComponent.Food, foodComponent.MaxFood, foodComponent.FoodSaturation);
// Experience
var expComponent = AttachedObject.GetComponent <ExperienceComponent>();
await generator.SetExperience(expComponent.ExperienceBar, expComponent.Level, expComponent.TotalExperience);
// Inventory
var slots = await AttachedObject.GetComponent <InventoryComponent>().GetInventoryWindow().GetSlots(AttachedObject);
await generator.WindowItems(0, slots);
InstallPropertyChangedHandlers();
}
private Task OnEntityWorldPositionChanged(object sender, PropertyChangedEventArgs <EntityWorldPos> e)
{
var pos = e.NewValue;
var box = new Cuboid(new Point3d(pos.X, pos.Z, pos.Y), new Size(0.6f, 0.6f, 1.75f));
return(AttachedObject.SetLocalValue(ColliderComponent.ColliderShapeProperty, box));
}
public async Task PlaceBlock(BlockWorldPos location, EntityInteractHand hand, PlayerDiggingFace face, Vector3 cursorPosition)
{
if (face != PlayerDiggingFace.Special)
{
var world = AttachedObject.GetWorld();
var blockState = await world.GetBlockState(GrainFactory, location);
var blockHandler = BlockHandler.Create((BlockId)blockState.Id);
if (blockHandler.IsUsable)
{
await blockHandler.UseBy(AttachedObject, GrainFactory, world, location, cursorPosition);
}
else
{
var heldItem = await AttachedObject.GetComponent <HeldItemComponent>().GetHeldItem();
if (!heldItem.slot.IsEmpty)
{
var itemHandler = ItemHandler.Create((uint)heldItem.slot.BlockId);
if (itemHandler.IsPlaceable)
{
var inventory = AttachedObject.GetComponent <InventoryComponent>().GetInventoryWindow();
await itemHandler.PlaceBy(AttachedObject, GrainFactory, world, location, inventory, heldItem.index, face, cursorPosition);
}
}
}
}
}
public int RasEnumDevices(RASDEVINFO[] lpRasDevInfo, ref int lpCb, ref int lpcDevices)
{
var callEvent = new PInvokeInt32CallCompletedTraceEvent
{
DllName = RasApi32Dll,
MethodName = nameof(RasEnumDevices)
};
callEvent.Args.Add(nameof(lpRasDevInfo), lpRasDevInfo);
callEvent.Args.Add(nameof(lpCb), lpCb);
callEvent.Args.Add(nameof(lpcDevices), lpcDevices);
var stopwatch = Stopwatch.StartNew();
var result = AttachedObject.RasEnumDevices(lpRasDevInfo, ref lpCb, ref lpcDevices);
stopwatch.Stop();
callEvent.Duration = stopwatch.Elapsed;
callEvent.Result = result;
callEvent.OutArgs.Add(nameof(lpCb), lpCb);
callEvent.OutArgs.Add(nameof(lpcDevices), lpcDevices);
LogVerbose(callEvent);
return(result);
}
public int RasDial(ref RASDIALEXTENSIONS lpRasDialExtensions, string lpszPhoneBook, ref RASDIALPARAMS lpRasDialParams, NotifierType dwNotifierType, RasDialFunc2 lpvNotifier, out IntPtr lphRasConn)
{
var stopwatch = Stopwatch.StartNew();
var result = AttachedObject.RasDial(ref lpRasDialExtensions, lpszPhoneBook, ref lpRasDialParams, dwNotifierType, lpvNotifier, out lphRasConn);
stopwatch.Stop();
var callEvent = new PInvokeInt32CallCompletedTraceEvent
{
DllName = RasApi32Dll,
Duration = stopwatch.Elapsed,
MethodName = nameof(RasDial),
Result = result,
};
callEvent.Args.Add(nameof(lpRasDialExtensions), lpRasDialExtensions);
callEvent.Args.Add(nameof(lpszPhoneBook), lpszPhoneBook);
callEvent.Args.Add(nameof(lpRasDialParams), lpRasDialParams);
callEvent.Args.Add(nameof(dwNotifierType), dwNotifierType);
callEvent.Args.Add(nameof(lpvNotifier), lpvNotifier);
callEvent.OutArgs.Add(nameof(lphRasConn), lphRasConn);
LogVerbose(callEvent);
return(result);
}
private async Task DispatchPacket(PlayerDigging packet)
{
var face = ConvertDiggingFace(packet.Face);
var component = AttachedObject.GetComponent <DiggingComponent>();
switch (packet.Status)
{
case PlayerDiggingStatus.StartedDigging:
await component.StartDigging(packet.Location, face);
break;
case PlayerDiggingStatus.CancelledDigging:
await component.CancelDigging(packet.Location, face);
break;
case PlayerDiggingStatus.FinishedDigging:
await component.FinishDigging(packet.Location, face);
break;
default:
Logger.LogWarning($"Not implemented digging status: {packet.Status}");
break;
}
}
/// <summary>
/// Attach a GameObject to this GameObject.
/// </summary>
/// <param name="objectToAttach">The GameObject to attach.</param>
/// <param name="flags">The flags to use for attaching the object.</param>
/// <param name="attachmentPoint">Name of the GameObject in the hierarchy of this VRHand which should act as the attachment point for this GameObject.</param>
/// <seealso cref="DetachObject"/>
public void AttachObject( GameObject objectToAttach, AttachmentFlags flags = defaultAttachmentFlags, string attachmentPoint = "" )
{
if ( flags == 0 )
{
flags = defaultAttachmentFlags;
}
//Make sure top object on stack is non-null
CleanUpAttachedObjectStack();
//Detach the object if it is already attached so that it can get re-attached at the top of the stack
DetachObject( objectToAttach );
//Detach from the other hand if requested
if ( ( ( flags & AttachmentFlags.DetachFromOtherHand ) == AttachmentFlags.DetachFromOtherHand ) && otherHand )
{
otherHand.DetachObject( objectToAttach );
}
if ( ( flags & AttachmentFlags.DetachOthers ) == AttachmentFlags.DetachOthers )
{
//Detach all the objects from the stack
while ( attachedObjects.Count > 0 )
{
DetachObject( attachedObjects[0].attachedObject );
}
}
if ( currentAttachedObject )
{
currentAttachedObject.SendMessage( "OnHandFocusLost", this, SendMessageOptions.DontRequireReceiver );
}
AttachedObject attachedObject = new AttachedObject();
attachedObject.attachedObject = objectToAttach;
attachedObject.originalParent = objectToAttach.transform.parent != null ? objectToAttach.transform.parent.gameObject : null;
if ( ( flags & AttachmentFlags.ParentToHand ) == AttachmentFlags.ParentToHand )
{
//Parent the object to the hand
objectToAttach.transform.parent = GetAttachmentTransform( attachmentPoint );
attachedObject.isParentedToHand = true;
}
else
{
attachedObject.isParentedToHand = false;
}
attachedObjects.Add( attachedObject );
if ( ( flags & AttachmentFlags.SnapOnAttach ) == AttachmentFlags.SnapOnAttach )
{
objectToAttach.transform.localPosition = Vector3.zero;
objectToAttach.transform.localRotation = Quaternion.identity;
}
VRHandDebugLog( "AttachObject " + objectToAttach );
objectToAttach.SendMessage( "OnAttachedToHand", this, SendMessageOptions.DontRequireReceiver );
UpdateHovering();
}
/// <summary>
/// Attach a GameObject to this GameObject.
/// </summary>
/// <param name="objectToAttach">The GameObject to attach.</param>
/// <param name="snapOnAttach">Should the GameObject snap to an attachment point?</param>
/// <param name="attachmentPoint">Name of the GameObject in the hierarchy of this VRHand which should act as the attachment point for this GameObject.</param>
/// <param name="detachOthers">Should all other attached objects in the attached object stack of this VRHand be detached?</param>
/// <seealso cref="DetachObject"/>
public void AttachObject( GameObject objectToAttach, bool snapOnAttach = true, string attachmentPoint = "", bool detachOthers = true )
{
//Make sure top object on stack is non-null
CleanUpAttachedObjectStack();
//Detach the object if it is already attached so that it can get re-attached at the top of the stack
DetachObject( objectToAttach );
if ( otherHand )
{
otherHand.DetachObject( objectToAttach );
}
if ( detachOthers )
{
//Detach all the objects from the stack
while ( attachedObjects.Count > 0 )
{
DetachObject( attachedObjects[0].attachedObject );
}
}
if ( currentAttachedObject )
{
currentAttachedObject.SendMessage( "OnHandFocusLost", this, SendMessageOptions.DontRequireReceiver );
}
AttachedObject attachedObject = new AttachedObject();
attachedObject.attachedObject = objectToAttach;
attachedObject.originalParent = objectToAttach.transform.parent != null ? objectToAttach.transform.parent.gameObject : null;
attachedObjects.Add( attachedObject );
//Parent the object to the hand
objectToAttach.transform.parent = GetAttachmentTransform( attachmentPoint );
if ( snapOnAttach )
{
objectToAttach.transform.localPosition = Vector3.zero;
objectToAttach.transform.localRotation = Quaternion.identity;
}
objectToAttach.SendMessage( "OnAttachedToHand", this, SendMessageOptions.DontRequireReceiver );
UpdateHovering();
}
