Unity3D自学笔记——架构应用（七）客户端识别角色是否已经创建

客户端识别角色是否已经创建

角色已经创建则会隐藏创建按钮，显示进入游戏按钮，并且名字禁止输入



角色没有创建则隐藏进入游戏按钮，显示创建按钮，启用名字输入



分析

1.我们首先要从服务端获取账号下的角色数据，玩家登录的时候，判断是否已经拥有角色，若有则把UserEntity(UserEntity 包含了AccountEntity)返回给客户端进行缓存，若没有则返回AccountEntity

2.在英雄选择的时候去缓存中判断是否已经创建了该英雄，然后进行界面处理

服务端

ALI.ARPG.Domain

增加一个验证，若英雄已经拥有则不允许再次创建

CreateHeroValidateHandler

public ValidationResult Validate(CreateHeroCommand command)
{
ValidationResult result = null;
if(command.HeroID == 0)
{
result = new ValidationResult(Resource.HeroRequire);
}
else if (string.IsNullOrEmpty(command.Name.Trim()))
{
result = new ValidationResult(Resource.HeroNameRequire);
}
else
{
HeroEntity hero = heroRepository.FindBy(command.HeroID);
AccountEntity account = accountRepository.FindBy(command.AccountID);
UserEntity user = userRepository.FindBy(x=>x.Account.ID == command.AccountID && x.Hero.ID == command.HeroID);
UserEntity sameNameUser = userRepository.FindBy(x => x.Name == command.Name);

unitOfWork.Commit();
if(hero == null)
{
result = new ValidationResult(Resource.HeroNotFount);
}
else if(account == null)
{
result = new ValidationResult(Resource.AccountNotExist);
}
else if(sameNameUser != null)
{
result = new ValidationResult(Resource.HeroNameSame);
}
else if(user != null)
{//该账户下已经拥有该英雄
result = new ValidationResult(Resource.HeroIsExist);
}
}

return result;
}

修改LoginHandler

public class UserLoginHandler : ICommandHandler<UserLoginCommand>
{
private readonly AccountRepository accountRepository;
private readonly UserRepository userRepository;
private UnitOfWork unitOfWork;

public UserLoginHandler()
{
unitOfWork = new UnitOfWork();
accountRepository = new AccountRepository(unitOfWork.Session);
userRepository = new UserRepository(unitOfWork.Session);
}
public ICommandResult Excute(UserLoginCommand command)
{
AccountEntity account = accountRepository.FindBy(x => x.Name == command.Name && x.Password == command.Password);
account.IsLogin = true;
account.LoginTime = DateTime.Now;
accountRepository.Update(account);

//登录时查找是否有UserEntity
IEnumerable<UserEntity> users = userRepository.FilterBy(x => x.Account.ID == account.ID);

unitOfWork.Commit();

//有则返回UserEntity
if (users != null && users.Count() != 0)
return new CommandResult<UserEntity>(true, users);
else//否则返回AccountEntity
return new CommandResult<AccountEntity>(true, account);
}
}

ALI.ARPG.Server

AliPeer

修改Login处理请求

protected virtual void HandleLoginOperation(OperationRequest operationRequest, SendParameters sendParameters)
{
object json;
operationRequest.Parameters.TryGetValue(operationRequest.OperationCode, out json);
AccountEntity account = JsonMapper.ToObject<AccountEntity>(json.ToString());
var command = Mapper.Map<AccountEntity, UserLoginCommand>(account);
ValidationResult error = commandBus.Validate(command);
OperationResponse response = new OperationResponse((byte)OperationCode.Login);

if (error != null)
{
response.ReturnCode = (short)ReturnCode.Error;
Dictionary<byte, object> dict = new Dictionary<byte, object>();
string strJson = JsonMapper.ToJson(error);
dict.Add((byte)ReturnCode.Error, strJson);
response.Parameters = dict;
}
else
{
var result = commandBus.Submit(command);

if (result.Success)
{
string strJson = string.Empty;
byte key;

//如果账户下有角色数据则返回角色数据，否者返回英雄数据
//客户端通过key来判定是AccountEntity还是UserEntity，然后进行相应解析及缓存
if (result is CommandResult<AccountEntity>)
{//通过返回值类型来进行判断
key = 0;
CommandResult<AccountEntity> data = result as CommandResult<AccountEntity>;
strJson = JsonMapper.ToJson(data.Result);
}
else
{
key = 1;
CommandResult<UserEntity> data = result as CommandResult<UserEntity>;
strJson = JsonMapper.ToJson(data.Result);
}

response.ReturnCode = (short)ReturnCode.Sucess;
Dictionary<byte, object> dict = new Dictionary<byte, object>();
dict.Add(key, strJson);
response.Parameters = dict;
}
else
{
response.ReturnCode = (short)ReturnCode.Faild;
}
}

SendOperationResponse(response, sendParameters);
}

客户端

PhotonManger修改LoginResponse

private void HandleLoginResponse(OperationResponse operationResponse)
{
object json;
switch ((ReturnCode)operationResponse.ReturnCode)
{
case ReturnCode.Sucess:
Debug.Log("登录成功");
//通过Key来判断返回的类型
if (operationResponse.Parameters.ContainsKey(0))
{//AccountEntity
operationResponse.Parameters.TryGetValue(0, out json);
if (json != null)
{
//缓存AccountEntity
JsonData data = JsonMapper.ToObject(json.ToString());
new JsonToEntity<AccountEntity>(PhotonCacheType.Account, data).BuildEntityToCache();

//进入创建英雄场景
StartCoroutine(GameMain.Instance.LoadScene(SceneName.CharacterSelection));
}
}
else if (operationResponse.Parameters.ContainsKey(1))
{//UserEntity
operationResponse.Parameters.TryGetValue(1, out json);
if (json != null)
{
//缓存UserEntity
JsonData data = JsonMapper.ToObject(json.ToString());
new JsonToEntity<UserEntity>(PhotonCacheType.User, data).BuildEntityToCache();
//为了统一操作，所以再将UserEntity里的Account进行缓存
UserEntity user = PhotonDataCache.GetValue<UserEntity>(PhotonCacheType.User);
AccountEntity account = user.Account;
PhotonDataCache.AddOrUpdateDataCache(PhotonCacheType.Account, account.ID, account);

//进入创建英雄场景
StartCoroutine(GameMain.Instance.LoadScene(SceneName.CharacterSelection));
}
}
break;
case ReturnCode.Error:
PopupErrorMessage(operationResponse);
break;
}
}

界面处理

修改选择英雄的事件

public class UISelectHero : UIScene {
private UIHeroInfo m_HeroInfo;
private UIBottom m_Bottom;
private int m_SelectedHeroID;

public int SelectedHeroID
{
get
{
return m_SelectedHeroID;
}

set
{
m_SelectedHeroID = value;
}
}

protected override void Start()
{
base.Start();
InitWidget();
}

private void InitWidget()
{
m_HeroInfo = UIManager.Instance.GetUI<UIHeroInfo>(UIName.UIHeroInfo);
m_Bottom = UIManager.Instance.GetUI<UIBottom>(UIName.UIBottom);

for (int i = 0; i < this.GetWidgetCount(); i++)
{
UISceneWidget m_TogButton = GetWidget("togHero" + (i + 1));
if(m_TogButton != null)
{
m_TogButton.PointerClick += TogButtonOnPointerClick;
}
}
}

private void TogButtonOnPointerClick(UnityEngine.EventSystems.PointerEventData obj)
{
//获取HeroId
string heroID = obj.selectedObject.name;
int id;
heroID = heroID.Substring(heroID.Length - 1);
m_SelectedHeroID = (Int32.TryParse(heroID, out id)) ? id : 0;
//显示英雄介绍
m_HeroInfo.SetHeroInfo(m_SelectedHeroID);
//判断英雄是否已经创建
Dictionary<int, IEntity> users = PhotonDataCache.GetValue(PhotonCacheType.User);

var user = users.Select(x => x.Value).Cast<UserEntity>().Where(x => x.Hero.ID == id);
if(user.Count() > 0)
{//英雄已经创建
m_Bottom.ExistHero(true);
m_Bottom.IptName.text = user.ToList().First().Name;
}
else
{
m_Bottom.ExistHero(false);
m_Bottom.IptName.text = string.Empty;
}
}
}

UIBottom的方法，将它Public提供给外部调用

public void ExistHero(bool isExist)
{
IptName.interactable = !isExist;
m_BtnNew.gameObject.SetActive(!isExist);
m_BtnEnter.gameObject.SetActive(isExist);
}

搞定