Transform GetMiddleTransform(GrabInfo grab)
{
if (IsAllLeftHand(grab.leftGroup, grab.rightGroup))
{
if (IsPalm(grab.leftGroup))
{
return(grab.right.fingerPalmBone);
}
else if (IsPalm(grab.rightGroup))
{
return(grab.left.fingerPalmBone);
}
else
{
return(leftPalm1.fingerPalmBone);
}
}
else if (IsAllRightHand(grab.leftGroup, grab.rightGroup))
{
if (IsPalm(grab.leftGroup))
{
return(grab.right.fingerPalmBone);
}
else if (IsPalm(grab.rightGroup))
{
return(grab.left.fingerPalmBone);
}
else
{
return(rightPalm1.fingerPalmBone);
}
}
return(null);
}
void Release()
{
if (!isGrabbing)
{
return;
}
var grabbable = grabInfo_.grabbable;
Assert.IsTrue(grabbable.isGrabbed);
grabbable.velocity = grabInfo_.velocity.average;
grabbable.OnReleased(this);
if (grabbable.isGrabbed)
{
// opposite.ReGrab();
}
else
{
grabbable.rigidbody.isKinematic = grabInfo_.isKinematic;
}
grabInfo_ = new GrabInfo();
}
private void ImageGrabbed(GrabInfo grabInfo)
{
var image = BitmapSource.Create(grabInfo.Width, grabInfo.Height, 96, 96, PixelFormats.Rgb24, null, grabInfo.Data, grabInfo.Width * 3);
image.Freeze();
Store.Image = image;
}
GrabInfo GetGrabInfoOfFingersByDetector(int iFingerGroupLeft, int iFingerGroupRight)
{
Finger[] leftFingers = fingerGroups[iFingerGroupLeft];
Finger[] rightFingers = fingerGroups[iFingerGroupRight];
for (int iFingerLeft = 0; iFingerLeft < leftFingers.Length; ++iFingerLeft)
{
for (int iFingerRight = 0; iFingerRight < rightFingers.Length; ++iFingerRight)
{
Finger leftFinger = leftFingers[iFingerLeft];
Finger rightFinger = rightFingers[iFingerRight];
GameObject[] grabbedObjects = GetIntersectObjects(leftFinger, rightFinger);
if (grabbedObjects != null && grabbedObjects.Length > 0)
{
GrabInfo grab = new GrabInfo();
grab.left = leftFinger;
grab.right = rightFinger;
grab.obj = grabbedObjects[0];
grab.grabAngle = 0.0f;
grab.leftGroup = iFingerGroupLeft;
grab.rightGroup = iFingerGroupRight;
selectObject = grab.obj;
// Debug.LogFormat("{0} grabbed by detector {1} and {2}", grab.obj, grab.left.name, grab.right.name);
return(grab);
}
}
}
return(null);
}
public override Capture UpdateCapture(InputState input, CaptureData data)
{
GrabInfo gi = data.custom_data as GrabInfo;
bool bFinished = false;
if (data.which == CaptureSide.Left && (input.bLeftShoulderReleased || input.bLeftTriggerReleased))
{
bFinished = true;
}
else if (data.which == CaptureSide.Right && (input.bRightShoulderReleased || input.bRightTriggerReleased))
{
bFinished = true;
}
if (bFinished)
{
gi.complete();
Capture result = end_transform(data);
if (OnEndGrab != null)
{
OnEndGrab(this, gi.so);
}
return(result);
}
Frame3f handF = (data.which == CaptureSide.Left) ? input.LeftHandFrame : input.RightHandFrame;
gi.stickDelta += (data.which == CaptureSide.Left) ? input.vLeftStickDelta2D : input.vRightStickDelta2D;
gi.update(handF);
// drop-a-copy on X/A button release
if ((data.which == CaptureSide.Left && input.bXButtonReleased) ||
(data.which == CaptureSide.Right && input.bAButtonReleased))
{
SceneObject copy = gi.so.Duplicate();
// save an undo-point for the current xform, and start a new one. That way we can
// step between drop-a-copy stages
end_transform(data);
gi.change = new TransformGizmoChange()
{
parentSO = new WeakReference(gi.so),
parentBefore = gi.so.GetLocalFrame(CoordSpace.SceneCoords),
parentScaleBefore = gi.so.GetLocalScale()
};
// if we do this afterwards, and don't push an interaction state, then when
// we undo/redo we don't end up sitting on top of a duplicate.
context.Scene.History.PushChange(
new AddSOChange()
{
scene = context.Scene, so = copy, bKeepWorldPosition = false
});
}
return(Capture.Continue);
}
private bool ChooseExtremityPlacement(RagdollAnimator.AnimatedPair pair, out Vector3 targetPos)
{
GrabInfo thisLimbGrabInfo = GetGrabInfoForBone(pair.Name);
ClimbingGrabbable chosenGrabbable;
if (thisLimbGrabInfo.isGrabbing)
{
chosenGrabbable = thisLimbGrabInfo.Grabbable;
}
else
{
chosenGrabbable = FindClosestGrabbable(pair.currentPose.worldPosition);
}
//Return the chosen position
if (chosenGrabbable)
{
thisLimbGrabInfo.Grabbable = chosenGrabbable;
targetPos = thisLimbGrabInfo.GetGrabPosition(pair.RagdollBone.Rigidbody.position, lerpDuration, Time.deltaTime);
UnityEngine.Debug.DrawLine(pair.RagdollBone.Rigidbody.position, chosenGrabbable.Transform.position, Color.blue);
UnityEngine.Debug.DrawLine(pair.RagdollBone.Rigidbody.position, targetPos, Color.yellow);
return(true);
}
else
{
thisLimbGrabInfo.Grabbable = null;
targetPos = Vector3.zero;
return(false);
}
}
public bool TryGrab(GrabInfo info, out IGrabImage grabImage)
{
bool isGrabbed = false;
grabImage = null;
CommonOpenFileDialog dialog = new CommonOpenFileDialog
{
IsFolderPicker = false
};
if (dialog.ShowDialog() == CommonFileDialogResult.Ok)
{
string fileName;
fileName = dialog.FileName;
grabImage = _container.Resolve <IGrabImage>();
grabImage.GrabImageInfo = _container.Resolve <GrabImageInfo>();
grabImage.GrabImageInfo.GrabInfo = info.Clone() as GrabInfo;
grabImage.MatImage = new Mat(fileName);
FinishedGrab?.Invoke(this, grabImage);
isGrabbed = true;
}
return(isGrabbed);
}
GrabInfo GetGrabInfoByDetector()
{
for (int iFingerGroupLeft = 0; iFingerGroupLeft < fingerGroups.Length; ++iFingerGroupLeft)
{
for (int iFingerGroupRight = iFingerGroupLeft + 1; iFingerGroupRight < fingerGroups.Length; ++iFingerGroupRight)
{
// ignore thumb palm grab
if (iFingerGroupLeft == (int)FingerGroup.LeftThumb && iFingerGroupRight == (int)FingerGroup.LeftPalm ||
iFingerGroupLeft == (int)FingerGroup.LeftPalm && iFingerGroupRight == (int)FingerGroup.LeftThumb ||
iFingerGroupLeft == (int)FingerGroup.RightThumb && iFingerGroupRight == (int)FingerGroup.RightPalm ||
iFingerGroupLeft == (int)FingerGroup.RightPalm && iFingerGroupRight == (int)FingerGroup.RightThumb)
{
continue;
}
GrabInfo info = GetGrabInfoOfFingersByDetector(iFingerGroupLeft, iFingerGroupRight);
if (info != null)
{
return(info);
}
}
}
return(null);
}
public void Loaded()
{
foreach (string name in Properties.Settings.Default.ImageNames)
{
GrabInfo grabInfo = _container.Resolve <GrabInfo>();
grabInfo.Name = name;
GrabInfoMap.Add(name, grabInfo);
}
for (int i = 0; i < Properties.Settings.Default.GrabberNames.Count; i++)
{
GrabberController controller = _container.Resolve <GrabberController>(
new ResolverOverride[]
{
new ParameterOverride("grabber", _container.Resolve <IGrabber>(Properties.Settings.Default.GrabberNames[i]))
});
controller.GrabInfoMap = GrabInfoMap;
GrabberControllerMap.Add(i, controller);
controller.FinishedGrab += App.Locator.DisplayViewModel.ImageViewModel.FinishedGrab;
}
App.Locator.GrabViewModel.GrabberController = GrabberControllerMap[0];
}
public override Capture ForceEndCapture(InputState input, CaptureData data)
{
GrabInfo gi = data.custom_data as GrabInfo;
gi.complete();
return(end_transform(data));
}
public GrabInfoViewModel(IUnityContainer container)
{
_container = container;
_grabInfo = _container.Resolve <GrabInfo>();
GrabCommand = new KentDelegateCommand(Grab);
}
private void NewViewModel_StartedGrab(object sender, GrabInfo grabInfo)
{
if (GrabberController == null)
{
return;
}
GrabberController.Grabber.AsyncGrab(grabInfo);
}
void push_position_change(CaptureData data)
{
GrabInfo gi = data.custom_data as GrabInfo;
gi.change.parentAfter = gi.grabbedSO.GetLocalFrame(CoordSpace.SceneCoords);
gi.change.parentScaleAfter = gi.grabbedSO.GetLocalScale();
cockpit.Scene.History.PushChange(gi.change, true);
cockpit.Scene.History.PushInteractionCheckpoint();
}
Capture end_transform(CaptureData data)
{
GrabInfo gi = data.custom_data as GrabInfo;
gi.change.parentAfter = gi.so.GetLocalFrame(CoordSpace.SceneCoords);
gi.change.parentScaleAfter = gi.so.GetLocalScale();
context.Scene.History.PushChange(gi.change, true);
context.Scene.History.PushInteractionCheckpoint();
return(Capture.End);
}
private void Grabbed(GrabInfo grabInfo)
{
if (_grabbing)
{
_grabInfo = grabInfo;
_grabbing = false;
}
if (ImageGrabbed != null)
{
ImageGrabbed(grabInfo);
}
}
GrabInfo GetGrabInfoOfFingersByRayCast(int iFingerGroupLeft, int iFingerGroupRight)
{
Finger[] leftFingers = fingerGroups[iFingerGroupLeft];
Finger[] rightFingers = fingerGroups[iFingerGroupRight];
for (int iFingerLeft = 0; iFingerLeft < leftFingers.Length; ++iFingerLeft)
{
for (int iFingerRight = 0; iFingerRight < rightFingers.Length; ++iFingerRight)
{
Finger leftFinger = leftFingers[iFingerLeft];
Finger rightFinger = rightFingers[iFingerRight];
Vector3 leftPosition = leftFinger.fingerRayAnchor.position;
Vector3 rightPosition = rightFinger.fingerRayAnchor.position;
Ray ray = new Ray(leftPosition, rightPosition - leftPosition);
float lenth = Vector3.Distance(leftPosition, rightPosition);
//if (IsSameHand(iFingerGroupLeft, iFingerGroupRight))
//{
// Debug.DrawLine(leftPosition, rightPosition, Color.red);
//}
RaycastHit hitInfo;
if (Physics.Raycast(ray, out hitInfo, lenth, ingoreLayerMask))
{
bool sameHand = IsSameHand(iFingerGroupLeft, iFingerGroupRight);
// same hand fingers or both hand actually touched object
if (sameHand || leftFinger.touchedObjects.Contains(hitInfo.collider.gameObject) && rightFinger.touchedObjects.Contains(hitInfo.collider.gameObject))
{
GrabInfo info = new GrabInfo();
info.left = leftFinger;
info.right = rightFinger;
info.obj = hitInfo.collider.gameObject;
info.grabAngle = 0.0f;
info.leftGroup = iFingerGroupLeft;
info.rightGroup = iFingerGroupRight;
selectObject = info.obj;
return(info);
}
}
}
}
return(null);
}
void Update()
{
GrabInfos.Clear();
var character = CreateCharacterInfo(transform.position);
foreach (var ledge in Ledges)
{
var calculator = new LedgeGrabCalculator(ledge, character, Margin);
var checker = new ClimbPositionChecker(calculator, CollisionLayers, MaxClimbDownHeight);
var info = new GrabInfo(ledge, calculator, checker);
GrabInfos.Add(info);
}
}
public void Copy(GrabInfo src)
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
enable = src.enable;
duration = src.duration;
releaseAttackId = src.releaseAttackId;
parentNode = src.parentNode;
cameraLookAt = src.cameraLookAt;
toCameraDir = src.toCameraDir;
cameraDistance = src.cameraDistance;
releaseByWeakHit = src.releaseByWeakHit;
releaseByWeaponWeakHit = src.releaseByWeaponWeakHit;
drainAttackId = src.drainAttackId;
}
GrabInfo GetGrabInfoByRaycast()
{
// check all fingers
for (int iFingerGroupLeft = 0; iFingerGroupLeft < fingerGroups.Length; ++iFingerGroupLeft)
{
for (int iFingerGroupRight = iFingerGroupLeft + 1; iFingerGroupRight < fingerGroups.Length; ++iFingerGroupRight)
{
GrabInfo info = GetGrabInfoOfFingersByRayCast(iFingerGroupLeft, iFingerGroupRight);
if (info != null)
{
return(info);
}
}
}
return(null);
}
private void Save(GrabInfo grabInfo, string imagePath)
{
if (_mat == null || _mat.Cols != grabInfo.Width || _mat.Rows != grabInfo.Height || _mat.Channels() != grabInfo.Channels)
{
switch (grabInfo.Channels)
{
case 1:
_mat = new Mat(grabInfo.Height, grabInfo.Width, MatType.CV_8UC1);
break;
case 3:
_mat = new Mat(grabInfo.Height, grabInfo.Width, MatType.CV_8UC3);
break;
}
}
Marshal.Copy(grabInfo.Data, 0, _mat.Data, grabInfo.Data.Length);
_mat.ImWrite(string.Format("{0}.{1}", imagePath, _coreConfig.ImageFormat));
}
private void DrawImage(GrabInfo grabInfo)
{
ImageSource source = grabInfo.GetImage();
if (source != null)
{
bool zoomFitRequired = false;
if (ImageSource == null)
{
zoomFitRequired = true;
}
ImageSource = source;
if (zoomFitRequired)
{
FrameworkElement.Dispatcher.Invoke(ZoomFit);
}
}
}
public static ImageSource GetImage(this GrabInfo grabInfo)
{
ImageSource source = null;
switch (grabInfo.Channels)
{
case 1:
source = BitmapSource.Create(grabInfo.Width, grabInfo.Height, 96, 96, PixelFormats.Gray8, null, grabInfo.Data, grabInfo.Width);
break;
case 3:
source = BitmapSource.Create(grabInfo.Width, grabInfo.Height, 96, 96, PixelFormats.Rgb24, null, grabInfo.Data, grabInfo.Width * 3);
break;
}
if (source != null)
{
source.Freeze();
}
return(source);
}
public void Grab(Player _player, GrabInfo info, DrainAttackInfo _drainAtkInfo)
{
Grab(info.duration, _player, info.releaseAttackId, info.releaseByWeakHit, info.releaseByWeaponWeakHit, _drainAtkInfo);
}
public void AsyncGrab(GrabInfo info)
{
if (TryGrab(info, out IGrabImage grabImage) == true)
{
}
}
private IEnumerator DoLoad(int body_id, int anim_id, float scale, string base_effect, string base_effect_node, bool need_shadow, bool enable_light_probes, bool need_anim_event_res_cache, SHADER_TYPE shader_type, int layer, string foundation_name, bool need_stamp_effect, bool will_stock, OnCompleteLoad callback)
{
Enemy enemy = this.get_gameObject().GetComponent <Enemy>();
if (enemy != null)
{
int id = enemy.id;
}
bodyID = body_id;
bodyScale = scale;
bool is_boss = false;
if (enemy != null)
{
is_boss = enemy.isBoss;
if (enemy.controller != null)
{
enemy.controller.set_enabled(false);
}
if (enemy.packetReceiver != null)
{
enemy.packetReceiver.SetStopPacketUpdate(true);
}
enemy.OnLoadStart();
}
string body_name = ResourceName.GetEnemyBody(body_id);
string mate_name = ResourceName.GetEnemyMaterial(body_id);
string anim_name = ResourceName.GetEnemyAnim(anim_id);
Transform _this = this.get_transform();
isLoading = true;
LoadingQueue load_queue = new LoadingQueue(this);
LoadObject lo_body = load_queue.LoadAndInstantiate(RESOURCE_CATEGORY.ENEMY_MODEL, body_name);
LoadObject lo_mate = (mate_name == null) ? null : load_queue.Load(RESOURCE_CATEGORY.ENEMY_MATERIAL, body_name, new string[1]
{
mate_name
}, false);
LoadObject lo_anim = load_queue.Load(RESOURCE_CATEGORY.ENEMY_ANIM, anim_name, new string[2]
{
anim_name + "Ctrl",
anim_name + "Event"
}, false);
if (!string.IsNullOrEmpty(base_effect))
{
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, base_effect);
}
LoadObject lo_foundation = null;
if (!string.IsNullOrEmpty(foundation_name))
{
if (!MonoBehaviourSingleton <GlobalSettingsManager> .I.uiModelRendering.enableEnemyModelFoundationFromQuestStage)
{
foundation_name = "FST011";
}
lo_foundation = load_queue.LoadAndInstantiate(RESOURCE_CATEGORY.FOUNDATION_MODEL, foundation_name);
}
yield return((object)load_queue.Wait());
body = lo_body.Realizes(_this, (layer != -1) ? layer : 11);
if (layer == -1)
{
this.get_gameObject().set_layer(10);
}
body.set_localPosition(Vector3.get_zero());
body.set_localRotation(Quaternion.get_identity());
renderersBody = body.get_gameObject().GetComponentsInChildren <Renderer>();
if (lo_mate != null && lo_mate.loadedObject != null && renderersBody.Length == 1)
{
Material mate = lo_mate.loadedObject as Material;
if (mate != null)
{
renderersBody[0].set_sharedMaterial(mate);
}
}
if (enemy != null)
{
enemy.body = body;
}
body.set_localScale(Vector3.Scale(body.get_localScale(), new Vector3(scale, scale, scale)));
animator = body.get_gameObject().GetComponent <Animator>();
if (animator != null && lo_anim.loadedObjects != null)
{
animator.set_runtimeAnimatorController(lo_anim.loadedObjects[0].obj);
if (lo_anim.loadedObjects.Length >= 2 && lo_anim.loadedObjects[1] != null)
{
this.animEventData = (lo_anim.loadedObjects[1].obj as AnimEventData);
}
if (enemy != null)
{
body.get_gameObject().AddComponent <StageObjectProxy>().stageObject = enemy;
enemy.animEventData = this.animEventData;
}
}
if (!string.IsNullOrEmpty(base_effect))
{
string node_name = base_effect_node;
if (string.IsNullOrEmpty(node_name))
{
node_name = "Root";
}
Transform node = Utility.Find(body, node_name);
Transform effect_transform = EffectManager.GetEffect(base_effect, node);
if (effect_transform != null)
{
baseEffect = effect_transform;
if (layer != -1)
{
Utility.SetLayerWithChildren(effect_transform, layer);
}
}
}
if (shader_type == SHADER_TYPE.LIGHTWEIGHT)
{
ShaderGlobal.ChangeWantLightweightShader(renderersBody);
}
if (is_boss)
{
materialParamsList = new List <MaterialParams>();
Shader.PropertyToID("_RimPower");
Shader.PropertyToID("_RimWidth");
Shader.PropertyToID("_Vanish_flag");
Shader.PropertyToID("_Vanish_rate");
Utility.MaterialForEach(renderersBody, delegate(Material material)
{
if (material != null)
{
MaterialParams materialParams = new MaterialParams
{
material = material
};
if (materialParams.hasRimPower = material.HasProperty(((_003CDoLoad_003Ec__Iterator228) /*Error near IL_062d: stateMachine*/)._003CID_RIM_POWER_003E__16))
{
materialParams.defaultRimPower = material.GetFloat(((_003CDoLoad_003Ec__Iterator228) /*Error near IL_062d: stateMachine*/)._003CID_RIM_POWER_003E__16);
}
if (materialParams.hasRimWidth = material.HasProperty(((_003CDoLoad_003Ec__Iterator228) /*Error near IL_062d: stateMachine*/)._003CID_RIM_WIDTH_003E__17))
{
materialParams.defaultRimWidth = material.GetFloat(((_003CDoLoad_003Ec__Iterator228) /*Error near IL_062d: stateMachine*/)._003CID_RIM_WIDTH_003E__17);
}
materialParams.hasVanishFlag = material.HasProperty(((_003CDoLoad_003Ec__Iterator228) /*Error near IL_062d: stateMachine*/)._003CID_VANISH_FLAG_003E__18);
materialParams.hasVanishRate = material.HasProperty(((_003CDoLoad_003Ec__Iterator228) /*Error near IL_062d: stateMachine*/)._003CID_VANISH_RATE_003E__19);
((_003CDoLoad_003Ec__Iterator228) /*Error near IL_062d: stateMachine*/)._003C_003Ef__this.materialParamsList.Add(materialParams);
}
});
}
int l = 0;
for (int k = renderersBody.Length; l < k; l++)
{
renderersBody[l].set_useLightProbes(enable_light_probes);
}
EnemyParam param = body.get_gameObject().GetComponent <EnemyParam>();
body.get_gameObject().SetActive(false);
if (need_anim_event_res_cache && animator != null && lo_anim.loadedObjects != null && lo_anim.loadedObjects[1] != null)
{
AnimEventData tmpAnimEventData = lo_anim.loadedObjects[1].obj as AnimEventData;
if (tmpAnimEventData != null)
{
if (enemy == null)
{
load_queue.CacheAnimDataUseResource(tmpAnimEventData, null, null);
}
else
{
LoadingQueue loadingQueue = load_queue;
AnimEventData animEventData = tmpAnimEventData;
Enemy enemy2 = enemy;
loadingQueue.CacheAnimDataUseResource(animEventData, ((Character)enemy2).EffectNameAnalyzer, enemy.continusAtkEventDataList);
}
PreSetAnimationEventDataParamToEnemy(tmpAnimEventData, enemy);
}
}
AnimEventData.ResidentEffectData[] residentEffectList = null;
if (this.animEventData != null)
{
residentEffectList = this.animEventData.residentEffectDataList;
if (residentEffectList != null)
{
int numEffect3 = residentEffectList.Length;
for (int ef3 = 0; ef3 < numEffect3; ef3++)
{
if (!string.IsNullOrEmpty(residentEffectList[ef3].effectName))
{
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, residentEffectList[ef3].effectName);
}
}
}
}
if (param != null)
{
if (enemy != null || need_stamp_effect)
{
StageObject.StampInfo[] stampInfos = param.stampInfos;
foreach (StageObject.StampInfo info4 in stampInfos)
{
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, info4.effectName);
}
}
if (param.isHide)
{
FieldMapTable.GatherPointViewTableData viewData = Singleton <FieldMapTable> .I.GetGatherPointViewData(param.gatherPointViewId);
if (viewData != null)
{
if (!string.IsNullOrEmpty(viewData.targetEffectName))
{
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, viewData.targetEffectName);
}
if (!string.IsNullOrEmpty(viewData.gatherEffectName))
{
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, viewData.gatherEffectName);
}
}
}
SystemEffectSetting sysEffectSetting2 = param.residentEffectSetting;
if (sysEffectSetting2 != null)
{
SystemEffectSetting.Data[] effectDataList = sysEffectSetting2.effectDataList;
if (effectDataList != null)
{
int numEffect2 = effectDataList.Length;
for (int ef2 = 0; ef2 < numEffect2; ef2++)
{
if (!string.IsNullOrEmpty(effectDataList[ef2].effectName))
{
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, effectDataList[ef2].effectName);
}
}
}
}
}
if (load_queue.IsLoading())
{
yield return((object)load_queue.Wait());
}
if (enemy != null)
{
if (param != null)
{
EnemyTable.EnemyData data = enemy.enemyTableData;
AttackHitInfo[] attackHitInfos = param.attackHitInfos;
foreach (AttackHitInfo temp_info in attackHitInfos)
{
AttackHitInfo info = temp_info;
if (!string.IsNullOrEmpty(data.convertRegionKey))
{
string convert_name = info.name + "_" + data.convertRegionKey;
AttackHitInfo[] convertAttackHitInfos = param.convertAttackHitInfos;
foreach (AttackHitInfo convert_info in convertAttackHitInfos)
{
if (convert_info.name == convert_name)
{
info = convert_info;
break;
}
}
}
if (info.hitSEID != 0)
{
load_queue.CacheSE(info.hitSEID, null);
}
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, info.hitEffectName);
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, info.remainEffectName);
load_queue.CacheBulletDataUseResource(info.bulletData, null);
RestraintInfo restInfo = temp_info.restraintInfo;
if (restInfo.enable && !string.IsNullOrEmpty(restInfo.effectName))
{
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, restInfo.effectName);
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, "ef_btl_target_flick");
if (temp_info.toPlayer.reactionType != 0)
{
Log.Error(LOG.INGAME, "Can't use reactionType with RestraintInfo!! " + temp_info.name);
}
}
GrabInfo grabInfo = temp_info.grabInfo;
if (grabInfo != null && grabInfo.enable && temp_info.toPlayer.reactionType != 0)
{
Log.Error(LOG.INGAME, "Can't use reactionType with GrabInfo!! " + temp_info.name);
}
InkSplashInfo inkSplashInfo = temp_info.inkSplashInfo;
if (inkSplashInfo != null && inkSplashInfo.duration > 0f)
{
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, "ef_btl_pl_blind_01");
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, "ef_btl_pl_blind_02");
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, "ef_btl_target_flick");
}
}
AttackContinuationInfo[] attackContinuationInfos = param.attackContinuationInfos;
foreach (AttackContinuationInfo temp_info2 in attackContinuationInfos)
{
AttackContinuationInfo info2 = temp_info2;
if (!string.IsNullOrEmpty(data.convertRegionKey))
{
string convert_name2 = info2.name + "_" + data.convertRegionKey;
AttackContinuationInfo[] convertAttackContinuationInfos = param.convertAttackContinuationInfos;
foreach (AttackContinuationInfo convert_info2 in convertAttackContinuationInfos)
{
if (convert_info2.name == convert_name2)
{
info2 = convert_info2;
break;
}
}
}
load_queue.CacheBulletDataUseResource(info2.bulletData, null);
}
Enemy.RegionInfo[] regionInfos = param.regionInfos;
foreach (Enemy.RegionInfo temp_info3 in regionInfos)
{
Enemy.RegionInfo info3 = temp_info3;
if (!string.IsNullOrEmpty(data.convertRegionKey))
{
string convert_name3 = info3.name + "_" + data.convertRegionKey;
Enemy.RegionInfo[] convertRegionInfos = param.convertRegionInfos;
foreach (Enemy.RegionInfo convert_info3 in convertRegionInfos)
{
if (convert_info3.name == convert_name3)
{
info3 = convert_info3;
break;
}
}
}
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, info3.breakEffect.effectName);
}
if (Singleton <EnemyHitMaterialTable> .IsValid())
{
int j = 0;
for (int len2 = param.regionInfos.Length; j < len2 + 1; j++)
{
string hit_material_name = (j >= len2) ? param.baseHitMaterialName : param.regionInfos[j].hitMaterialName;
if (!string.IsNullOrEmpty(hit_material_name))
{
EnemyHitMaterialTable.MaterialData check_data = Singleton <EnemyHitMaterialTable> .I.GetData(hit_material_name);
if (check_data != null)
{
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, check_data.addEffectName);
int[] typeSEIDs = check_data.typeSEIDs;
foreach (int type_se_id in typeSEIDs)
{
if (type_se_id != 0)
{
load_queue.CacheSE(type_se_id, null);
}
}
}
}
}
}
}
if (MonoBehaviourSingleton <InGameSettingsManager> .IsValid())
{
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, MonoBehaviourSingleton <GlobalSettingsManager> .I.linkResources.enemyParalyzeHitEffectName);
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, MonoBehaviourSingleton <GlobalSettingsManager> .I.linkResources.enemyPoisonHitEffectName);
}
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, "ef_btl_enm_shock_01");
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, "ef_btl_enm_fire_01");
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, "ef_btl_pl_movedown_01");
EffectPlayProcessor processor = body.get_gameObject().GetComponent <EffectPlayProcessor>();
if (processor != null && processor.effectSettings != null)
{
enemy.effectPlayProcessor = processor;
int i = 0;
for (int len = processor.effectSettings.Length; i < len; i++)
{
if (!string.IsNullOrEmpty(processor.effectSettings[i].effectName))
{
load_queue.CacheEffect(RESOURCE_CATEGORY.EFFECT_ACTION, processor.effectSettings[i].effectName);
}
}
}
if (load_queue.IsLoading())
{
yield return((object)load_queue.Wait());
}
}
body.get_gameObject().SetActive(true);
if (residentEffectList != null)
{
int numEffect = residentEffectList.Length;
for (int ef = 0; ef < numEffect; ef++)
{
AnimEventData.ResidentEffectData effectData = residentEffectList[ef];
if (!string.IsNullOrEmpty(effectData.effectName) && !string.IsNullOrEmpty(effectData.linkNodeName))
{
Transform parentTrans = Utility.Find(body.get_transform(), effectData.linkNodeName);
if (parentTrans == null)
{
parentTrans = body.get_transform();
}
Transform effectTrans = EffectManager.GetEffect(effectData.effectName, parentTrans);
if (effectTrans != null)
{
if (layer != -1)
{
Utility.SetLayerWithChildren(effectTrans, layer);
}
Vector3 basisScale = effectTrans.get_localScale();
effectTrans.set_localScale(basisScale * effectData.scale);
effectTrans.set_localPosition(effectData.offsetPos);
effectTrans.set_localRotation(Quaternion.Euler(effectData.offsetRot));
ResidentEffectObject residentEffect = effectTrans.get_gameObject().AddComponent <ResidentEffectObject>();
residentEffect.Initialize(effectData);
if (enemy != null)
{
enemy.RegisterResidentEffect(residentEffect);
}
}
}
}
}
if (param != null)
{
SystemEffectSetting sysEffectSetting = param.residentEffectSetting;
SysEffectCreate(enemy, layer, sysEffectSetting);
}
if (need_shadow && param != null && param.shadowSize > 0f)
{
shadow = MonoBehaviourSingleton <GlobalSettingsManager> .I.linkResources.CreateShadow(param.shadowSize, param.bodyRadius, bodyScale, true, _this, shader_type == SHADER_TYPE.LIGHTWEIGHT);
}
if (enemy != null)
{
if (param != null)
{
param.SetParam(enemy);
Object.DestroyImmediate(param);
}
if (enemy.controller != null)
{
enemy.controller.set_enabled(true);
}
enemy.willStock = will_stock;
enemy.OnLoadComplete();
if (enemy.packetReceiver != null)
{
enemy.packetReceiver.SetStopPacketUpdate(false);
}
}
callback?.Invoke(enemy);
if (lo_foundation != null)
{
foundation = lo_foundation.Realizes(_this, layer);
foundation.SetParent(_this.get_parent(), true);
}
isLoading = false;
}
protected override bool HandleCoopEvent(CoopPacket packet)
{
//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
//IL_0290: Unknown result type (might be due to invalid IL or missing references)
//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
//IL_037b: Unknown result type (might be due to invalid IL or missing references)
//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
//IL_04be: Unknown result type (might be due to invalid IL or missing references)
//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
//IL_04e9: Unknown result type (might be due to invalid IL or missing references)
//IL_0533: Unknown result type (might be due to invalid IL or missing references)
//IL_0564: Unknown result type (might be due to invalid IL or missing references)
//IL_0569: Unknown result type (might be due to invalid IL or missing references)
//IL_056e: Unknown result type (might be due to invalid IL or missing references)
//IL_0573: Unknown result type (might be due to invalid IL or missing references)
//IL_0585: Unknown result type (might be due to invalid IL or missing references)
//IL_066e: Unknown result type (might be due to invalid IL or missing references)
//IL_06b2: Unknown result type (might be due to invalid IL or missing references)
//IL_0835: Unknown result type (might be due to invalid IL or missing references)
//IL_085c: Unknown result type (might be due to invalid IL or missing references)
//IL_0894: Unknown result type (might be due to invalid IL or missing references)
//IL_08c1: Unknown result type (might be due to invalid IL or missing references)
//IL_0931: Unknown result type (might be due to invalid IL or missing references)
//IL_0965: Unknown result type (might be due to invalid IL or missing references)
//IL_099d: Unknown result type (might be due to invalid IL or missing references)
//IL_09c3: Unknown result type (might be due to invalid IL or missing references)
//IL_09fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0a31: Unknown result type (might be due to invalid IL or missing references)
//IL_0a38: Unknown result type (might be due to invalid IL or missing references)
//IL_0a79: Unknown result type (might be due to invalid IL or missing references)
//IL_0a93: Unknown result type (might be due to invalid IL or missing references)
//IL_0a9a: Unknown result type (might be due to invalid IL or missing references)
//IL_0dd0: Unknown result type (might be due to invalid IL or missing references)
//IL_0e22: Unknown result type (might be due to invalid IL or missing references)
//IL_0e58: Unknown result type (might be due to invalid IL or missing references)
//IL_0ea9: Unknown result type (might be due to invalid IL or missing references)
//IL_0ef4: Unknown result type (might be due to invalid IL or missing references)
//IL_0f1a: Unknown result type (might be due to invalid IL or missing references)
//IL_0f56: Unknown result type (might be due to invalid IL or missing references)
//IL_102c: Unknown result type (might be due to invalid IL or missing references)
//IL_105d: Unknown result type (might be due to invalid IL or missing references)
//IL_1062: Unknown result type (might be due to invalid IL or missing references)
//IL_1067: Unknown result type (might be due to invalid IL or missing references)
//IL_106c: Unknown result type (might be due to invalid IL or missing references)
//IL_107e: Unknown result type (might be due to invalid IL or missing references)
//IL_10b6: Unknown result type (might be due to invalid IL or missing references)
//IL_10ee: Unknown result type (might be due to invalid IL or missing references)
//IL_117d: Unknown result type (might be due to invalid IL or missing references)
//IL_11cd: Unknown result type (might be due to invalid IL or missing references)
//IL_11fe: Unknown result type (might be due to invalid IL or missing references)
//IL_122f: Unknown result type (might be due to invalid IL or missing references)
//IL_1248: Unknown result type (might be due to invalid IL or missing references)
switch (packet.packetType)
{
case PACKET_TYPE.PLAYER_LOAD_COMPLETE:
if (!player.isSetAppearPos)
{
return(false);
}
if (player.playerSender != null)
{
player.playerSender.OnRecvLoadComplete(packet.fromClientId);
}
break;
case PACKET_TYPE.PLAYER_INITIALIZE:
{
if (player.isLoading)
{
return(false);
}
Coop_Model_PlayerInitialize model32 = packet.GetModel <Coop_Model_PlayerInitialize>();
player.ApplySyncPosition(model32.pos, model32.dir, true);
player.hp = model32.hp;
player.healHp = model32.healHp;
player.StopCounter(model32.stopcounter);
StageObject target = null;
if (model32.target_id >= 0)
{
target = MonoBehaviourSingleton <StageObjectManager> .I.FindCharacter(model32.target_id);
}
player.SetActionTarget(target, true);
player.buffParam.SetSyncParam(model32.buff_sync_param, true);
if (MonoBehaviourSingleton <InGameRecorder> .IsValid())
{
MonoBehaviourSingleton <InGameRecorder> .I.ApplySyncOwnerData(model32.id);
}
MonoBehaviourSingleton <StageObjectManager> .I.RemoveCacheObject(player);
player.get_gameObject().SetActive(true);
SetFilterMode(FILTER_MODE.NONE);
player.isCoopInitialized = true;
player.SetAppearPos(player._position);
bool flag = false;
if (player.weaponData == null != (model32.weapon_item == null))
{
flag = true;
}
else if (player.weaponData != null && player.weaponData.eId != model32.weapon_item.eId)
{
flag = true;
}
else if (player.weaponIndex != model32.weapon_index)
{
flag = true;
}
CoopClient coopClient = MonoBehaviourSingleton <CoopManager> .I.coopRoom.clients.FindByClientId(packet.fromClientId);
if (coopClient != null && !coopClient.IsBattleStart())
{
player.WaitBattleStart();
player.get_gameObject().SetActive(false);
MonoBehaviourSingleton <StageObjectManager> .I.AddCacheObject(player);
}
else if (flag)
{
player.LoadWeapon(model32.weapon_item, model32.weapon_index, delegate
{
player.ActBattleStart(true);
});
}
else
{
player.SetNowWeapon(model32.weapon_item, model32.weapon_index);
player.InitParameter();
if (player.hp <= 0)
{
player.ActBattleStart(true);
if (!player.isDead)
{
player.ActDeadLoop(false, 0f, 0f);
}
}
else if (model32.act_battle_start)
{
player.ActBattleStart(false);
}
else
{
player.ActBattleStart(true);
player.ActIdle(false, -1f);
}
}
player.SetSyncUsingCannon(model32.cannonId);
break;
}
case PACKET_TYPE.PLAYER_ATTACK_COMBO:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerAttackCombo model15 = packet.GetModel <Coop_Model_PlayerAttackCombo>();
base.owner._position = model15.pos;
base.owner._rotation = Quaternion.AngleAxis(model15.dir, Vector3.get_up());
player.ActAttack(model15.attack_id, true, false);
player.SetActionPosition(model15.act_pos, model15.act_pos_f);
break;
}
case PACKET_TYPE.PLAYER_CHARGE_RELEASE:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerChargeRelease model36 = packet.GetModel <Coop_Model_PlayerChargeRelease>();
player.ApplySyncExRush(model36.isExRushCharge);
player.ApplySyncPosition(model36.pos, model36.dir, false);
player.SetChargeRelease(model36.charge_rate);
player.SetLerpRotation(Quaternion.AngleAxis(model36.lerp_dir, Vector3.get_up()) * Vector3.get_forward());
player.SetActionPosition(model36.act_pos, model36.act_pos_f);
break;
}
case PACKET_TYPE.PLAYER_RESTRAINT:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerRestraint model33 = packet.GetModel <Coop_Model_PlayerRestraint>();
RestraintInfo restraintInfo = new RestraintInfo();
restraintInfo.enable = true;
restraintInfo.duration = model33.duration;
restraintInfo.damageInterval = model33.damageInterval;
restraintInfo.damageRate = model33.damageRate;
restraintInfo.reduceTimeByFlick = model33.reduceTimeByFlick;
restraintInfo.effectName = model33.effectName;
restraintInfo.isStopMotion = model33.isStopMotion;
player.ActRestraint(restraintInfo);
break;
}
case PACKET_TYPE.PLAYER_RESTRAINT_END:
if (base.character.isDead)
{
return(true);
}
player.ActRestraintEnd();
break;
case PACKET_TYPE.PLAYER_AVOID:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerAvoid model38 = packet.GetModel <Coop_Model_PlayerAvoid>();
player.ApplySyncPosition(model38.pos, model38.dir, false);
player.ActAvoid();
break;
}
case PACKET_TYPE.PLAYER_WARP:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerWarp model19 = packet.GetModel <Coop_Model_PlayerWarp>();
player.ApplySyncPosition(model19.pos, model19.dir, false);
player.ActWarp();
break;
}
case PACKET_TYPE.PLAYER_BLOW_CLEAR:
if (base.character.isDead)
{
return(true);
}
player.InputBlowClear();
break;
case PACKET_TYPE.PLAYER_STUNNED_END:
if (base.character.isDead)
{
return(true);
}
player.SetStunnedEnd();
break;
case PACKET_TYPE.PLAYER_DEAD_COUNT:
{
Coop_Model_PlayerDeadCount model3 = packet.GetModel <Coop_Model_PlayerDeadCount>();
player.DeadCount(model3.remaind_time, model3.stop);
break;
}
case PACKET_TYPE.PLAYER_DEAD_STANDUP:
{
Coop_Model_PlayerDeadStandup model47 = packet.GetModel <Coop_Model_PlayerDeadStandup>();
player.ActDeadStandup(model47.standupHp, model47.cType);
break;
}
case PACKET_TYPE.PLAYER_STOP_COUNTER:
{
Coop_Model_PlayerStopCounter model46 = packet.GetModel <Coop_Model_PlayerStopCounter>();
player.StopCounter(model46.stop);
break;
}
case PACKET_TYPE.PLAYER_GATHER:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerGather model13 = packet.GetModel <Coop_Model_PlayerGather>();
GatherPointObject gatherPointObject = null;
if (MonoBehaviourSingleton <InGameProgress> .IsValid() && MonoBehaviourSingleton <InGameProgress> .I.gatherPointList != null)
{
int i = 0;
for (int count = MonoBehaviourSingleton <InGameProgress> .I.gatherPointList.Count; i < count; i++)
{
if (model13.point_id == (int)MonoBehaviourSingleton <InGameProgress> .I.gatherPointList[i].pointData.pointID)
{
gatherPointObject = MonoBehaviourSingleton <InGameProgress> .I.gatherPointList[i];
break;
}
}
}
if (gatherPointObject != null)
{
player.ApplySyncPosition(model13.pos, model13.dir, false);
player.ActGather(gatherPointObject);
player.SetActionPosition(model13.act_pos, model13.act_pos_f);
}
break;
}
case PACKET_TYPE.PLAYER_SKILL_ACTION:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerSkillAction model8 = packet.GetModel <Coop_Model_PlayerSkillAction>();
player.ApplySyncPosition(model8.pos, model8.dir, false);
player.ActSkillAction(model8.skill_index);
player.SetActionPosition(model8.act_pos, model8.act_pos_f);
break;
}
case PACKET_TYPE.PLAYER_GET_HEAL:
{
Coop_Model_PlayerGetHeal model7 = packet.GetModel <Coop_Model_PlayerGetHeal>();
player.OnGetHeal(model7.heal_hp, (HEAL_TYPE)model7.heal_type, !model7.receive, (HEAL_EFFECT_TYPE)model7.effect_type, true);
break;
}
case PACKET_TYPE.PLAYER_SPECIAL_ACTION:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerSpecialAction model2 = packet.GetModel <Coop_Model_PlayerSpecialAction>();
player.ApplySyncPosition(model2.pos, model2.dir, false);
player.ActSpecialAction(model2.start_effect, model2.isSuccess);
player.SetActionPosition(model2.act_pos, model2.act_pos_f);
break;
}
case PACKET_TYPE.PLAYER_SPECIAL_ACTION_CONTINUE:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerSpecialActionContinue model39 = packet.GetModel <Coop_Model_PlayerSpecialActionContinue>();
player.ApplySyncPosition(model39.pos, model39.dir, false);
player.ActSpAttackContinue();
player.SetActionPosition(model39.act_pos, model39.act_pos_f);
break;
}
case PACKET_TYPE.PLAYER_SHOT_ARROW:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerShotArrow model35 = packet.GetModel <Coop_Model_PlayerShotArrow>();
player.ApplySyncPosition(model35.pos, model35.dir, false);
AttackInfo attack_info = player.FindAttackInfoExternal(model35.attack_name, true, model35.attack_rate);
player.ShotArrow(model35.shot_pos, model35.shot_rot, attack_info, model35.is_sit_shot, model35.is_aim_end);
break;
}
case PACKET_TYPE.PLAYER_SHOT_SOUL_ARROW:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerShotSoulArrow model26 = packet.GetModel <Coop_Model_PlayerShotSoulArrow>();
player.ApplySyncPosition(model26.pos, model26.dir, false);
player.ShotSoulArrowPuppet(model26.shotPos, model26.bowRot, model26.targetPosList);
break;
}
case PACKET_TYPE.PLAYER_UPDATE_SKILL_INFO:
{
Coop_Model_PlayerUpdateSkillInfo model25 = packet.GetModel <Coop_Model_PlayerUpdateSkillInfo>();
player.skillInfo.SetSettingsInfo(model25.settings_info, player.equipWeaponList);
break;
}
case PACKET_TYPE.PLAYER_PRAYER_START:
{
Coop_Model_PlayerPrayerStart model23 = packet.GetModel <Coop_Model_PlayerPrayerStart>();
player.OnPrayerStart(model23.sid);
break;
}
case PACKET_TYPE.PLAYER_PRAYER_END:
{
Coop_Model_PlayerPrayerEnd model22 = packet.GetModel <Coop_Model_PlayerPrayerEnd>();
player.OnPrayerEnd(model22.sid);
break;
}
case PACKET_TYPE.PLAYER_PRAYER_BOOST:
{
Coop_Model_PlayerPrayerBoost model20 = packet.GetModel <Coop_Model_PlayerPrayerBoost>();
player.OnPrayerBoost(model20.sid, model20.isBoost);
break;
}
case PACKET_TYPE.PLAYER_CHANGE_WEAPON:
if (base.character.isDead)
{
return(true);
}
player.ActChangeWeapon(null, -1);
break;
case PACKET_TYPE.PLAYER_APPLY_CHANGE_WEAPON:
{
Coop_Model_PlayerApplyChangeWeapon model12 = packet.GetModel <Coop_Model_PlayerApplyChangeWeapon>();
if (player.weaponData.eId == (uint)model12.item.eId && player.weaponIndex == model12.index)
{
return(true);
}
player.ApplyChangeWeapon(model12.item, model12.index);
break;
}
case PACKET_TYPE.PLAYER_SETSTATUS:
{
Coop_Model_PlayerSetStatus model10 = packet.GetModel <Coop_Model_PlayerSetStatus>();
player.OnSetPlayerStatus(model10.level, model10.atk, model10.def, model10.hp, true, null);
if (MonoBehaviourSingleton <UIPlayerAnnounce> .IsValid())
{
MonoBehaviourSingleton <UIPlayerAnnounce> .I.Announce(UIPlayerAnnounce.ANNOUNCE_TYPE.LEVEL_UP, player);
}
break;
}
case PACKET_TYPE.PLAYER_GET_RAREDROP:
if (MonoBehaviourSingleton <UIInGameMessageBar> .IsValid())
{
Coop_Model_PlayerGetRareDrop model5 = packet.GetModel <Coop_Model_PlayerGetRareDrop>();
string text = null;
switch (model5.type)
{
case 5:
{
SkillItemTable.SkillItemData skillItemData = Singleton <SkillItemTable> .I.GetSkillItemData((uint)model5.item_id);
if (skillItemData != null)
{
text = skillItemData.name;
}
break;
}
case 4:
{
EquipItemTable.EquipItemData equipItemData = Singleton <EquipItemTable> .I.GetEquipItemData((uint)model5.item_id);
if (equipItemData != null)
{
text = equipItemData.name;
}
break;
}
default:
{
ItemTable.ItemData itemData = Singleton <ItemTable> .I.GetItemData((uint)model5.item_id);
if (itemData != null)
{
text = itemData.name;
}
break;
}
}
if (text != null)
{
MonoBehaviourSingleton <UIInGameMessageBar> .I.Announce(player.charaName, StringTable.Format(STRING_CATEGORY.IN_GAME, 4000u, text));
}
}
break;
case PACKET_TYPE.PLAYER_GRABBED:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerGrabbed model48 = packet.GetModel <Coop_Model_PlayerGrabbed>();
GrabInfo grabInfo = new GrabInfo();
grabInfo.parentNode = model48.nodeName;
grabInfo.duration = model48.duration;
grabInfo.drainAttackId = model48.drainAtkId;
player.ActGrabbedStart(model48.enemyId, grabInfo);
break;
}
case PACKET_TYPE.PLAYER_GRABBED_END:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerGrabbedEnd model45 = packet.GetModel <Coop_Model_PlayerGrabbedEnd>();
player.ActGrabbedEnd(model45.angle, model45.power);
break;
}
case PACKET_TYPE.PLAYER_SET_PRESENT_BULLET:
{
Coop_Model_PlayerSetPresentBullet model44 = packet.GetModel <Coop_Model_PlayerSetPresentBullet>();
player.SetPresentBullet(model44.presentBulletId, (BulletData.BulletPresent.TYPE)model44.type, model44.position, model44.bulletName);
break;
}
case PACKET_TYPE.PLAYER_PICK_PRESENT_BULLET:
{
Coop_Model_PlayerPickPresentBullet model43 = packet.GetModel <Coop_Model_PlayerPickPresentBullet>();
player.DestroyPresentBulletObject(model43.presentBulletId);
break;
}
case PACKET_TYPE.PLAYER_SHOT_ZONE_BULLET:
{
Coop_Model_PlayerShotZoneBullet model42 = packet.GetModel <Coop_Model_PlayerShotZoneBullet>();
player.ShotZoneBullet(player, model42.bulletName, model42.position, false, false);
break;
}
case PACKET_TYPE.PLAYER_SHOT_DECOY_BULLET:
{
Coop_Model_PlayerShotDecoyBullet model41 = packet.GetModel <Coop_Model_PlayerShotDecoyBullet>();
player.ShotDecoyBullet(model41.id, model41.decoyId, model41.bulletName, model41.position, false);
break;
}
case PACKET_TYPE.PLAYER_EXPLODE_DECOY_BULLET:
{
Coop_Model_PlayerExplodeDecoyBullet model40 = packet.GetModel <Coop_Model_PlayerExplodeDecoyBullet>();
player.ExplodeDecoyBullet(model40.decoyId);
break;
}
case PACKET_TYPE.PLAYER_CANNON_STANDBY:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerCannonStandby model37 = packet.GetModel <Coop_Model_PlayerCannonStandby>();
player.ApplySyncPosition(model37.pos, model37.dir, false);
player.ActCannonStandby(model37.cannonId);
break;
}
case PACKET_TYPE.PLAYER_CANNON_SHOT:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerCannonShot model34 = packet.GetModel <Coop_Model_PlayerCannonShot>();
player.ApplySyncPosition(model34.pos, model34.dir, false);
player.SetCannonState(Player.CANNON_STATE.READY);
player.ApplyCannonVector(model34.cannonVec);
player.ActCannonShot();
break;
}
case PACKET_TYPE.PLAYER_CANNON_ROTATE:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerCannonRotate model31 = packet.GetModel <Coop_Model_PlayerCannonRotate>();
player.SetSyncCannonRotation(model31.cannonVec);
break;
}
case PACKET_TYPE.PLAYER_GET_CHARGE_SKILLGAUGE:
{
Coop_Model_PlayerGetChargeSkillGauge model30 = packet.GetModel <Coop_Model_PlayerGetChargeSkillGauge>();
player.OnGetChargeSkillGauge((BuffParam.BUFFTYPE)model30.buffType, model30.buffValue, model30.useSkillIndex, !model30.receive);
break;
}
case PACKET_TYPE.PLAYER_RESURRECT:
{
Coop_Model_PlayerResurrect model29 = packet.GetModel <Coop_Model_PlayerResurrect>();
player.OnResurrection(true);
break;
}
case PACKET_TYPE.PLAYER_GET_RESURRECT:
{
Coop_Model_PlayerGetResurrect model28 = packet.GetModel <Coop_Model_PlayerGetResurrect>();
player.OnGetResurrection();
break;
}
case PACKET_TYPE.PLAYER_SPECIAL_ACTION_GAUGE_SYNC:
{
Coop_Model_PlayerSpecialActionGaugeSync model27 = packet.GetModel <Coop_Model_PlayerSpecialActionGaugeSync>();
player.OnSyncSpecialActionGauge(model27.weaponIndex, model27.currentSpActionGauge);
player.pairSwordsCtrl.SetComboLv(model27.comboLv);
break;
}
case PACKET_TYPE.PLAYER_CHARGE_EXPAND_RELEASE:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerChargeExpandRelease model24 = packet.GetModel <Coop_Model_PlayerChargeExpandRelease>();
player.ApplySyncPosition(model24.pos, model24.dir, false);
player.SetChargeExpandRelease(model24.charge_rate);
player.SetLerpRotation(Quaternion.AngleAxis(model24.lerp_dir, Vector3.get_up()) * Vector3.get_forward());
player.SetActionPosition(model24.act_pos, model24.act_pos_f);
break;
}
case PACKET_TYPE.PLAYER_JUMP_RIZE:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerJumpRize model21 = packet.GetModel <Coop_Model_PlayerJumpRize>();
player.OnJumpRize(model21.dir, model21.level);
break;
}
case PACKET_TYPE.PLAYER_JUMP_END:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerJumpEnd model18 = packet.GetModel <Coop_Model_PlayerJumpEnd>();
player.OnJumpEnd(model18.pos, model18.isSuccess, model18.y);
break;
}
case PACKET_TYPE.PLAYER_SOUL_BOOST:
{
Coop_Model_PlayerSoulBoost model17 = packet.GetModel <Coop_Model_PlayerSoulBoost>();
player.OnSoulBoost(model17.isBoost);
break;
}
case PACKET_TYPE.PLAYER_EVOLVE_ACTION_SYNC:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerEvolveActionSync model16 = packet.GetModel <Coop_Model_PlayerEvolveActionSync>();
player.OnSyncEvolveAction(model16.isAction);
break;
}
case PACKET_TYPE.PLAYER_EVOLVE_SPECIAL_ACTION:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerEvolveSpecialAction model14 = packet.GetModel <Coop_Model_PlayerEvolveSpecialAction>();
player.ApplySyncPosition(model14.pos, model14.dir, false);
player.ActEvolveSpecialAction();
break;
}
case PACKET_TYPE.PLAYER_SNATCH_POS:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerSnatchPos model11 = packet.GetModel <Coop_Model_PlayerSnatchPos>();
player.snatchCtrl.OnHit(model11.enemyId, model11.hitPoint);
break;
}
case PACKET_TYPE.PLAYER_SNATCH_MOVE_START:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerSnatchMoveStart model9 = packet.GetModel <Coop_Model_PlayerSnatchMoveStart>();
player.OnSnatchMoveStart(model9.snatchPos);
break;
}
case PACKET_TYPE.PLAYER_SNATCH_MOVE_END:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerSnatchMoveEnd model6 = packet.GetModel <Coop_Model_PlayerSnatchMoveEnd>();
player.SetActionPosition(model6.act_pos, model6.act_pos_f);
player.ApplySyncPosition(model6.pos, model6.dir, false);
player.OnSnatchMoveEnd(model6.triggerIndex);
break;
}
case PACKET_TYPE.PLAYER_PAIR_SWORDS_LASER_END:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerPairSwordsLaserEnd model4 = packet.GetModel <Coop_Model_PlayerPairSwordsLaserEnd>();
player.OnSyncSpecialActionGauge(model4.weaponIndex, model4.currentSpActionGauge);
player.pairSwordsCtrl.OnLaserEnd(true);
break;
}
case PACKET_TYPE.PLAYER_SHOT_HEALING_HOMING:
{
if (base.character.isDead)
{
return(true);
}
Coop_Model_PlayerShotHealingHoming model = packet.GetModel <Coop_Model_PlayerShotHealingHoming>();
player.OnShotHealingHoming(model);
break;
}
default:
return(base.HandleCoopEvent(packet));
}
if (QuestManager.IsValidInGameExplore())
{
CoopClient coopClient2 = MonoBehaviourSingleton <CoopManager> .I.coopRoom.clients.FindByClientId(packet.fromClientId);
if (coopClient2 != null)
{
MonoBehaviourSingleton <QuestManager> .I.UpdateExplorePlayerStatus(coopClient2);
}
}
return(true);
}
void LetGoOfBody()
{
fixedJoint.connectedBody = null;
currentDrag = new GrabInfo();
}
private void ImageGrabbed(GrabInfo grabInfo)
{
_grabInfos.Add(grabInfo);
}
void FixedUpdate()
{
handVelocity = GetMaxFingerVelocity();
//if( handVelocity > colliderEnableVelocity )
//{
// if( currentState == State.Idle )
// {
// EnableColliders(true);
// }
//}
//else
//{
// EnableColliders(false);
//}
//if( currentState == State.Idle )
{
if (handVelocity < colliderEnableVelocity)
{
EnableColliders(false);
if (leftIndex.BendAngle > leftMiddle.BendAngle + indexPokingDeltaAngle)
{
leftIndex.pushCollider.enabled = true;
}
if (rightIndex.BendAngle > rightMiddle.BendAngle + indexPokingDeltaAngle)
{
rightIndex.pushCollider.enabled = true;
}
}
else
{
EnableColliders(true);
}
}
switch (currentState)
{
case State.Idle:
{
currentSelect = GetGrabInfoByDetector();
// currentSelect = GetGrabInfoByRaycast();
if (currentSelect != null && currentSelect.obj != null)
{
//GrabInfo detectorInfo = GetGrabInfoByDetector();
//if (detectorInfo == null || detectorInfo.obj == null || detectorInfo.obj != currentSelect.obj)
//{
// return;
//}
Transform midTransform = GetMiddleTransform(currentSelect);
currentState = State.Selected;
currentAngle = GetAngle(currentSelect.left.fingerTipBone, currentSelect.right.fingerTipBone, midTransform);
currentSelect.selectAngle = currentAngle;
// EnableColliders(touchedWith > 0);
GrabReleaseDelegate callback = OnSelect;
if (callback != null)
{
callback(currentSelect);
}
}
}
return;
case State.Selected:
{
Vector3 vleft = currentSelect.left.fingerRayAnchor.position;
Vector3 vRight = currentSelect.right.fingerRayAnchor.position;
Transform midTransform = GetMiddleTransform(currentSelect);
float angle = GetAngle(currentSelect.left.fingerTipBone, currentSelect.right.fingerTipBone, midTransform);
currentAngle = angle;
//if( !currentSelect.IsMidPointInsideCollider() )
{
GrabInfo info = GetGrabInfoByDetector();
if (info == null || currentSelect != null && currentSelect.obj != info.obj)
{
GrabReleaseDelegate callback = OnDeselect;
if (callback != null)
{
callback(currentSelect);
}
currentState = State.Idle;
// currentSelect.selectAngle = angle;
currentSelect = null;
return;
}
}
//if ( angle > currentAngle )
//{
// currentAngle = angle;
//}
if (currentSelect.selectAngle - angle > grabAngle)
{
currentState = State.Grabbed;
currentSelect.grabAngle = angle;
currentSelect.left.pushCollider.enabled = false;
currentSelect.right.pushCollider.enabled = false;
GrabReleaseDelegate callback = OnGrab;
if (callback != null)
{
callback(currentSelect);
}
}
Debug.DrawLine(vleft, midTransform.position, Color.red);
Debug.DrawLine(vRight, midTransform.position, Color.red);
}
return;
case State.Grabbed:
{
Vector3 vleft = currentSelect.left.fingerRayAnchor.position;
Vector3 vRight = currentSelect.right.fingerRayAnchor.position;
Transform midTransform = GetMiddleTransform(currentSelect);
float angle = GetAngle(currentSelect.left.fingerRayAnchor, currentSelect.right.fingerRayAnchor, midTransform);
currentAngle = angle;
//if ( angle < currentAngle )
//{
// currentAngle = angle;
//}
if (angle - currentSelect.grabAngle > releaseAngle)
{
GrabReleaseDelegate callback = OnRelease;
if (callback != null)
{
callback(currentSelect);
}
currentState = State.Idle;
// currentSelect.selectAngle = currentAngle;
currentSelect = null;
}
else if (angle < currentSelect.grabAngle)
{
currentSelect.grabAngle = angle;
}
Debug.DrawLine(vleft, midTransform.position, Color.red);
Debug.DrawLine(vRight, midTransform.position, Color.red);
}
return;
}
}
private void ImageGrabbed(GrabInfo grabInfo)
{
_pipeLine.Enqueue(grabInfo);
}
