public static FieldDropObject CreateTreasureBox(Coop_Model_EnemyDefeat model, List <InGameManager.DropDeliveryInfo> deliveryList, List <InGameManager.DropItemInfo> itemList, UIDropAnnounce.COLOR color)
    {
        //IL_004a: Unknown result type (might be due to invalid IL or missing references)
        //IL_004f: Unknown result type (might be due to invalid IL or missing references)
        //IL_0138: Unknown result type (might be due to invalid IL or missing references)
        //IL_013a: Unknown result type (might be due to invalid IL or missing references)
        //IL_013b: Unknown result type (might be due to invalid IL or missing references)
        //IL_0140: Unknown result type (might be due to invalid IL or missing references)
        //IL_014b: Unknown result type (might be due to invalid IL or missing references)
        //IL_0151: Unknown result type (might be due to invalid IL or missing references)
        //IL_0153: Unknown result type (might be due to invalid IL or missing references)
        //IL_016b: Unknown result type (might be due to invalid IL or missing references)
        //IL_0170: Unknown result type (might be due to invalid IL or missing references)
        //IL_0182: Unknown result type (might be due to invalid IL or missing references)
        //IL_0187: Unknown result type (might be due to invalid IL or missing references)
        //IL_0196: Unknown result type (might be due to invalid IL or missing references)
        //IL_0198: Unknown result type (might be due to invalid IL or missing references)
        GameObject val = MonoBehaviourSingleton <InGameManager> .I.CreateTreasureBox(color);

        FieldDropObject fieldDropObject = val.GetComponent <FieldDropObject>();

        if (fieldDropObject == null)
        {
            fieldDropObject = val.AddComponent <FieldDropObject>();
        }
        fieldDropObject.itemInfo     = itemList;
        fieldDropObject.deliveryInfo = deliveryList;
        fieldDropObject.rewardId     = model.rewardId;
        fieldDropObject.isRare       = (color == UIDropAnnounce.COLOR.RARE);
        Vector3 zero = Vector3.get_zero();

        if (MonoBehaviourSingleton <InGameSettingsManager> .IsValid())
        {
            InGameSettingsManager.FieldDropItem fieldDrop = MonoBehaviourSingleton <InGameSettingsManager> .I.fieldDrop;
            float value  = Random.get_value();
            float value2 = Random.get_value();
            float value3 = Random.get_value();
            float num    = (!(Random.get_value() > 0.5f)) ? 1f : (-1f);
            float num2   = (!(Random.get_value() > 0.5f)) ? 1f : (-1f);
            zero._002Ector(Mathf.Lerp(fieldDrop.offsetMin.x, fieldDrop.offsetMax.x, value) * num, Mathf.Lerp(fieldDrop.offsetMin.y, fieldDrop.offsetMax.y, value2), Mathf.Lerp(fieldDrop.offsetMin.z, fieldDrop.offsetMax.z, value3) * num2);
        }
        Vector3 val2 = default(Vector3);

        val2._002Ector((float)model.x, 0f, (float)model.z);
        Vector3    target       = val2 + zero;
        int        obstacleMask = AIUtility.GetObstacleMask();
        RaycastHit hit          = default(RaycastHit);

        if (AIUtility.RaycastForTargetPos(val2, target, obstacleMask, out hit))
        {
            Vector3 point  = hit.get_point();
            float   x      = point.x;
            float   y      = target.y;
            Vector3 point2 = hit.get_point();
            target._002Ector(x, y, point2.z);
        }
        fieldDropObject.Drop(val2, target);
        return(fieldDropObject);
    }
Esempio n. 2
0
    public void DeleteDropObject(int reward_id, bool is_get)
    {
        FieldDropObject fieldDropObject = dropList.Find((FieldDropObject o) => o.rewardId == reward_id);

        if (fieldDropObject != null)
        {
            fieldDropObject.Delete(is_get);
        }
        dropList.Remove(fieldDropObject);
    }
Esempio n. 3
0
    public void CreateDropObject(Coop_Model_EnemyDefeat model, List <DropDeliveryInfo> deliveryList, List <DropItemInfo> itemList)
    {
        FieldDropObject fieldDropObject = FieldDropObject.Create(model, deliveryList, itemList);

        if (fieldDropObject != null)
        {
            dropList.Add(fieldDropObject);
            if (MonoBehaviourSingleton <InGameProgress> .IsValid() && MonoBehaviourSingleton <InGameProgress> .I.isHappenQuestDirection)
            {
                OpenAllDropObject();
            }
        }
    }
    private void FuncBasisMode()
    {
        //IL_0096: Unknown result type (might be due to invalid IL or missing references)
        //IL_009b: Unknown result type (might be due to invalid IL or missing references)
        //IL_00c9: Unknown result type (might be due to invalid IL or missing references)
        //IL_00cb: Unknown result type (might be due to invalid IL or missing references)
        //IL_00d0: Unknown result type (might be due to invalid IL or missing references)
        //IL_00d5: Unknown result type (might be due to invalid IL or missing references)
        //IL_0245: Unknown result type (might be due to invalid IL or missing references)
        //IL_0366: Unknown result type (might be due to invalid IL or missing references)
        //IL_0367: Unknown result type (might be due to invalid IL or missing references)
        //IL_036c: Unknown result type (might be due to invalid IL or missing references)
        //IL_036f: Unknown result type (might be due to invalid IL or missing references)
        //IL_0374: Unknown result type (might be due to invalid IL or missing references)
        //IL_038b: Unknown result type (might be due to invalid IL or missing references)
        //IL_0390: Unknown result type (might be due to invalid IL or missing references)
        //IL_0394: Unknown result type (might be due to invalid IL or missing references)
        //IL_0399: Unknown result type (might be due to invalid IL or missing references)
        //IL_039b: Unknown result type (might be due to invalid IL or missing references)
        //IL_039d: Unknown result type (might be due to invalid IL or missing references)
        //IL_03a2: Unknown result type (might be due to invalid IL or missing references)
        //IL_03a6: Unknown result type (might be due to invalid IL or missing references)
        //IL_03ab: Unknown result type (might be due to invalid IL or missing references)
        //IL_03b0: Unknown result type (might be due to invalid IL or missing references)
        //IL_03b5: Unknown result type (might be due to invalid IL or missing references)
        //IL_042d: Unknown result type (might be due to invalid IL or missing references)
        //IL_057c: Unknown result type (might be due to invalid IL or missing references)
        //IL_0581: Unknown result type (might be due to invalid IL or missing references)
        //IL_0583: 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_058a: Unknown result type (might be due to invalid IL or missing references)
        //IL_058c: Unknown result type (might be due to invalid IL or missing references)
        //IL_058e: Unknown result type (might be due to invalid IL or missing references)
        //IL_0590: Unknown result type (might be due to invalid IL or missing references)
        //IL_0595: Unknown result type (might be due to invalid IL or missing references)
        //IL_0599: Unknown result type (might be due to invalid IL or missing references)
        //IL_059b: Unknown result type (might be due to invalid IL or missing references)
        //IL_059d: Unknown result type (might be due to invalid IL or missing references)
        //IL_05a2: Unknown result type (might be due to invalid IL or missing references)
        //IL_05a6: Unknown result type (might be due to invalid IL or missing references)
        //IL_05b2: Unknown result type (might be due to invalid IL or missing references)
        //IL_05b7: Unknown result type (might be due to invalid IL or missing references)
        //IL_05b9: Unknown result type (might be due to invalid IL or missing references)
        //IL_05be: Unknown result type (might be due to invalid IL or missing references)
        //IL_05c5: Unknown result type (might be due to invalid IL or missing references)
        //IL_05c7: Unknown result type (might be due to invalid IL or missing references)
        //IL_05ce: Unknown result type (might be due to invalid IL or missing references)
        //IL_05d0: Unknown result type (might be due to invalid IL or missing references)
        //IL_06c9: Unknown result type (might be due to invalid IL or missing references)
        //IL_06cb: Unknown result type (might be due to invalid IL or missing references)
        //IL_06cd: Unknown result type (might be due to invalid IL or missing references)
        //IL_06d2: Unknown result type (might be due to invalid IL or missing references)
        //IL_06d4: Unknown result type (might be due to invalid IL or missing references)
        //IL_06d6: Unknown result type (might be due to invalid IL or missing references)
        //IL_06dd: Unknown result type (might be due to invalid IL or missing references)
        //IL_0727: Unknown result type (might be due to invalid IL or missing references)
        //IL_0729: Unknown result type (might be due to invalid IL or missing references)
        //IL_072e: Unknown result type (might be due to invalid IL or missing references)
        //IL_0804: Unknown result type (might be due to invalid IL or missing references)
        //IL_0805: Unknown result type (might be due to invalid IL or missing references)
        //IL_0807: Unknown result type (might be due to invalid IL or missing references)
        //IL_080c: Unknown result type (might be due to invalid IL or missing references)
        //IL_0ab1: Unknown result type (might be due to invalid IL or missing references)
        Self self = MonoBehaviourSingleton <StageObjectManager> .I.self;

        if (MonoBehaviourSingleton <StageObjectManager> .I.boss != null)
        {
            parameter = MonoBehaviourSingleton <InGameSettingsManager> .I.targetMarker;
        }
        else
        {
            parameter = MonoBehaviourSingleton <InGameSettingsManager> .I.targetMarkerLesserEnemies;
        }
        if (changeLockFlag)
        {
            changeLockTime -= Time.get_deltaTime();
            if (changeLockTime <= 0f)
            {
                changeLockTime = 0f;
                changeLockFlag = false;
                isTargetLock   = !isTargetLock;
            }
        }
        bool    flag = false;
        Vector3 val  = self._position;

        if (self.isArrowAimLesserMode)
        {
            if (self.isArrowAimEnd)
            {
                flag = true;
            }
            else
            {
                parameter = MonoBehaviourSingleton <InGameSettingsManager> .I.targetMarkerArrowAimLesser;
                val      += self.arrowAimLesserCursorPos;
            }
        }
        float num  = parameter.targetDistance;
        float num2 = parameter.showTargetDistance;

        if (self.isLongAttackMode)
        {
            num  = parameter.targetDistanceArrow;
            num2 = parameter.showTargetDistanceArrow;
        }
        TargetPoint targetingPoint = self.targetingPoint;

        self.targetingPointList.Clear();
        self.targetPointWithSpWeakList.Clear();
        int i = 0;

        for (int count = MonoBehaviourSingleton <StageObjectManager> .I.enemyList.Count; i < count; i++)
        {
            Enemy enemy = MonoBehaviourSingleton <StageObjectManager> .I.EnemyList[i];
            if (enemy.HasValidTargetPoint())
            {
                for (int j = 0; j < enemy.targetPoints.Length; j++)
                {
                    RegisterTargetInfo(enemy.targetPoints[j], enemy);
                }
            }
            List <IBulletObservable> bulletObservableList = enemy.GetBulletObservableList();
            if (bulletObservableList != null)
            {
                for (int k = 0; k < bulletObservableList.Count; k++)
                {
                    AnimEventShot animEventShot = bulletObservableList[k] as AnimEventShot;
                    if (!(animEventShot == null) && !(animEventShot.targetPoint == null))
                    {
                        RegisterTargetInfo(animEventShot.targetPoint, null);
                    }
                }
            }
        }
        for (int l = 0; l < MonoBehaviourSingleton <InGameManager> .I.dropItemList.Count; l++)
        {
            FieldDropObject fieldDropObject = MonoBehaviourSingleton <InGameManager> .I.dropItemList[l];
            if (fieldDropObject.targetPoint != null && fieldDropObject.get_gameObject().get_activeInHierarchy())
            {
                RegisterTargetInfo(fieldDropObject.targetPoint, null);
            }
        }
        int count2 = MonoBehaviourSingleton <StageObjectManager> .I.playerList.Count;

        for (int m = 0; m < count2; m++)
        {
            Player player = MonoBehaviourSingleton <StageObjectManager> .I.playerList[m] as Player;
            if (!(player == null) && !player.isDead)
            {
                TargetPoint restraintTargetPoint = player.RestraintTargetPoint;
                if (restraintTargetPoint != null)
                {
                    RegisterTargetInfo(restraintTargetPoint, null);
                }
            }
        }
        if (numTargetInfo <= 0)
        {
            Clear();
            self.SetActionTarget(null, true);
        }
        else
        {
            float       num3         = parameter.showAngle * 0.0174532924f;
            float       num4         = num * num;
            float       num5         = num2 * num2;
            float       num6         = parameter.targetAngle * 0.0174532924f;
            TargetPoint targetPoint  = null;
            float       num7         = 3.40282347E+38f;
            TargetPoint targetPoint2 = null;
            float       num8         = 3.40282347E+38f;
            TargetPoint targetPoint3 = null;
            float       num9         = 3.40282347E+38f;
            Vector2     val2         = val.ToVector2XZ();
            Vector2     forwardXZ    = self.forwardXZ;
            forwardXZ.Normalize();
            Transform  cameraTransform = MonoBehaviourSingleton <InGameCameraManager> .I.cameraTransform;
            Quaternion rotation        = cameraTransform.get_rotation();
            Vector3    position        = cameraTransform.get_position();
            Vector2    val3            = position.ToVector2XZ();
            Vector3    val4            = Vector2.op_Implicit(cameraTransform.get_forward().ToVector2XZ());
            val4.Normalize();
            bool isAutoMode = self.isAutoMode;
            for (int n = 0; n < numTargetInfo; n++)
            {
                Enemy             enemy2       = targetInfoList[n].enemy;
                TargetPoint       targetPoint4 = targetInfoList[n].targetPoint;
                TargetPoint.Param param        = targetPoint4.param;
                param.isShowRange    = false;
                param.isTargetEnable = false;
                param.weakState      = Enemy.WEAK_STATE.NONE;
                param.weakSubParam   = -1;
                if (targetPoint4.get_enabled() && targetPoint4.get_gameObject().get_activeInHierarchy())
                {
                    if (self.isArrowAimBossMode)
                    {
                        if (!self.CheckAttackModeAndSpType(Player.ATTACK_MODE.ARROW, SP_ATTACK_TYPE.SOUL) && !targetPoint4.isAimEnable)
                        {
                            continue;
                        }
                    }
                    else if (!targetPoint4.isTargetEnable)
                    {
                        continue;
                    }
                    if (enemy2 != null && targetPoint4.regionID >= 0 && targetPoint4.regionID < enemy2.regionWorks.Length)
                    {
                        EnemyRegionWork enemyRegionWork = enemy2.regionWorks[targetPoint4.regionID];
                        if (!enemyRegionWork.enabled)
                        {
                            continue;
                        }
                        if (!self.isArrowAimBossMode || Enemy.IsWeakStateDisplaySign(enemyRegionWork.weakState))
                        {
                            param.weakState        = enemyRegionWork.weakState;
                            param.weakSubParam     = enemyRegionWork.weakSubParam;
                            param.validElementType = enemyRegionWork.validElementType;
                            if (Enemy.IsWeakStateCheckAlreadyHit(param.weakState) && enemyRegionWork.weakAttackIDs.Contains(self.id))
                            {
                                param.weakState = Enemy.WEAK_STATE.NONE;
                            }
                        }
                        param.aimMarkerScale = MonoBehaviourSingleton <InGameSettingsManager> .I.enemy.aimMarkerBaseRate * enemy2.enemyTableData.aimMarkerRate * targetPoint4.aimMarkerPointRate;
                    }
                    param.isTargetEnable = true;
                    Vector3           targetPoint5 = targetPoint4.GetTargetPoint();
                    Vector2           val5         = targetPoint5.ToVector2XZ();
                    Vector2           val6         = val5 - val2;
                    TargetPoint.Param param2       = param;
                    Vector3           val7         = position - targetPoint5;
                    param2.markerPos = val7.get_normalized() * targetPoint4.scaledMarkerZShift + targetPoint5;
                    param.markerRot  = rotation;
                    param.targetPos  = targetPoint5;
                    bool flag2 = false;
                    if (param.weakState != 0 && param.weakSubParam != 0)
                    {
                        flag2 = true;
                    }
                    float sqrMagnitude = val6.get_sqrMagnitude();
                    param.isShowRange     = (sqrMagnitude < num5 || flag2);
                    param.vecSqrMagnitude = sqrMagnitude;
                    if (!isTargetDisable)
                    {
                        if (isAutoMode && !(targetPoint4.owner is Player))
                        {
                            if (targetPoint3 == null)
                            {
                                targetPoint3 = targetPoint4;
                                num9         = sqrMagnitude;
                            }
                            else if (targetPoint4.owner == null)
                            {
                                if (targetPoint3.owner == null)
                                {
                                    if (sqrMagnitude < num9)
                                    {
                                        targetPoint3 = targetPoint4;
                                        num9         = sqrMagnitude;
                                    }
                                }
                                else
                                {
                                    targetPoint3 = targetPoint4;
                                    num9         = sqrMagnitude;
                                }
                            }
                            else if (sqrMagnitude < num9)
                            {
                                targetPoint3 = targetPoint4;
                                num9         = sqrMagnitude;
                            }
                        }
                        if (flag2 || !(sqrMagnitude > num4))
                        {
                            Vector2 val8  = val5 - val3;
                            float   num10 = Mathf.Acos(Vector2.Dot(Vector2.op_Implicit(val4), val8.get_normalized()));
                            if (!(num10 > num3))
                            {
                                bool flag3 = false;
                                if (parameter.enableCameraCulling && !flag)
                                {
                                    float   cameraCullingMargin = parameter.cameraCullingMargin;
                                    Vector3 val9 = MonoBehaviourSingleton <InGameCameraManager> .I.WorldToViewportPoint(targetPoint5);

                                    if (val9.x < 0f - cameraCullingMargin || val9.x > 1f + cameraCullingMargin || val9.y < 0f - cameraCullingMargin || val9.y > 1f + cameraCullingMargin || val9.z < 0f)
                                    {
                                        flag3 = true;
                                    }
                                }
                                if (!flag3)
                                {
                                    if (Enemy.IsWeakStateSpAttack(param.weakState) && param.weakSubParam == (int)self.attackMode)
                                    {
                                        self.targetPointWithSpWeakList.Add(targetPoint4);
                                    }
                                    if (Enemy.IsWeakStateDisplaySign(param.weakState))
                                    {
                                        float num11 = Mathf.Sqrt(sqrMagnitude) - parameter.weakMarginDistance;
                                        sqrMagnitude = num11 * num11;
                                        num10        = 0f;
                                    }
                                    Vector3 val10 = val - targetPoint5;
                                    sqrMagnitude  = val10.get_magnitude();
                                    sqrMagnitude += targetPoint4.weight;
                                    if (targetPoint5.y >= 0f && targetPoint5.y < self.GetIgnoreTargetHeight())
                                    {
                                        if (targetPoint2 == null || sqrMagnitude < num8)
                                        {
                                            targetPoint2 = targetPoint4;
                                            num8         = sqrMagnitude;
                                        }
                                        if (num10 <= num6 && (targetPoint == null || sqrMagnitude < num7))
                                        {
                                            targetPoint = targetPoint4;
                                            num7        = sqrMagnitude;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            if (targetPoint == null && targetPoint2 != null)
            {
                targetPoint = targetPoint2;
            }
            if (isAutoMode)
            {
                AutoSelfController autoSelfController = self.controller as AutoSelfController;
                autoSelfController.actionTargetPoint = targetPoint3;
            }
            if (self.isArrowAimBossMode)
            {
                self.targetAimAfeterPoint = targetPoint;
                MakeTargetPointListForArrowAimBossMode(self.targetingPointList);
            }
            else
            {
                TargetPoint targetPoint6 = DecideFinalTargetPoint(targetPoint, targetingPoint, self.attackMode);
                if (targetPoint6 != null)
                {
                    self.targetingPointList.Add(targetPoint6);
                    self.SetActionTarget(targetPoint6.owner, true);
                    if (isAutoMode)
                    {
                        AutoSelfController autoSelfController2 = self.controller as AutoSelfController;
                        if (targetPoint6 != null)
                        {
                            if (targetPoint6.owner == null)
                            {
                                autoSelfController2.actionTargetPoint = targetPoint6;
                            }
                            else if (targetPoint3.owner == null)
                            {
                                targetPoint6 = (autoSelfController2.actionTargetPoint = DecideFinalTargetPoint(targetPoint3, targetPoint6, self.attackMode));
                                self.targetingPointList.Add(targetPoint6);
                                self.SetActionTarget(targetPoint6.owner, true);
                            }
                            else
                            {
                                autoSelfController2.actionTargetPoint = targetPoint6;
                            }
                        }
                        else
                        {
                            autoSelfController2.actionTargetPoint = targetPoint3;
                        }
                    }
                }
                else
                {
                    self.SetActionTarget(null, true);
                }
            }
            bool         flag4        = false;
            TargetMarker targetMarker = null;
            markersTemp.Clear();
            markersTemp.AddRange(markers);
            paramList.Clear();
            int num12  = 0;
            int count3 = paramListPool.Count;
            for (int num13 = 0; num13 < numTargetInfo; num13++)
            {
                Enemy       enemy3       = targetInfoList[num13].enemy;
                TargetPoint targetPoint7 = targetInfoList[num13].targetPoint;
                if (targetPoint7 != targetPoint)
                {
                    targetPoint7.param.targetSelectCounter -= Time.get_deltaTime();
                    if (targetPoint7.param.targetSelectCounter < 0f)
                    {
                        targetPoint7.param.targetSelectCounter = 0f;
                    }
                }
                if (targetPoint7.get_enabled() && targetPoint7.get_gameObject().get_activeInHierarchy() && showMarker)
                {
                    Enemy.WEAK_STATE weakState = targetPoint7.param.weakState;
                    bool             flag5     = false;
                    if (self.CheckAttackMode(Player.ATTACK_MODE.ARROW) && (self.isArrowAimBossMode || (self.isArrowAimLesserMode && !self.isArrowAimEnd)))
                    {
                        flag5 = true;
                    }
                    bool flag6 = false;
                    if (Enemy.IsWeakStateSpAttack(weakState) && targetPoint7.param.weakSubParam == (int)self.attackMode)
                    {
                        flag6 = true;
                    }
                    bool  playSign    = false;
                    float markerScale = 1f;
                    if (enemy3 != null && targetPoint7.regionID >= 0 && targetPoint7.regionID < enemy3.regionWorks.Length)
                    {
                        if (flag5 && !flag6)
                        {
                            markerScale = targetPoint7.param.aimMarkerScale;
                        }
                        else
                        {
                            playSign = (weakState != targetPoint7.param.prevWeakState && weakState != Enemy.WEAK_STATE.NONE);
                        }
                        if (!flag4)
                        {
                            targetPoint7.param.prevWeakState = weakState;
                        }
                    }
                    bool flag7 = self.targetingPointList.Contains(targetPoint7) || fieldMultiLockDic.ContainsKey(targetPoint7);
                    bool flag8 = (parameter.enableNormalMarker || self.isArrowAimBossMode || targetPoint7.IsForceDisplay) && !self.isJumpAction;
                    if ((flag7 && flag8) || weakState != 0)
                    {
                        TargetMarker.UpdateParam updateParam = null;
                        if (num12 >= count3)
                        {
                            updateParam = new TargetMarker.UpdateParam();
                            paramListPool.Add(updateParam);
                        }
                        else
                        {
                            updateParam = paramListPool[num12];
                        }
                        updateParam.targetPoint      = targetPoint7;
                        updateParam.targeting        = flag7;
                        updateParam.isLock           = isTargetLock;
                        updateParam.weakState        = weakState;
                        updateParam.weakSubParam     = targetPoint7.param.weakSubParam;
                        updateParam.playSign         = playSign;
                        updateParam.spAttackType     = self.spAttackType;
                        updateParam.isAimArrow       = flag5;
                        updateParam.isAimMode        = (flag5 && !flag6);
                        updateParam.isAimChargeMax   = (self.GetChargingRate() >= 1f);
                        updateParam.markerScale      = markerScale;
                        updateParam.validElementType = targetPoint7.param.validElementType;
                        if (self.isArrowAimLesserMode)
                        {
                            updateParam.isMultiLockMax = self.isMultiLockMax();
                        }
                        targetMarker = null;
                        for (int num14 = 0; num14 < markersTemp.Count; num14++)
                        {
                            if (markersTemp[num14].point == updateParam.targetPoint)
                            {
                                targetMarker = markersTemp[num14];
                                markersTemp.RemoveAt(num14);
                                break;
                            }
                        }
                        if (targetMarker == null)
                        {
                            paramList.Add(updateParam);
                        }
                        else if (!flag4)
                        {
                            flag4 = targetMarker.UpdateMarker(updateParam);
                            if (self.isArrowAimLesserMode && self.spAttackType == SP_ATTACK_TYPE.SOUL && targetMarker.point == self.targetingPoint)
                            {
                                MultiLockMarker multiLockMarker = null;
                                if (fieldMultiLockDic.ContainsKey(targetPoint7))
                                {
                                    multiLockMarker = fieldMultiLockDic[targetPoint7];
                                }
                                else
                                {
                                    multiLockMarker = targetMarker.GetMultiLock();
                                    fieldMultiLockDic.Add(targetPoint7, multiLockMarker);
                                }
                                self.CheckMultiLock(multiLockMarker);
                            }
                        }
                        num12++;
                    }
                }
            }
            int num15 = 0;
            for (int count4 = paramList.Count; num15 < count4; num15++)
            {
                targetMarker = null;
                if (markersTemp.Count > 0)
                {
                    targetMarker = markersTemp[0];
                    markersTemp.RemoveAt(0);
                }
                else
                {
                    targetMarker = new TargetMarker(base._transform);
                    markers.Add(targetMarker);
                }
                if (!flag4)
                {
                    targetMarker.UpdateMarker(paramList[num15]);
                }
            }
            if (markersTemp.Count > 0)
            {
                for (int num16 = 0; num16 < markersTemp.Count; num16++)
                {
                    markersTemp[num16].UnableMarker();
                }
            }
            for (int num17 = 0; num17 < numTargetInfo; num17++)
            {
                targetInfoList[num17].enemy       = null;
                targetInfoList[num17].targetPoint = null;
            }
            numTargetInfo = 0;
            if (MonoBehaviourSingleton <StageObjectManager> .I.boss != null && updateShadowSealingFlag)
            {
                MonoBehaviourSingleton <StageObjectManager> .I.boss.CountShadowSealingTarget();

                updateShadowSealingFlag = false;
                MonoBehaviourSingleton <StageObjectManager> .I.boss.CheckCounterRegion();
            }
        }
    }
Esempio n. 5
0
 public void DeleteDropObject(FieldDropObject obj)
 {
     dropList.Remove(obj);
 }