public static void InitRankList()
{
if (CacheSet.ArenaRankCache.FindAll().Count == 0)
{
PlayerLogic player = new PlayerLogic();
HeroTeamLogic ht = new HeroTeamLogic();
for (int i = 0; i < GameConsts.Arena.RobotCount; i++)
{
player.AddRobot();
PlayerHeroLogic ph = new PlayerHeroLogic();
ph.SetUser(player.MyPlayer.Id);
ht.SetUser(player.MyPlayer.Id);
var heros = new int[] { 1, 2, 5 };//GameUtils.RandomChoose(1, 4, GameConsts.Hero.MaxHeroTeamCount);
foreach (int heroId in heros)
{
ph.AddNewHero(heroId);
ph.MyHeros.Heros[heroId].HeroLv = player.MyPlayer.Level;
}
List <int> heroTeam = new List <int>();
heroTeam.AddRange(heros);
ht.AssignHero(heroTeam);
AddNewPlayer(player.MyPlayer.Id);
PlayerArena pa = new PlayerArena();
pa.UserId = player.MyPlayer.Id;
pa.EnemyId = 0;
CacheSet.PlayerArenaCache.Add(pa);
}
}
}
private void GetInstanceReward(PlayerInstanceLogic instance)
{
int instanceId = instance.MyInstance.InstanceId;
PlayerLogic player = new PlayerLogic();
player.SetUser(m_UserId);
long nextRecoverTime;
if (!m_RequestPacket.Win)
{
int feedbackEnergy = PlayerInstanceLogic.GetFeedBackEnergy(instanceId);
player.AddEnergy(feedbackEnergy, out nextRecoverTime);
m_ResponsePacket.PlayerInfo = new PBPlayerInfo();
m_ResponsePacket.PlayerInfo.Energy = player.MyPlayer.Energy;
m_ResponsePacket.PlayerInfo.NextEnergyRecoveryTime = nextRecoverTime;
return;
}
DTInstance instanceData = PlayerInstanceLogic.GetInstanceData(instanceId);
player.MyPlayer.Coin += instanceData.Coin;
player.AddExp(instanceData.PlayerExp);
m_ResponsePacket.PlayerInfo = new PBPlayerInfo();
m_ResponsePacket.PlayerInfo.Id = player.MyPlayer.Id;
m_ResponsePacket.PlayerInfo.Coin = player.MyPlayer.Coin;
m_ResponsePacket.PlayerInfo.Exp = player.MyPlayer.Exp;
m_ResponsePacket.PlayerInfo.Level = player.MyPlayer.Level;
HeroTeamLogic heroTeam = new HeroTeamLogic();
heroTeam.SetUser(m_UserId);
PlayerHeroLogic playerHero = new PlayerHeroLogic();
playerHero.SetUser(m_UserId);
foreach (int heroId in heroTeam.MyHeroTeam.Team)
{
if (heroId == 0)
{
continue;
}
playerHero.SetHero(heroId).AddExp(instanceData.HeroExp);
m_ResponsePacket.LobbyHeroInfo.Add(new PBLobbyHeroInfo()
{
Type = heroId,
Exp = playerHero.MyHeros.Heros[heroId].HeroExp,
Level = playerHero.MyHeros.Heros[heroId].HeroLv,
Might = playerHero.MyHeros.Heros[heroId].Might,
});
}
m_ResponsePacket.InstanceType = instance.MyInstance.InstanceId;
CacheDictionary <int, int> dropDict = instance.GetDropList();
PlayerPackageLogic package = new PlayerPackageLogic();
package.SetUser(m_UserId);
PBReceivedItems receivedItems;
package.GetItems(dropDict, ReceiveItemMethodType.CompleteInstance, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
}
public override bool TakeAction()
{
PlayerFriendsLogic pf = new PlayerFriendsLogic();
pf.SetUser(m_UserId);
var nearbyPlayers = pf.GetOnlinePlayers();
var friends = pf.GetFriends();
HeroTeamLogic ht = new HeroTeamLogic();
PlayerHeroLogic ph = new PlayerHeroLogic();
NearbyPlayerLogic np = new NearbyPlayerLogic();
foreach (var player in nearbyPlayers)
{
ht.SetUser(player.Id);
ph.SetUser(player.Id).SetHero(ht.GetTeam()[0]);
Hero hero = ph.GetHeroInfo();
if (hero == null)
{
continue;
}
m_ResponsePacket.Heroes.Add(new PBLobbyHeroInfo()
{
Type = hero.HeroType,
Level = hero.HeroLv,
StarLevel = hero.HeroStarLevel,
ConsciousnessLevel = hero.ConsciousnessLevel,
ElevationLevel = hero.ElevationLevel
});
np.SetUser(player.Id);
m_ResponsePacket.Players.Add(new PBPlayerInfo()
{
Id = player.Id,
Name = player.Name,
Level = player.Level,
VipLevel = player.VIPLevel,
PortraitType = player.PortraitType,
LastLoginInTicks = player.LastLoginTime,
PositionX = np.NearbyPlayers.MyPositionX,
PositionY = np.NearbyPlayers.MyPositionY,
DisplayId = player.UUID
});
if (friends.ContainsKey(player.Id))
{
m_ResponsePacket.IsMyFriend.Add(true);
}
else
{
m_ResponsePacket.IsMyFriend.Add(false);
}
}
return(true);
}
private void Init()
{
PlayerChess newChess = new PlayerChess();
newChess.UserId = m_UserId;
CacheSet.PlayerChessCache.Add(newChess);
m_Chess = newChess;
HeroTeamLogic heroTeam = new HeroTeamLogic();
heroTeam.SetUser(m_UserId);
ChangeTeam(heroTeam.GetTeam());
ResetToken();
Reset();
}
private void SetHeroTeamInfo()
{
HeroTeamLogic heroTeam = new HeroTeamLogic();
heroTeam.SetUser(m_UserId);
CacheList <int> team = heroTeam.GetTeam();
PBHeroTeamInfo heroTeamInfo = new PBHeroTeamInfo();
foreach (int heroType in team)
{
heroTeamInfo.HeroType.Add(heroType);
}
m_ResponsePacket.HeroTeamInfo = heroTeamInfo;
}
public override bool TakeAction()
{
HeroTeamLogic team = new HeroTeamLogic();
team.SetUser(actionGetter.GetSession().UserId);
if (!team.AssignHero(m_RequestPacket.HeroTeamInfo.HeroType))
{
ErrorCode = (int)ErrorType.CannotOpenChance;
ErrorInfo = "Wrong Hero Team Info";
return(false);
}
m_ResponsePacket.HeroTeamInfo = new PBHeroTeamInfo();
m_ResponsePacket.HeroTeamInfo.HeroType.AddRange(team.MyHeroTeam.Team);
return(true);
}
public static BattleChessField GetBattleChessField(ChessFieldColor color, int enemyId, int count)
{
BattleChessField field = new BattleChessField();
field.Color = color;
field.IsOpened = false;
field.Count = count;
field.EnemyAnger = 0;
field.EnemyPlayerId = enemyId;
HeroTeamLogic heroTeam = new HeroTeamLogic();
heroTeam.SetUser(field.EnemyPlayerId);
PlayerHeroLogic playerHero = new PlayerHeroLogic();
playerHero.SetUser(field.EnemyPlayerId);
int i = 0;
foreach (int heroId in heroTeam.MyHeroTeam.Team)
{
if (heroId == 0)
{
break;
}
field.EnemyPlayerHeroTeam[i] = new Hero();
field.EnemyPlayerHeroTeam[i].HeroType = playerHero.MyHeros.Heros[heroId].HeroType;
field.EnemyPlayerHeroTeam[i].HeroLv = playerHero.MyHeros.Heros[heroId].HeroLv;
field.EnemyPlayerHeroTeam[i].HeroStarLevel = playerHero.MyHeros.Heros[heroId].HeroStarLevel;
field.EnemyPlayerHeroTeam[i].ElevationLevel = playerHero.MyHeros.Heros[heroId].ElevationLevel;
field.EnemyPlayerHeroTeam[i].ConsciousnessLevel = playerHero.MyHeros.Heros[heroId].ConsciousnessLevel;
field.EnemyPlayerHeroTeam[i].Gears = new CacheDictionary <GearType, int>();
field.EnemyPlayerHeroTeam[i].SkillLevels.AddRange(playerHero.MyHeros.Heros[heroId].SkillLevels);
foreach (var gear in playerHero.MyHeros.Heros[heroId].Gears)
{
field.EnemyPlayerHeroTeam[i].Gears[gear.Key] = gear.Value;
}
field.EnemyPlayerHeroTeam[i].Souls = new CacheDictionary <int, int>();
foreach (var soul in playerHero.MyHeros.Heros[heroId].Souls)
{
field.EnemyPlayerHeroTeam[i].Souls[soul.Key] = soul.Value;
}
//field.EnemyHeroHP.Add(MaxHP);
i++;
}
return(field);
}
public override bool TakeAction()
{
ArenaRankLogic ar = new ArenaRankLogic();
List <ArenaRank> rankList;
if (ar.TryGetRankList(m_RequestPacket.PageIndex, out rankList))
{
m_ResponsePacket.IsLastPage = false;
}
else
{
m_ResponsePacket.IsLastPage = true;
}
m_ResponsePacket.MyRank = ar.GetPlayerRank(m_UserId);
PlayerLogic p = new PlayerLogic();
HeroTeamLogic ht = new HeroTeamLogic();
foreach (var player in rankList)
{
PBArenaPlayerAndTeamInfo enemy = new PBArenaPlayerAndTeamInfo();
enemy.Rank = player.RankId;
p.SetUser(player.PlayerId);
enemy.PlayerInfo = new PBPlayerInfo()
{
Id = player.PlayerId,
Name = p.MyPlayer.Name,
Level = p.MyPlayer.Level,
PortraitType = p.MyPlayer.PortraitType
};
ht.SetUser(player.PlayerId);
var team = ht.GetTeam();
foreach (int hero in team)
{
PBLobbyHeroInfo heroInfo = new PBLobbyHeroInfo()
{
Type = hero
};
enemy.HeroTeam.Add(heroInfo);
}
m_ResponsePacket.Enemies.Add(enemy);
}
m_ResponsePacket.PageIndex = m_RequestPacket.PageIndex;
return(true);
}
public void RefreshMight()
{
HeroTeamLogic ht = new HeroTeamLogic();
ht.SetUser(MyPlayer.Id);
PlayerHeroLogic ph = new PlayerHeroLogic();
ph.SetUser(MyPlayer.Id);
int newMight = 0;
foreach (int heroId in ht.GetTeam())
{
if (heroId > 0)
{
newMight += ph.MyHeros.Heros[heroId].Might;
}
}
MyPlayer.Might = newMight;
}
public override bool TakeAction()
{
if (m_RequestPacket.Name.Length < 1 || m_RequestPacket.Name.Length > 30)
{
ErrorCode = (int)ErrorType.WrongInput;
ErrorInfo = "wrong length";
return(false);
}
if (PlayerLogic.FindUserByName(m_RequestPacket.Name) != null)
{
ErrorCode = (int)ErrorType.DuplicateName;
ErrorInfo = "Duplicate name";
return(false);
}
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
p.MyPlayer.ModifyLocked(() =>
{
p.MyPlayer.Name = m_RequestPacket.Name;
p.MyPlayer.PortraitType = m_RequestPacket.PortraitType;
p.MyPlayer.IsFemale = m_RequestPacket.IsFemale;
});
PlayerHeroLogic ph = new PlayerHeroLogic();
ph.SetUser(m_UserId);
ph.AddNewHero(m_RequestPacket.FirstHeroType);
HeroTeamLogic ht = new HeroTeamLogic();
ht.SetUser(m_UserId);
List <int> heroTeam = new List <int>()
{
m_RequestPacket.FirstHeroType
};
ht.AssignHero(heroTeam);
PlayerPackageLogic pp = new PlayerPackageLogic();
pp.SetUser(m_UserId);
return(true);
}
public override bool TakeAction()
{
InstanceProgressLogic ip = new InstanceProgressLogic();
ip.SetUser(m_UserId);
if (!(ip.GetInstanceProgress()).ContainsKey(m_RequestPacket.InstanceId))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "You have not passed this instance";
return(false);
}
PlayerInstanceLogic pi = new PlayerInstanceLogic();
pi.SetUser(m_UserId);
CacheDictionary <int, int> dropItems = new CacheDictionary <int, int>();
for (int i = 0; i < m_RequestPacket.Count; i++)
{
PBInstanceDrop instanceDrop = new PBInstanceDrop();
List <PBDropInfo> dropList = new List <PBDropInfo>();
List <PBDropInfo> dropPack;
var dropDict = pi.GenerateDropList(m_RequestPacket.InstanceId, true, out dropPack);
GameUtils.MergeItemDict(dropItems, dropDict);
foreach (var dropItem in dropDict)
{
PBDropInfo item = new PBDropInfo()
{
DropId = dropItem.Key,
DropCount = dropItem.Value
};
instanceDrop.Items.Add(item);
}
m_ResponsePacket.Drops.Add(instanceDrop);
}
PlayerPackageLogic pp = new PlayerPackageLogic();
pp.SetUser(m_UserId);
if (!pp.CheckPackageSlot(dropItems))
{
ErrorCode = (int)ErrorType.PackageSlotFull;
ErrorInfo = "Package full";
return(false);
}
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
int energy = PlayerInstanceLogic.GetInstanceEnergy(m_RequestPacket.InstanceId);
long nextRecoverTime;
if (!p.DeductEnergy(energy * m_RequestPacket.Count, out nextRecoverTime))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "You have not enough energy";
return(false);
}
PBReceivedItems receivedItems;
pp.GetItems(dropItems, ReceiveItemMethodType.CompleteInstance, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
DTInstance instanceData = PlayerInstanceLogic.GetInstanceData(m_RequestPacket.InstanceId);
p.AddCoin(instanceData.Coin * m_RequestPacket.Count);
p.AddExp(instanceData.PlayerExp * m_RequestPacket.Count);
m_ResponsePacket.Count = m_RequestPacket.Count;
m_ResponsePacket.InstanceId = m_RequestPacket.InstanceId;
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Id = m_UserId,
Coin = p.MyPlayer.Coin,
Exp = p.MyPlayer.Exp,
Level = p.MyPlayer.Level,
Energy = p.MyPlayer.Energy,
NextEnergyRecoveryTime = nextRecoverTime
};
HeroTeamLogic heroTeam = new HeroTeamLogic();
heroTeam.SetUser(m_UserId);
PlayerHeroLogic playerHero = new PlayerHeroLogic();
playerHero.SetUser(m_UserId);
foreach (int heroId in heroTeam.MyHeroTeam.Team)
{
if (heroId == 0)
{
continue;
}
//playerHero.SetHero(heroId).AddExp(instanceData.HeroExp);
m_ResponsePacket.LobbyHeroInfo.Add(new PBLobbyHeroInfo()
{
Type = heroId,
Exp = playerHero.MyHeros.Heros[heroId].HeroExp,
Level = playerHero.MyHeros.Heros[heroId].HeroLv
});
}
PlayerDailyQuestLogic.GetInstance(m_UserId).UpdateDailyQuest(DailyQuestType.CleanOutInstance, m_RequestPacket.Count);
return(true);
}
public override bool TakeAction()
{
PlayerLogic p = new PlayerLogic();
p.SetUser(m_RequestPacket.EnemyPlayerId);
ArenaRankLogic ar = new ArenaRankLogic();
m_ResponsePacket.EnemyInfo = new PBArenaPlayerAndTeamInfo();
m_ResponsePacket.EnemyInfo.PlayerInfo = new PBPlayerInfo()
{
Id = p.MyPlayer.Id,
Name = p.MyPlayer.Name,
PortraitType = p.MyPlayer.PortraitType,
Level = p.MyPlayer.Level,
};
m_ResponsePacket.EnemyInfo.Rank = ar.GetPlayerRank(m_RequestPacket.EnemyPlayerId);
PlayerHeroLogic ph = new PlayerHeroLogic();
ph.SetUser(m_RequestPacket.EnemyPlayerId);
HeroTeamLogic ht = new HeroTeamLogic();
ht.SetUser(m_RequestPacket.EnemyPlayerId);
GearLogic gear = new GearLogic();
SoulLogic soul = new SoulLogic();
foreach (int heroId in ht.GetTeam())
{
if (heroId == 0)
{
continue;
}
ph.SetHero(heroId);
Hero heroInfo = ph.GetHeroInfo();
PBLobbyHeroInfo pbhero = new PBLobbyHeroInfo()
{
Type = heroInfo.HeroType,
Level = heroInfo.HeroLv,
ConsciousnessLevel = heroInfo.ConsciousnessLevel,
ElevationLevel = heroInfo.ElevationLevel,
StarLevel = heroInfo.HeroStarLevel,
};
pbhero.SkillLevels.AddRange(heroInfo.SkillLevels);
foreach (var equipedGear in heroInfo.Gears)
{
gear.SetGear(equipedGear.Value);
PBGearInfo heroGear = new PBGearInfo()
{
Id = gear.MyGear.Id,
Type = gear.MyGear.TypeId,
Level = gear.MyGear.Level,
StrengthenLevel = gear.MyGear.StrengthenLevel
};
pbhero.GearInfo.Add(heroGear);
}
foreach (var equipedSoul in heroInfo.Souls)
{
soul.SetSoul(equipedSoul.Value);
PBSoulInfo heroSoul = new PBSoulInfo()
{
Id = soul.MySoul.Id,
Type = soul.MySoul.TypeId
};
pbhero.SoulInfo.Add(heroSoul);
}
m_ResponsePacket.EnemyInfo.HeroTeam.Add(pbhero);
}
return(true);
}
public override bool TakeAction()
{
IList <int> heroes;
if (m_RequestPacket.HeroTypes.Count == 0)
{
HeroTeamLogic ht = new HeroTeamLogic();
ht.SetUser(m_UserId);
heroes = ht.GetTeam();
}
else
{
heroes = m_RequestPacket.HeroTypes;
}
PlayerHeroLogic ph = new PlayerHeroLogic();
ph.SetUser(m_RequestPacket.PlayerId);
GearLogic gear = new GearLogic();
SoulLogic soul = new SoulLogic();
foreach (int heroId in heroes)
{
if (heroId == 0)
{
continue;
}
ph.SetHero(heroId);
Hero heroInfo = ph.GetHeroInfo();
PBLobbyHeroInfo pbhero = new PBLobbyHeroInfo()
{
Type = heroInfo.HeroType,
Level = heroInfo.HeroLv,
ConsciousnessLevel = heroInfo.ConsciousnessLevel,
ElevationLevel = heroInfo.ElevationLevel,
StarLevel = heroInfo.HeroStarLevel,
};
foreach (var equipedGear in heroInfo.Gears)
{
gear.SetGear(equipedGear.Value);
PBGearInfo heroGear = new PBGearInfo()
{
Id = gear.MyGear.Id,
Type = gear.MyGear.TypeId,
Level = gear.MyGear.Level,
StrengthenLevel = gear.MyGear.StrengthenLevel
};
pbhero.GearInfo.Add(heroGear);
}
foreach (var equipedSoul in heroInfo.Souls)
{
soul.SetSoul(equipedSoul.Value);
PBSoulInfo heroSoul = new PBSoulInfo()
{
Id = soul.MySoul.Id,
Type = soul.MySoul.TypeId
};
pbhero.SoulInfo.Add(heroSoul);
}
m_ResponsePacket.Heroes.Add(pbhero);
}
m_ResponsePacket.PlayerId = m_RequestPacket.PlayerId;
return(true);
}
public override bool TakeAction()
{
PlayerLogic player = new PlayerLogic();
player.SetUser(m_RequestPacket.PlayerId);
PlayerHeroLogic ph = new PlayerHeroLogic();
ph.SetUser(m_RequestPacket.PlayerId);
m_ResponsePacket.Player = new PBPlayerInfo()
{
Id = player.MyPlayer.Id,
Name = player.MyPlayer.Name,
VipLevel = player.MyPlayer.VIPLevel,
Level = player.MyPlayer.Level,
PlayerHeroCount = ph.MyHeros.Heros.Count,
Might = player.MyPlayer.Might,
DisplayId = player.MyPlayer.UUID
};
PlayerFriendsLogic pf = new PlayerFriendsLogic();
pf.SetUser(m_RequestPacket.PlayerId);
var friends = pf.GetFriends();
if (friends.ContainsKey(m_UserId))
{
m_ResponsePacket.IsMyFriend = true;
}
else
{
m_ResponsePacket.IsMyFriend = false;
}
HeroTeamLogic ht = new HeroTeamLogic();
ht.SetUser(m_RequestPacket.PlayerId);
GearLogic g = new GearLogic();
SoulLogic s = new SoulLogic();
foreach (int heroType in ht.MyHeroTeam.Team)
{
if (heroType == 0)
{
continue;
}
var hero = ph.SetHero(heroType).GetHeroInfo();
var heroInfo = new PBLobbyHeroInfo()
{
Type = hero.HeroType,
Level = hero.HeroLv,
ConsciousnessLevel = hero.ConsciousnessLevel,
ElevationLevel = hero.ElevationLevel,
StarLevel = hero.HeroStarLevel,
Might = hero.Might,
};
heroInfo.SkillLevels.AddRange(hero.SkillLevels);
foreach (var gear in hero.Gears)
{
g.SetGear(gear.Value);
heroInfo.GearInfo.Add(new PBGearInfo()
{
Id = g.MyGear.Id,
Type = g.MyGear.TypeId,
Level = g.MyGear.Level,
StrengthenLevel = g.MyGear.StrengthenLevel
});
}
foreach (var soul in hero.Souls)
{
s.SetSoul(soul.Value);
heroInfo.SoulInfo.Add(new PBSoulInfo()
{
Id = s.MySoul.Id,
Type = s.MySoul.TypeId,
});
}
m_ResponsePacket.HeroTeam.Add(heroInfo);
}
return(true);
}
private static PBRoomPlayerInfo GetPlayerRoomData(int playerId)
{
PBRoomPlayerInfo retData = new PBRoomPlayerInfo();
PlayerLogic p = new PlayerLogic();
p.SetUser(playerId);
retData.PlayerInfo = new PBPlayerInfo()
{
Id = playerId,
Name = p.MyPlayer.Name,
Level = p.MyPlayer.Level,
VipLevel = p.MyPlayer.VIPLevel,
PortraitType = p.MyPlayer.PortraitType,
Might = p.MyPlayer.Might,
};
HeroTeamLogic heroTeam = new HeroTeamLogic();
heroTeam.SetUser(playerId);
CacheList <int> team = heroTeam.GetTeam();
PlayerHeroLogic ph = new PlayerHeroLogic().SetUser(playerId);
foreach (int heroType in team)
{
if (heroType == 0)
{
continue;
}
ph.SetHero(heroType);
var heroInfo = ph.GetHeroInfo();
PBLobbyHeroInfo lobbyHeroInfo = new PBLobbyHeroInfo();
lobbyHeroInfo.Type = heroInfo.HeroType;
lobbyHeroInfo.Level = heroInfo.HeroLv;
lobbyHeroInfo.Exp = heroInfo.HeroExp;
lobbyHeroInfo.StarLevel = heroInfo.HeroStarLevel;
lobbyHeroInfo.ConsciousnessLevel = heroInfo.ConsciousnessLevel;
lobbyHeroInfo.ElevationLevel = heroInfo.ElevationLevel;
lobbyHeroInfo.SkillLevels.AddRange(heroInfo.SkillLevels);
foreach (var gear in heroInfo.Gears)
{
if (gear.Value == 0)
{
continue;
}
PBGearInfo gearInfo = new PBGearInfo();
gearInfo.Id = gear.Value;
Gears gearData = CacheSet.GearCache.FindKey(gear.Value);
gearInfo.Level = gearData.Level;
gearInfo.Type = gearData.TypeId;
gearInfo.StrengthenLevel = gearData.StrengthenLevel;
lobbyHeroInfo.GearInfo.Add(gearInfo);
}
foreach (var soul in heroInfo.Souls)
{
if (soul.Value == 0)
{
continue;
}
PBSoulInfo soulInfo = new PBSoulInfo();
soulInfo.Id = soul.Value;
Souls soulData = CacheSet.SoulCache.FindKey(soul.Value);
soulInfo.Type = soulData.TypeId;
lobbyHeroInfo.SoulInfo.Add(soulInfo);
}
PBRoomHeroInfo roomHeroInfo = new PBRoomHeroInfo()
{
LobbyHeroInfo = lobbyHeroInfo,
};
retData.RoomHeroInfo.Add(roomHeroInfo);
}
retData.LobbyServerId = int.Parse(ConfigUtils.GetSetting("Server.Id"));
PlayerSinglePvpLogic psp = new PlayerSinglePvpLogic();
psp.SetUser(playerId);
retData.Score = psp.MyPvp.SinglePvpScore;
return(retData);
}
