Пример #1
0
        public RuneBuff(Transform rRoot, Creature rListener, int rBuffId)
        {
            if (rRoot == null)
            {
                return;
            }
            rRoot.SafeSetActive(true);
            listener     = rListener;
            listenerBuff = rBuffId;
            var info = ConfigManager.Get <BuffInfo>(rBuffId);

            Util.SetText(rRoot.GetComponent <Text>("rune_buff_03/rune_txt"), info?.name ?? string.Empty);
            miniIconNode = rRoot.GetComponent <Transform>("rune_buff_01");
            iconNode     = rRoot.GetComponent <Transform>("rune_buff_03");

            miniIconNode.SafeSetActive(info != null);
            iconNode.SafeSetActive(false);

            if (info?.runeIcons != null)
            {
                if (info.runeIcons.Length > 0 && !string.IsNullOrEmpty(info.runeIcons[0]))
                {
                    AtlasHelper.SetRune(rRoot.GetComponent <Image>("rune_buff_01"), info.runeIcons[0]);
                }
                if (info.runeIcons.Length > 1 && !string.IsNullOrEmpty(info.runeIcons[1]))
                {
                    AtlasHelper.SetRune(rRoot.GetComponent <Image>("rune_buff_03"), info.runeIcons[1]);
                }
            }
            listener?.AddEventListener(CreatureEvents.BUFF_TRIGGER, OnBuffTrigger);
            listener?.AddEventListener(CreatureEvents.BUFF_REMOVE, OnBuffRemove);
        }
Пример #2
0
    protected override void OnCreateCreatures()
    {
        base.OnCreateCreatures();         // Create default player

        m_player.regenRagePercent = 0.3f; // Regen 30% rage every second

        moduleAI.AddCreatureToCampDic(m_player);

        var info = modulePlayer.BuildPlayerInfo(modulePlayer.proto);

        info.name = Util.GetString(9208);

        m_enermy = Creature.Create(info, new Vector3_(CombatConfig.spvpStart.y, 0, 0), new Vector3(0, 90, 0), false, "enermy", info.name);
        m_enermy.FaceTo(player);

        var es = Module_Equip.SelectRandomEquipments(m_player.gender, m_player.roleProto);

        m_enermy.avatar    = es[0] + "_" + es[1] + "_" + es[2];
        m_enermy.avatarBox = m_player.avatarBox;
        m_enermy.roleProto = m_player.roleProto;
        moduleAI.AddCreatureToCampDic(m_enermy);

        CharacterEquip.ChangeCloth(m_enermy, es);

        m_enermy.maxHealth          = (int)(player.attack + player.elementAttack) * 20;
        m_enermy.health             = m_enermy.maxHealth;
        m_enermy.regenHealthPercent = 0.3;

        player.AddEventListener(CreatureEvents.DEAD, OnCreatureDead);
        m_enermy.AddEventListener(CreatureEvents.DEAD, OnCreatureDead);
        EventManager.AddEventListener(CreatureEvents.Dying, OnCreatureDying);
    }
Пример #3
0
    public static void ChangeCloth(Creature c, int[] items, bool isCombine = false)
    {
        var e = c.activeRootNode.GetComponentDefault <CharacterEquip>();

        c.AddEventListener(CreatureEvents.RESET_LAYERS, e.OnCreatureResetLayer);
        e.RefreshCloth(items);
        if (isCombine)
        {
            e.CombineMesh();
        }
    }
Пример #4
0
    /// <summary>
    /// 仅处理更换时装
    /// </summary>
    /// <param name="c"></param>
    /// <param name="fashion"></param>
    /// <param name="isCombine">如果合并网格,则需要重新加载动画控制器</param>
    public static void ChangeCloth(Creature c, PFashion fashion, bool isCombine = false)
    {
        if (fashion == null)
        {
            return;
        }

        var e = c.activeRootNode.GetComponentDefault <CharacterEquip>();

        c.AddEventListener(CreatureEvents.RESET_LAYERS, e.OnCreatureResetLayer);
        e.RefreshCloth(fashion);
        if (isCombine)
        {
            e.CombineMesh();
        }
    }
Пример #5
0
    private void BindToPlayer()
    {
        if (!m_creature)
        {
            return;
        }

        var np = m_creature.position + offset;

        RecalculateEdge(ref np);

        m_t.position    = np;
        m_t.eulerAngles = m_euler;

        m_startZ = m_t.position.z;

        m_creature.AddEventListener(CreatureEvents.ENTER_STATE, OnPlayerEnterState);
    }
Пример #6
0
    public void InitializedData(int id, Creature creature = null)
    {
        isNeedCreature = creature != null;
        m_creature     = creature;

        if (m_creature != null)
        {
            m_creature.RemoveEventListener(CreatureEvents.ENTER_STATE, OnStateChaged);
            m_creature.AddEventListener(CreatureEvents.ENTER_STATE, OnStateChaged);
        }

        text     = transform.Find("bg/content")?.GetComponent <Text>();
        textTran = transform.Find("bg");

        var config = ConfigManager.Get <ConfigText>(id);

        if (config == null || config.text == null || config.text.Length < 1)
        {
            return;
        }
        texts = config.text;
    }
Пример #7
0
    private void AssistMemberCommonOn(Creature rCreature)
    {
        assistMember = rCreature;
        if (assistMember == null)
        {
            return;
        }
        isAssistComeOn = true;
        Module_Avatar.SetClassAvatar(assistIcon.gameObject, assistMember);
        Module_Avatar.SetClassAvatar(assistIcon2.gameObject, assistMember);
        assistHpSlider.fillAmount = assistMember.healthRate;
        Util.SetText(assistName, Util.Format(ConfigText.GetDefalutString(198), GetAssistName()));

        assistRoot.SafeSetActive(true);
        assistIcon.saturation = 1;

        assistNotice.SafeSetActive(true);
        var tween = assistNotice?.GetComponent <TweenBase>();

        tween?.Play();

        assistMember.AddEventListener(CreatureEvents.HEALTH_CHANGED, OnAssistHealthChange);
    }
Пример #8
0
    /// <summary>
    /// Init creature info
    /// </summary>
    /// <param name="index">0 = left  1 = right</param>
    private void InitCreature(int index, Creature c)
    {
        var old = index == 0 ? m_hero1 : m_hero2;

        if (old)
        {
            old.RemoveEventListener(this);
        }

        var isPlayer = old == m_player && old || c && c.isPlayer;

        if (index == 0)
        {
            m_hero1 = c;
        }
        else
        {
            m_hero2 = c;
        }

        var a = index == 0 ? m_avatarLeft : m_avatarRight;

        if (a)
        {
            a.creature = c;
        }

        if (c)
        {
            c.AddEventListener(CreatureEvents.DEAD_ANIMATION_END, OnCreatureRealDead);

            if (!c.isPlayer)
            {
                if (m_isPvP || m_isTrain)
                {
                    c.AddEventListener(CreatureEvents.ENTER_STATE, OnEnermyEnterState);
                    c.AddEventListener(CreatureEvents.HIT_INFO_CLEARED, OnClearComboState);
                }
            }
            else
            {
                m_player = c;
            }
        }

        if (isPlayer)
        {
            if (m_player)
            {
                m_btnShoot.ignoreInteractable = true;
                m_btnAwake.ignoreInteractable = true;

                m_player.AddEventListener(CreatureEvents.ATTACK, OnCreatureAttack);
                m_player.AddEventListener(CreatureEvents.COMBO_BREAK, OnClearComboState);
                m_player.AddEventListener(CreatureEvents.DEAL_DAMAGE, OnPlayerDealDamage);
                m_player.AddEventListener(CreatureEvents.DEAL_UI_DAMAGE, OnPlayerDealUIDamage);
                m_player.AddEventListener(CreatureEvents.BATTLE_UI_INFO, OnBattleUIInfo);
                m_player.AddEventListener(CreatureEvents.RAGE_CHANGED, UpdateBurstButtonState);
                m_player.AddEventListener(CreatureEvents.BULLET_COUNT_CHANGED, UpdateShootButtonState);
                m_player.AddEventListener(CreatureEvents.ATTACK_HIT_FAILED, OnAttackHitFailed);
                m_player.AddEventListener(CreatureEvents.QUIT_STATE, OnPlayerQuitState);

                if (m_awakeRoot.activeSelf)
                {
                    m_player.AddEventListener(CreatureEvents.ENERGY_CHANGED, UpdateAwakeButtonState);
                    m_player.AddEventListener(CreatureEvents.MORPH_PROGRESS, UpdateAwakeProgress);
                }

                if (m_player.pet)
                {
                    m_player.pet.AddEventListener(CreatureEvents.ENTER_STATE, OnPetEnterState);
                }
            }
            else
            {
                m_btnShoot.interactable = false;
                m_btnBurst.interactable = false;
                m_btnAwake.interactable = false;
            }
        }

        var bn = GetComponent <Transform>(index == 0 ? "rune_buff/rune_buff_left" : "rune_buff/rune_buff_right");
        var bb = index == 0 ? m_runeBuffs[0] : m_runeBuffs[1];

        InitRuneBuff(c, bn, ref bb);
    }
Пример #9
0
    protected override void OnOpen()
    {
        m_npc = null;

        GetComponent <NpcMono>("content/role_render")?.InitAction(c =>
        {
            m_npc = c;
            if (m_npc)
            {
                m_npc.AddEventListener(CreatureEvents.ENTER_STATE, OnNpcEnterState);
            }
        });

        m_btnSkipAnimation = GetComponent <Button>("mask");
        m_btnAddWishCoin   = GetComponent <Button>("topLayer/wishCoin/add");
        m_btnWish          = GetComponent <Button>("content/wish_Btn");
        m_btnWishTen       = GetComponent <Button>("content/wish_Btn02");
        m_ruleBtn          = GetComponent <Button>("content/activity_Btn");
        m_wish             = GetComponent <Transform>("content/wish_Btn").gameObject;
        m_popOK            = GetComponent <Button>("topLayer/popup/yes");
        m_sss          = GetComponent <WishItemInfoSSS>("topLayer/tips/jipin");
        m_itemTemplate = GetComponent <RectTransform>("content/dropInfo/info/inner/items/template").gameObject;
        m_ta           = GetComponent <TweenAlpha>("content");
        m_ta2          = GetComponent <TweenAlpha>("topLayer/wishCoin");
        m_tb           = GetComponent <TweenAlphaParticle>("content/wish_Btn/effect");
        m_tc           = GetComponent <TweenColor>("npc");
        m_tad          = GetComponent <TweenAlpha>("content/dropInfo");
        m_rewardShow   = GetComponent <RewardShow>("topLayer/tips");
        m_popUpContext = GetComponent <Text>("topLayer/popup/content1/info");

        m_btnWish2    = GetComponent <Button>("topLayer/tips/wish_goods/GameObject/wish_Btn");
        m_btnWishTen2 = GetComponent <Button>("topLayer/tips/wish_goods/GameObject/wish_Btn02");

        m_itemTemplate.SetActive(false);

        if (null != m_rewardShow)
        {
            m_rewardShow.OnClose += () =>
            {
                HighlightNpc(false);
                Module_Guide.AddSpecialTweenEndCondition();
                moduleGlobal.ShowGlobalTopRightBar(false);
            };
            m_rewardShow.onAnimEnd.AddListener(() =>
            {
                m_ta2.Play(false);
                m_btnWish2.transform.parent.SafeSetActive(!moduleGuide.inGuideProcess);
            });
        }
        m_popOK?.onClick.AddListener(() =>
        {
            if (wishTimes > 0)
            {
                moduleWish.ImFeelingLucky(wishTimes, true);
                wishTimes = 0;
            }
            else
            {
                moduleWish.BuyWishCoin(currentTimes, true);
            }
        });
        m_ruleBtn.onClick.AddListener(() => { m_wish.SetActive(false); });

        m_btnAddWishCoin?.onClick.AddListener(() =>
        {
            UpdateGemText(1, false);
        });

        m_btnWish?.onClick.AddListener(() => { OnWishClick(1); });
        m_btnWish2?.onClick.AddListener(() => { OnWishClick(1); });
        m_btnWishTen?.onClick.AddListener(() => { OnWishClick(10); });
        m_btnWishTen2?.onClick.AddListener(() => { OnWishClick(10); });

        m_btnSkipAnimation.SafeSetActive(false);
        m_btnSkipAnimation?.onClick.AddListener(() =>
        {
            m_skipAnimation = true;
            m_npc.stateMachine.TranslateToID(CREATURE_STATE_IDLE);
        });

        InitializeText();
        UpdateWishCoinText();

        m_rewardShow?.Regirest(IsSSS, m_sss);

        m_dropInfo = new DataSource <PWishItemDropInfo>(moduleWish.dropInfo, GetComponent <ScrollView>("content/dropInfo/info/inner/items"), SetDropItem);
    }
Пример #10
0
    public static Effect Create(StateMachineInfo.Effect effInfo, Transform node, Creature source = null, Buff sourceBuff = null)
    {
        var pos      = effInfo.offset * 0.1f;
        var rotation = effInfo.rotation;

        if (node)
        {
            pos      = node.TransformPoint(pos);
            rotation = (node.rotation * Quaternion.Euler(rotation)).eulerAngles;
        }

        if (effInfo.lockY != 0)
        {
            pos.y = effInfo.lockY < 0 ? 0 : effInfo.lockY;
        }

        var eff = Create <Effect>(effInfo.effect, effInfo.effect, pos, rotation);

        eff.source     = source;
        eff.follow     = effInfo.follow;
        eff.sourceBuff = sourceBuff;
        eff.m_inherit  = effInfo.inherit;
        eff.m_freez    = !effInfo.markedHit && source && !source.stateMachine.playable;

        if (effInfo.follow)
#if UNITY_EDITOR
        {
            eff.transform.SetParent(node, true);
            if (source && source.lockLayer)
            {
                Util.SetLayer(eff.gameObject, source.lockedLayer);
            }
        }
#else
        { eff.transform.SetParent(node, true); }
#endif

        eff.m_originEular = eff.localEulerAngles;
        eff.lockForward   = effInfo.syncRotation ? Vector3.zero : eff.transform.forward;
        eff.startForward  = !source || source.isForward;

        if (sourceBuff != null)
        {
            eff.m_buffCheck = sourceBuff.version;
            eff.lifeTime    = -1;
        }
        else
        {
            eff.m_buffCheck = 0;
        }

        if (source)
        {
            if (effInfo.interrupt)
            {
                source.AddEventListener(CreatureEvents.QUIT_STATE, eff.OnCreatureQuitState);
            }
            if (effInfo.follow)
            {
                source.AddEventListener(CreatureEvents.DIRECTION_CHANGED, eff.OnCreatureDirectionChanged);
                source.AddEventListener(CreatureEvents.MORPH_MODEL_CHANGED, eff.OnCreatureMorphModelChanged);

                if (node != source.behaviour.effects.transform)
                {
                    source.AddEventListener(CreatureEvents.RESET_LAYERS, eff.OnCreatureResetLayers);
                }
            }
            source.AddEventListener(CreatureEvents.STATE_PLAYABLE, eff.OnCreatureStatePlayable);
        }

        eff.m_inverted = source && !source.isForward;
        eff.UpdateInvert();

        return(eff);
    }