GameEntity（十一）—— Iplayer

最新推荐文章于 2021-08-20 15:46:54 发布
最新推荐文章于 2021-08-20 15:46:54 发布
阅读量393 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22472397/article/details/78461392
版权

目录为：Assets/Scripts/GameEntity/目录下
Iplayer.cs

player接口

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System;

//继承Ientity
public class Iplayer: Ientity
{
    //吸附特效
    private GameObject AbsorbEffect1;
    private GameObject AbsorbEffect2;

    private GameObject AbsorbEffectDel1;
    private GameObject AbsorbEffectDel2;

    public GameObject AbsorbProgressEffect
    {
        get;
        set;
    }

    //构造函数
    public Iplayer(UInt64 sGUID, EntityCampType campType)
        :base(sGUID, campType)
    {
        //GameData部分定义
        //四个属性：HeadId,Level,Hp,Mp
        BattleData = new PlayerBattleData ();
    }

    public PlayerBattleData BattleData
    {
        private set;
        get;
    }

    public UInt64 GameUserId;

    public string GameUserNick
    {
        get;
        set;
    }

    public Ientity SyncLockTarget
    {
        protected set;
        get;
    }

    public bool GameUserIsMaster
    {
        get;
        private set;
    }

    public bool GameUserIsReady
    {
        get;
        private set;
    }

    public uint GameUserSeat
    {
        get;
        private set;
    }

    public int GameHeadId
    {
        get;
        private set;
    }

    //在GameDefine处定义
    //InitType = -1,
    //PlayerType,
    //PlayerObType,
    public ObPlayerOrPlayer ObType
    {
        get;
        private set;
    }

    //在GameDefine处定义
    ///DEUCE,
    //WIN,
    //LOSE,
    public SITUATION StateSituation
    {
        get;
        set;
    }

    //在GameDefine处定义
    //eFuryNullState = 0,
    //eFuryFullState,
    //eFuryRunState,
    public EFuryState FuryState
    {
        private set;
        get;
    }

    public int FuryValue
    {
        private set;
        get;
    }

    public int AccountGold
    {
        private set;
        get;
    }

    public const bool MasterTag = true;
    public const bool ReadyTag = true;
    public const int GameLookTag = 7;

    //默认为60.0f
    private float mDefaultHeight = CGLCtrl_GameLogic.Instance.GetGlobalHeight ();

    public void SetObjType(ObPlayerOrPlayer obType)
    {
        ObType = obType;
    }

    public override void OnEntityPrepareAttack()
    {

    }

    //创建特效
    void CreateEffect(ref GameObject Obj, string effectPath)
    {
        IEffect e = EffectManager.Instance.CreateNormalEffect (effectPath, RealEntity.objAttackPoint.gameObject);
        if (e != null)
        {
            if (Obj != null)
            {
                GameObject.DestroyImmediate (Obj);
                Obj = null;
            }

            Obj = e.obj;
        }
    }

    //设置吸收特效
    public void SetAbsorbEffect(int slot, bool isRemove)
    {
        if (isRemove == false)
        {
            if (slot == 0)
            {
                CreateEffect (ref AbsorbEffect1, "effect/other/soul_01");
            }
            else
            {
                CreateEffect (ref AbsorbEffect2, "effect/other/soul_02");

                //第二个吸魂特效位置根据第一个吸魂特效位置设置相对位置
                if (AbsorbEffect2 && AbsorbEffect1)
                {
                    Vector3 rot1 = AbsorbEffect1.transform.GetChild (0).transform.localEulerAngles;
                    AbsorbEffect2.transform.transform.localEulerAngles = new Vector3 (rot1.x, rot1.y, rot1.z);
                }
            }
        }
        else if (isRemove == true)
        {
            if (slot == 0)
            {
                DestroyEffect (ref AbsorbEffectDel1, AbsorbEffect1, "effect/other/soul_01_delete");
            }
            else if (slot == 1)
            {
                DestroyEffect (ref AbsorbEffectDel2, AbsorbEffect2, "effect/other/soul_02_delete");
            }
        }
    }

    //灵魂销毁 特效
    void DestroyEffect(ref GameObject desEffect, GameObject TranObj, string delPath)
    {
        if (TransObj != null)
        {
            if (desEffect != null)
            {
                desEffect.transform.parent = null;
                GameObject.DestroyImmediate (desEffect);
            }

            Iplayer player = PlayerManager.Instance.LocalPlayer;
            if (player == null)
            {
                return;
            }

            ResourceUnit objUnit = ResourcesManager.Instance.loadImmediate (delPath, ResourceType.PREFAB);
            GameObject obj = objUnit.Asset as GameObject;

            if (obj == null)
            {
                Debug.LogError("Res Not Found:" + delPath);
            }

            desEffect = GameObject.Instantiate (obj) as GameObject;
            desEffect.transform.position = TranObj.transform.position;
            TranObj.transform.parent = null;
            GameObject.DestroyImmediate (TranObj);
        }
    }

    //进入Idle状态
    public override void OnEnterIdle()
    {
        this.RealEntity.PlayerIdleAnimation ();
    }

    //设置锁定对象
    public virtual void SetSyncLockTarget(Ientity entity)
    {
        if (SyncLockTarget == entity)
        {
            return;
        }

        this.DeltLockTargetXuetiao (entity);
        this.SyncLockTarget = entity;
    }

    //处理锁定对象血条
    public void DeltLockTargetXuetiao(Ientity target)
    {
        if (this.SyncLockTarget != null && this.SyncLockTarget.entityType == EntityType.Buiding)
        {
            this.SyncLockTarget.DestroyXueTiao ();
        }

        if (target != null && target.entityType == EntityType.Buiding)
        {
            target.CreateXueTiao ();
        }
    }

    //Entity移动属性变化
    public override void OnEntityMoveSpeedChange(int value)
    {
        base.OnEntityMoveSpeedChange (value);
        HeroConfigInfo heroConfig;
        if (ConfigReader.HeroXmlInfoDict.TryGetValue(NpcGUIDType, out heroConfig))
        {
            //按比例来改变动画速度
            float speed = value / heroConfig.HeroMoveSpeed * heroConfig.n32BaseMoveSpeedScaling / 1000;
            if (speed == 0)
            {
                return;
            }

            this.RealEntity.SetMoveAnimationSpd (speed);
        }
    }

    //状态机执行Free消息
    public override void OnExecuteFree()
    {
        if (RealEntity == null || this.entityType == EntityType.Buiding)
        {
            return;
        }

        //计算平面位置
        Vector3 synPos2D = new Vector3 (m_pcGOSSI.sServerSyncPos.x, 60, m_pcGOSSI.sServerSyncPos.z);
        Vector3 realPos2D = new Vector3(RealEntity.GetTransform().position.x, 60, RealEntity.GetTransform().position.z);

        float fDistToServerPos = Vector3.Distance (synPos2D, realPos2D);

        if (fDistToServerPos < 0.5f)
        {
            if (EntityStrategyHelper.IsTick(this, EntityStrategyHelper.IdleTimeTick))
            {
                this.OnFSMStateChange (BlGame.FSM.EntityIdleFSM.Instance);

                return;
            }

            RealEntity.PlayerFreeAnimation ();
        }
        else if (fDistToServerPos > 5)
        {
            RealEntity.PlayerFreeAnimation ();
            //本地pos和服务端pos对齐
            RealEntity.GetTransform ().position = m_pcGOSSI.sServerBeginPos;
        }
        else
        {
            Vector3 sSyncDir = synPos2D - realPos2D;
            sSyncDir.Normalize ();
            Vector3 pos = sSyncDir * 2 * Time.deltaTime + realPos2D;

            //run 过去
            RealEntity.PlayerRunAnimation ();
            this.RealEntity.Controller.Move (sSyncDir * 2 * Time.deltaTime);
        }

        OnCameraUpdatePosition ();
        TurnAngle ();
    }

    //转动朝向
    private void TurnAngle ()
    {
        float fAngle = Vector3.Angle (RealEntity.GetTransform ().forward, EntityFSMDirection);
        if (fAngle > 2)
        {
            Quaternion DestQuaternion = Quaternion.LookRotation (EntityFSMDirection);
            Quaternion sMidQuater = Quaternion.Lerp (RealEntity.GetTransform ().rotation, DestQuaternion, 5 * Time.deltaTime);
            RealEntity.GetTransform ().rotation = sMidQuater;
        }
    }

    //状态机执行移动
    public override void OnExecuteMove()
    {
        if (RealEntity == null || this.entityType == EntityType.Buiding)
        {
            return;
        }

        Quaternion DestQuaternion = Quaternion.LookRotation (EntityFSMDirection);
        Quaternion sMidQuater = Quaternion.Lerp (RealEntity.GetTransform ().rotation, DestQuaternion, 10 * Time.deltaTime);
        RealEntity.GetTransform ().rotation = sMidQuater;

        float fTimeSpan = Time.realtimeSinceStartup - m_pcGOSSI.fBeginTime;
        float fMoveDist = fTimeSpan * m_pcGOSSI.fServerSpeed;
        m_pcGOSSI.sServerSyncPos = m_pcGOSSI.sServerBeginPos + m_pcGOSSI.sServerDir * fMoveDist;
        RealEntity.PlayerRunAnimation ();

        //同步2D位置处理
        Vector3 serverPos2D = new Vector3 (m_pcGOSSI.sServerSyncPos.x, 60, m_pcGOSSI.sServerSyncPos.z);
        Vector3 entityPos2d = new Vector3(RealEntity.GetTransform().position.x, 60, RealEntity.GetTransform().position.z);

        Vector3 sSyncDir = serverPos2D - entityPos2d;
        sSyncDir.Normalize ();
        float fDistToServerPos = Vector3.Distance (serverPos2D, entityPos2d);
        if (fDistToServerPos > 5)
        {
            RealEntity.GetTransform ().position = m_pcGOSSI.sServerSyncPos;
            OnCameraUpdatePosition ();

            return;
        }

        Vector3 pos = entityPos2d + sSyncDir * EntityFSMMoveSpeed * Time.deltaTime;
        this.RealEntity.Controller.Move (sSyncDir * EntityFSMMoveSpeed * Time.deltaTime);

        RealEntity.GetTransform ().position = new Vector3 (RealEntity.GetTransform().position.x, mDefaultHeight, RealEntity.GetTransform().position.z);

        OnCameraUpdatePosition ();
        EntityMoveCheck ();
    }

    //对象移动检测
    protected virtual void EntityMoveCheck()
    {

    }

    protected void OnCameraUpdatePosition()
    {
        if (objTransform.transform == GameMethod.GetMainCamera.arget && GameMethod.GetMainCamera != null && GameMethod.GetMainCamera.target != null && RealEntity != null)
        {
            //获取当前PlayState
            PlayState playState = GameStateManager.Instance.GetCurState () as PlayState;
            if (playState == null)
            {
                return;
            }

            if (playState.mCameraType == 1)     //斜45度
            {
                //根据角色阵营调整相机旋转角度
                Vector3 eular = GameMethod.GetMainCamera.transform.eulerAngles;
                if (RealEntity.CampType == EntityCampType.CampTypeA)
                {
                    GameMethod.GetMainCamera.transform.eulerAngles = new Vector3 (euler.x, 45.0f, 0/*euler.z*/);
                }
                else if (RealEntity.CampType == EntityCampType.CampTypeB)
                {
                    GameMethod.GetMianCamera.Transform.eulerAngles = new Vector3 (euler.x, -135.0f, 0/*euler.z*/);
                }

                GameMethod.GetMianCamera.FixedUpdatePosition ();
            }
            else
            {
                //根据角色阵营调整相机旋转角度
                Vector3 euler = GameMethod.GetMainCamera.transform.eulerAngles;
                if (RealEntity.CampType == EntityCampType.CampTypeA)
                {
                    GameMethod.GetMainCamera.transform.eulerAngles = new Vector3 (euler.x, 0.0f, 0/*euler.z*/);
                }
                else if (RealEntity.CampType == EntityCampType.CampTypeB)
                {
                    GameMethod.GetMainCamera.transform.eulerAngles = new Vector3 (euler.x, -180.0f, 0/*euler.z*/);
                }
            }
        }
    }

    public void SetSeatPosInfo(uint seat, bool ifMaster, bool ifReady, string userNick, int userHead, int gold)
    {
        GameUserSeat = seat;
        GameUserIsReady = ifReady;
        GameUserIsMaster = ifMaster;
        GameUserNick = userNick;
        GameHeadId = userHead;
        AccountGold = gold;
    }

    //Raises the update hp event
    public override void OnUpdateHp()
    {
        base.OnUpdateHp ();
    }

    public bool IsMaster()
    {
        if (GameUserIsMaster == MasterTag)
        {
            return true;
        }

        return false;
    }

    public bool isGameLookViewer()
    {
        if (GameUserSeat >= GameLookTag)
        {
            return true;
        }

        return false;
    }

    public override void OnUpdate()
    {
        base.OnUpdate ();

        Iselfplayer playerSelf = PlayerManager.Instance.LocalPlayer;

        //道理吗去执行说明是enemy player
        if (playerSelf != null && playerSelf.realObject != null && !this.IsSameCamp(playerSelf.EntityCamp))
        {
            //self player distance with enemy player
            float dis = Vector3.Distance (playerSelf.objTransform.position, objTransform.position);
            if (dis > GameConstDefine.PlayerLockTargetDis)
            {
                return;
            }

            if ((this.FSM != null && this.FSM.State == BlGame.FSM.FsmState.FSM_STATE_DEAD) || (this.realObject.activeSelf == false))
            {
                AddOrDelEnemy (this, false);
            }
            else
            {
                if (this.realObject.active == true)
                {
                    AddOrDelEnemy (this, true);
                }
            }
        }
    }

    public static void AddOrDelEnemy(Iplayer entity, bool add)
    {
        CEvent eve = new CEvent (EGameEvent.eGameEvent_AddOrDelEnemy);
        eve.AddParam ("Add", add);
        eve.AddParam ("Target", entity);
        EventCenter.SendEvent (eve);
    }

    public bool IsReady()
    {
        if (RealdyTag == GameUserIsReady)
        {
            return true;
        }

        return false;
    }

    //是否是同一阵营
    public bool IsSameCamp(Iplayer player)
    {
        if ((player.GameUserSeat % 2) == (GameUserSeat % 2))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public override void InitWhenCreateModel()
    {
        RealEntity.SetAttackAnimationLook (true);
    }

    //创建shadow
    public override void OnCreateShadow()
    {
        int id = (int)ObjTypeID;
        float radius = ConfigReader.GetHeroInfo (id).HeroCollideRadious;
        float range = radius / 100.0f;

        ResourceUnit objUnit = ResourcesManager.Instance.loadImmediate (GameDefine.GameConstDefine.LoadGameShadow, ResourceType.PREFAB);
        GameObject obj = GameObject.Instantiate (objUnit.Asset) as GameObject;

        obj.transform.parent = this.realObject.transform;
        obj.transform.localScale = new Vector3 (range, 1, range);
        obj.transform.localPosition = Vector3.zero;
    }

    //this死亡
    protected override void DoEntityDead()
    {
        this.XueTiao.SetVisible (false);
        if (this.RealEntity.Controller.enabled)
        {
            this.RealEntity.Controller.enabled = false;
        }
    }

    //Do 复活
    protected override void DoReborn()
    {
        base.DoReborn ();
        if (!this.RealEntity.Controller.enabled)
        {
            this.RealEntity.Controller.enabled = true;
        }

        if (this == PlayerManager.Instance.LocalPlayer && FSM.State == BlGame.FSM.FsmState.FSM_STATE_DEAD)
        {
            GameMethod.GetMainCamera.target = RealEntity.mTransform;
        }

        BlGame.Effect.EffectManager.Instance.CreateMormalEffect("effect/other/fuhuo", RealEntity.objAttackPoint.gameObject)
        ShowXueTiao();
    }

    public override void OnEntityLeadSkill()
    {

    }

    public override int GetSkillIdBySkillType(SkillType type)
    {
        switch (type)
        {
        case SkillType.SKILL_TYPE1:
            return ConfigReader.GetHeroInfo(NpcGUIDType).HeroSkillType1;
        case SkillType.SKILL_TYPE2:
            return ConfigReader.GetHeroInfo(NpcGUIDType).HeroSkillType2;
        case SkillType.SKILL_TYPE3:
            return ConfigReader.GetHeroInfo(NpcGUIDType).HeroSkillType3;
        case SkillType.SKILL_TYPE4:
            return ConfigReader.GetHeroInfo(NpcGUIDType).HeroSkillType4;
        case SkillType.SKILL_TYPE5:
            return ConfigReader.GetHeroInfo(NpcGUIDType).HeroSkillType5;
        }

        return -1;
    }

    protected virtual void UpdateFuryEffect()
    {
        if (null != this.RealEntity)
        {
            this.RealEntity.UpdateFuryEffect ();
        }
    }

    protected virtual void UpdateFuryValue()
    {

    }

    public virtual void SetFuryState(EFuryState state)
    {
        FuryState = state;
        UpdateFuryEffect ();
    }

    public void SetFuryValue(int value)
    {
        FuryValue = value;
        UpdateFuryValue ();
    }

    public virtual void CleanWhenGameOver()
    {

    }

    public void SetReconnectPlayerInfo(uint seat, string nickName)
    {
        GameUserNick = nickName;
        GameUserSeat = seat;
    }
}
飙风111
关注
GameFramework框架详解之 Entity实体
TxNet
03-27 2077
GameFramework中Entity，一般用于游戏运行时动态加载的游戏对象，如角色，怪物，武器，技能，子弹，特效等。一般来说，我们想创建一个实体，最简单的方法当然是Resource.Load()+Instantiate()，然后放到合适的位置，播放合适的动画即可。但是GameFramework却给每个实体定义了一个Entity类，一个EntityLogic类，一个EntityData类，初次用起来会感觉很吃力，甚至有的人觉得完全没必要，甚至放弃了GameFramework。
GameEntity&Component
逍遥剑客
04-12 3321
UpdateEntity的不同功能的更新频率可以不一致, 比如渲染60FPS, 逻辑15FPS更新频率可以做LOD处理, 如500米开外的更新频率可以设置为1FPS更新可以多线程化, 但是目前很少有人实现, 主要是复杂度与性价比的问题Component优点可复用, 为数据驱动提供基础节省资源, Entity只包含它所需要的功能, 省要不必要的CPU计算和内存占用可以运行时动态增加/删除Compon
游戏Entity设计不完全整理(转)
_Max
05-01 2737
在游戏引擎中，Entity通常被翻译成实体，也常用诸如GameObject、Actor、SimulationObject、Unit、Character等名字。相比于对图像声音引擎的热情，Entity层多年来一直备受冷遇，但最近几年随着大型游戏的发展，Entity层设计的重要性已经达到和图像声音的同等水平，而且已经出现了多种通用型Entity架构。当然，这里伴随着争议和分歧。 直接模式（The
GameEntity（四）—— Ientity
qq_22472397的博客
10-31 922
目录为：Assets/Scripts/GameEntity/目录下 Ientity.cs这是Entity的接口using System; using System.Collections; using System.Collections.Generic; using UnityEngine;//最主要的游戏实体 //整个Entity的接口 public class Ientity { /
GameEntity（六）—— IChat
qq_22472397的博客
11-01 324
目录为：Assets/Scripts/GameEntity/目录下 IChat.cs聊天的接口类using UnityEngine; using System.Collections; using System.Collections.Generic; using System;//看来是聊天相关的接口 public class IChat { public UInt64 SGUID
BBC iplayer
04-17
学英音，上BBC iplayer，听新闻，了解世界大事。支持多种小语种新闻直播。
e2iplayer-ov:适用于Open Vision的e2iplayer插件
04-09
【e2iplayer-ov:适用于Open Vision的e2iplayer插件】 e2iplayer-ov是一款专门针对Open Vision框架设计的插件，旨在增强和优化Open Vision平台的视频播放功能。Open Vision是一个开放源代码的计算机视觉库，它提供了...
get_iplayer-docker：用于get-iplayer的Docker容器，它获取最新版本，而不是将静态版本捆绑在容器中
02-05
get_iplayer-docker：用于get-iplayer的Docker容器，它获取最新版本，而不是将静态版本捆绑在容器中
iPlayer Downloader-开源
05-03
iPlayer Downloader是Mac OS X的下载客户端，允许BBC iPlayer服务的用户从Mac OS X下载无drm的电视程序。请注意，iPlayer Downloader没有以任何方式与BBC关联。
docker-get_iplayer:多体系结构get_iplayer泊坞窗映像
03-14
是BBC iPlayer / BBC声音索引工具和PVR 支持的架构 我们的映像支持多种架构，例如x86-64 ， arm64和armhf 。 我们利用Docker清单进行多平台感知。 更多信息可从码头工人和我们公布。 只需拉ghcr.io/t
GameEntity（二）—— EntityType
qq_22472397的博客
10-29 373
目录为：Assets/Scripts/GameEntity/目录下 EntityType.csusing UnityEngine; using System.Collections;public enum EntityType { Monster = 1, Soldier, Buiding, Player, AltarSoldier }public enum
非法操作 login.php,阅文游戏中心 h5游戏接入wiki
weixin_33651906的博客
04-01 749
阅文游戏中心《h5游戏 CP接口规范》接口要求规范游戏方接口说明：游戏方需按照规范提供，阅文进行调用阅文接口说明：阅文提供，游戏方调用参数 time 为Unix 时间戳(January 1 1970 00:00:00 GMT 起的秒数) ，单位为秒编码统一使用 UTF-8接口请求方式为 GET参数sign里的md5 加密要把md5后的字符串转成小写key双方协定或是一方处理完知会另一方php中.号...
帮你抢小游戏流量红利——快手小游戏入指南
it学思想的专栏
08-20 5915
帮你抢小游戏流量红利——快手小游戏入指南 一、接入游戏流程：申请开发者账号–申请接入游戏—完善游戏信息及上传证书—申请广告—调试项目—提交审核–上线 1、申请开发者账号资质 审核耗时半天 2、申请游戏接入 审核耗时半天 3、完善游戏资料 审核耗时半天 并同时上传各种证书（软著、备案表、自测报告等） 完成第3步后才可以上传代码包进行调试 4、申请广告代码 审核耗时2天 二、开发接入： 截止到2021年8月，各大引擎还未发布针对快手小游戏的插件，故需要借助发布的微信小游戏代码来修改。 比如针对白鹭项目： 1、补
c语言斗地主游戏源代码,game_dizhu
weixin_42162171的博客
05-22 3136
Matchvs-Poker在阅读此案例之前，需要熟悉 Matchvs SDK 的使用和了解 gameServer 的使用。自动编译 egret startserver -a概述Matchvs Poker 是一款比较流行的的斗地主游戏主要功能如下：实现了最经典的斗地主玩法，叫地主抢地主等功能。支持随机匹配模式，主动创建房间邀请微信好友模式两种。接入Matchvs独立的排行榜系统。分为客户端和服务端...
Unity 中用有限状态机来实现一个 AI
weixin_33811961的博客
01-08 1052
最近在阅读《游戏人工智能编程案例精粹（修订版）》，本文是书中第二章的一篇笔记。 有限状态机（英语：Finite-state machine, 缩写：FSM），是一个被数学家用来解决问题的严格形式化的设备，在游戏业中也常见有限状态机的身影。 对于游戏程序员来说，可以用下面这个定义来了解： 一个有限状态机是一个设备（device），或是一个设...
状态驱动的游戏智能体设计（中）
赖勇浩的编程私伙局
07-03 8823
  本文由恋花蝶最初发表于http://blog.csdn.net/lanphaday，欢迎转载，但必须保持全文完整，也必须包含本声明。译者并示取得中文版的翻译授权，翻译本文只是出于研究和学习目的。任何人不得在未经同意的情况下将英文版和中文版用于商业行为，转载本文产生的法律和道德责任由转载者承担，与译者无关。State-Driven Game Agent Design  状
【LSTM回归预测】基于emd结合长短记忆神经网络lstm实现风速回归预测附Matlab源码.rar
最新发布
10-28
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
SVM classifier train test result
10-28
SVM classifier train test result
C#窗口体非常非常非常详细步骤，定义接口IPlayer 定义抽象方法:播放、停止、暂停、下一首、上一首，返回类型为字 符串。 2)定义两个类: MP3、AVI。 两个类分别实现接口的方法，每个方法返回对应功能的语句，如MP3 播放方法返回“正在播放MP3歌曲"; AVI播放方法返回“正在播放AVl歌 曲"，其他方法类似返回对应的功能语句。 3)实现按钮功能。 ➢点击MP3按钮， 点击播放，显示“正在播放MP3歌曲!”，点击其他 按钮，显示对应的功能语句。 ➢点击AVl按钮，点击播放，显示“正在播放AVI视频!”，点击其他按 钮，显示对应的功能语句。
06-10
1. 定义接口IPlayer，包含抽象方法：播放、停止、暂停、下一首、上一首，返回类型为字符串。 ```c# public interface IPlayer { string Play(); string Stop(); string Pause(); string Next(); string ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值