/// <summary>
/// 倒置
/// </summary>
public void Reverse()
{
PublicInfo TempPublic = AllRole.MyPublicInfo;
PrivateInfo TempPrivate = AllRole.MyPrivateInfo;
AllRole.MyPublicInfo = AllRole.YourPublicInfo;
AllRole.MyPrivateInfo = AllRole.YourPrivateInfo;
AllRole.YourPublicInfo = TempPublic;
AllRole.YourPrivateInfo = TempPrivate;
//关于方向的设置，还有战场位置
AllRole.MyPublicInfo.Hero.战场位置.本方对方标识 = true;
AllRole.YourPublicInfo.Hero.战场位置.本方对方标识 = false;
foreach (var minion in AllRole.MyPublicInfo.BattleField.BattleMinions)
{
if (minion != null)
{
minion.战场位置.本方对方标识 = true;
}
}
foreach (var minion in AllRole.YourPublicInfo.BattleField.BattleMinions)
{
if (minion != null)
{
minion.战场位置.本方对方标识 = false;
}
}
}
/// <summary>
/// 新的回合
/// </summary>
public void TurnStart(bool IsMyTurn)
{
PublicInfo PlayInfo = IsMyTurn ? actionStatus.AllRole.MyPublicInfo : actionStatus.AllRole.YourPublicInfo;
if (IsMyTurn)
{
actionStatus.AllRole.MyPrivateInfo.handCards.Add(CardUtility.GetCardInfoBySN(ClientRequest.DrawCard(GameId.ToString(GameServer.GameIdFormat), IsHost, 1)[0]));
}
//过载的清算
if (PlayInfo.OverloadPoint != 0)
{
PlayInfo.crystal.ReduceCurrentPoint(PlayInfo.OverloadPoint);
PlayInfo.OverloadPoint = 0;
}
//连击的重置
PlayInfo.连击状态 = false;
//魔法水晶的增加
PlayInfo.crystal.NewTurn();
PlayInfo.Hero.RemainAttackTimes = 1;
PlayInfo.Hero.IsUsedHeroAbility = false;
PlayInfo.BattleField.FreezeStatus();
//重置攻击次数,必须放在状态变化之后！
//原因是剩余攻击回数和状态有关！
foreach (var minion in PlayInfo.BattleField.BattleMinions)
{
if (minion != null)
{
minion.重置剩余攻击次数();
}
}
}
private void ResponseFollowAddRemove(RequestMsg_FollowAddRemove msg, int hostId, int connectionId)
{
if (msg.Unfollow)
{
if (msg.IsEmail)
{
mongo.DeleteFollowerShip(msg.Token, msg.UsernameDiscriminatorOrEmail);
}
else
{
string[] data = msg.UsernameDiscriminatorOrEmail.Split(new char[] { '#' }, System.StringSplitOptions.RemoveEmptyEntries);
mongo.DeleteFollowerShip(msg.Token, data[0], data[1]);
}
}
else
{
PublicInfo info = null;
if (msg.IsEmail)
{
info = mongo.InsertFollowership(msg.Token, msg.UsernameDiscriminatorOrEmail);
}
else
{
string[] data = msg.UsernameDiscriminatorOrEmail.Split(new char[] { '#' }, System.StringSplitOptions.RemoveEmptyEntries);
info = mongo.InsertFollowership(msg.Token, data[0], data[1]);
}
SendToClient(hostId, connectionId, new ResponseMsg_FollowAddRemove(MessageEnums.Status.OK, info));
}
}
private void UpdateFollowers(PublicInfo updatedInfo)
{
foreach (var followersAccount in mongo.SelectAllAccountForTarget(updatedInfo.Email))
{
SendToClient(followersAccount.HostId, followersAccount.ConnectionId, new ResponseMsg_FollowUpdate(updatedInfo));
}
}
public async Task FindOneRandomUser()
{
var interest = new Interest
{
Name = StringGenerator.GenerateRandomString(10)
};
await _interestRepository.AddAsync(interest);
interest.Id.Should().NotBeEmpty();
var publicInfo1 = new PublicInfo
{
NickName = StringGenerator.GenerateNameWithTimeStamp("user"),
PictureUrl = StringGenerator.GenerateRandomString(50)
};
var user1 = new User
{
Email = StringGenerator.GenerateEmailWithTimeStamp("rnd_user", "mail.com"),
Gender = Gender.Female,
LookingFor = Gender.Male,
PublicInfo = publicInfo1
};
await _userRepository.AddAsync(user1);
user1.Id.Should().NotBeEmpty();
var publicInfo2 = new PublicInfo
{
NickName = StringGenerator.GenerateNameWithTimeStamp("user"),
PictureUrl = StringGenerator.GenerateRandomString(50)
};
var user2 = new User
{
Email = StringGenerator.GenerateEmailWithTimeStamp("rnd_user", "mail.com"),
Gender = Gender.Male,
LookingFor = Gender.Female,
PublicInfo = publicInfo2
};
await _userRepository.AddAsync(user2);
user2.Id.Should().NotBeEmpty();
var userService1 = new UserService(new ReturnsZeroRandomGeneratorMock());
User rndUser1 = await userService1.GetOneRandomUser(x => x.Gender == Gender.Female);
Assert.NotNull(rndUser1);
var userService2 = new UserService(new ReturnsOneRandomGeneratorMock());
User rndUser2 = await userService2.GetOneRandomUser(x => x.Gender == Gender.Female);
Assert.NotNull(rndUser2);
Assert.NotEqual(rndUser1.Id, rndUser2.Id);
}
/// <summary>
/// 获得一个动作
/// </summary>
/// <param name="gameStatus"></param>
/// <returns></returns>
public static void GetAction(ActionStatus gameStatus)
{
String Action = String.Empty;
PublicInfo PlayInfo = gameStatus.AllRole.MyPublicInfo;
PrivateInfo PlaySelfInfo = gameStatus.AllRole.MyPrivateInfo;
List <String> Result = new List <string>();
//优先使用技能
if (PlayInfo.IsHeroSkillEnable(true))
{
//召唤
if (PlayInfo.Hero.HeroSkill.FirstAbilityDefine.MainAbilityDefine.TrueAtomicEffect.AtomicEffectType ==
Effect.AtomicEffectDefine.AtomicEffectEnum.召唤 &&
PlayInfo.BattleField.MinionCount != SystemManager.MaxMinionCount)
{
gameStatus.Interrupt.ActionCard = new MinimizeBattleInfo.HandCardInfo();
gameStatus.Interrupt.ActionCard.Init(PlayInfo.Hero.HeroSkill);
gameStatus.ActionName = "USEHEROSKILL";
gameStatus.Interrupt.Step = 1;
gameStatus.Interrupt.ActionName = "SPELL";
PlayInfo.crystal.CurrentRemainPoint -= PlayInfo.Hero.HeroSkill.使用成本;
PlayInfo.Hero.IsUsedHeroAbility = true;
RunAction.StartActionCS(gameStatus, PlayInfo.Hero.HeroSkill.序列号, new string[] { });
gameStatus.Interrupt.ActionName = "SPELL";
return;
}
}
//能上场的随从都上场
int HandCardIndex = HasBattleMinion(gameStatus);
if (HandCardIndex != -1)
{
int newPos = PlayInfo.BattleField.MinionCount + 1;
var card = PlaySelfInfo.handCards[HandCardIndex];
RunAction.StartActionCS(gameStatus, card.序列号, new string[] { newPos.ToString() });
PlayInfo.crystal.CurrentRemainPoint -= card.使用成本;
PlaySelfInfo.RemoveUsedCard(card.序列号);
PlayInfo.HandCardCount = PlaySelfInfo.handCards.Count;
gameStatus.Interrupt.ActionCard = new MinimizeBattleInfo.HandCardInfo();
gameStatus.Interrupt.ActionCard.Init(card);
gameStatus.Interrupt.ActionName = "MINION";
return;
}
//能攻击的随从都攻击，优先攻击英雄
int AttackPos = HasAttackMinion(gameStatus);
if (AttackPos != -1)
{
int BeAttackedPos = GetAttackTarget(gameStatus);
RunAction.Fight(gameStatus, AttackPos, BeAttackedPos, true);
gameStatus.Interrupt.ActionName = "FIGHT";
gameStatus.Interrupt.ExternalInfo = AttackPos.ToString() + BeAttackedPos.ToString();
return;
}
gameStatus.Interrupt.ActionName = ActionCode.strEndTurn;
}
private void OnLogInResponse(ResponseMsg_Login msg, int connectionId)
{
if (msg.Status == MessageEnums.Status.OK)
{
Info = new PublicInfo(msg, connectionId);
Info.Email = msg.Email;
Token = msg.Token;
SceneManager.LoadSceneAsync("Hub");
}
LogInResponseReceived?.Invoke(msg);
}
private void OnDisconnected(int recHostId, int connectionId)
{
// log out
PublicInfo disconnectedAccountPublicInfo = mongo.ClearAccount(connectionId);
// if connected but didn't login
if (disconnectedAccountPublicInfo != null)
{
// update the followers
UpdateFollowers(disconnectedAccountPublicInfo);
}
}
/// <summary>
/// 获得打击目标
/// </summary>
/// <returns></returns>
private static int GetAttackTarget(ActionStatus gameStatus)
{
PublicInfo PlayInfo = gameStatus.AllRole.YourPublicInfo;
for (int i = 0; i < PlayInfo.BattleField.MinionCount; i++)
{
if (PlayInfo.BattleField.BattleMinions[i].嘲讽特性)
{
return(i + 1);
}
}
return(PlayInfo.BattleField.MinionCount);
}
/// <summary>
/// 是否拥有可以攻击的随从
/// </summary>
/// <returns></returns>
private static int HasAttackMinion(ActionStatus gameStatus)
{
PublicInfo PlayInfo = gameStatus.AllRole.MyPublicInfo;
//能攻击的随从都攻击，优先攻击英雄
for (int i = 0; i < PlayInfo.BattleField.MinionCount; i++)
{
if (PlayInfo.BattleField.BattleMinions[i].能否攻击)
{
return(i + 1);
}
}
return(-1);
}
/// <summary>
/// 开始一个动作
/// </summary>
/// <param name="actionStatus">
/// 在调用这个过程之前，actionStatus里面的本方和对方都应该已经设定好了
/// 在这里不进行任何的方向判断，默认这个方法是由MyInfo发起的
/// </param>
/// <param name="CardSn"></param>
/// <returns></returns>
public static List <string> StartAction(ActionStatus actionStatus, string CardSn)
{
//清除事件池，注意，事件将在动作结束后整体结算
actionStatus.battleEvenetHandler.事件池.Clear();
CardBasicInfo card = CardUtility.GetCardInfoBySN(CardSn);
List <string> ActionCodeLst = new List <string>();
//未知的异常，卡牌资料缺失
if (card == null)
{
return(ActionCodeLst);
}
PublicInfo PlayInfo = actionStatus.AllRole.MyPublicInfo;
switch (card.卡牌种类)
{
case CardBasicInfo.资源类型枚举.法术:
actionStatus.ActionName = "USESPELLCARD";
UseSpellAction.RunBS(actionStatus, CardSn);
break;
case CardBasicInfo.资源类型枚举.随从:
actionStatus.ActionName = "USEMINIONCARD";
UseMinionAction.RunBS(actionStatus, CardSn);
break;
case CardBasicInfo.资源类型枚举.武器:
ActionCodeLst.Add(ActionCode.strWeapon + CardUtility.strSplitMark + CardSn);
PlayInfo.Hero.Weapon = (WeaponCard)card;
break;
case CardBasicInfo.资源类型枚举.奥秘:
ActionCodeLst.Add(ActionCode.strSecret + CardUtility.strSplitMark + CardSn);
actionStatus.AllRole.MyPrivateInfo.奥秘列表.Add((SecretCard)card);
PlayInfo.Hero.SecretCount = actionStatus.AllRole.MyPrivateInfo.奥秘列表.Count;
break;
default:
break;
}
//随从卡牌的连击效果启动
Combo(actionStatus, card, ActionCodeLst, PlayInfo);
if (ActionCodeLst.Count != 0)
{
PlayInfo.连击状态 = true;
ActionCodeLst.AddRange(actionStatus.battleEvenetHandler.事件处理(actionStatus));
}
return(ActionCodeLst);
}
/// <summary>
/// 能上场的随从
/// </summary>
/// <returns></returns>
private static int HasBattleMinion(ActionStatus gameStatus)
{
PrivateInfo PlaySelfInfo = gameStatus.AllRole.MyPrivateInfo;
PublicInfo PlayInfo = gameStatus.AllRole.MyPublicInfo;
if (PlayInfo.BattleField.MinionCount == SystemManager.MaxMinionCount)
{
return(-1);
}
for (int i = 0; i < PlaySelfInfo.handCards.Count; i++)
{
var card = PlaySelfInfo.handCards[i];
if (card.卡牌种类 == Card.CardBasicInfo.资源类型枚举.随从)
{
if (card.使用成本 <= PlayInfo.crystal.CurrentRemainPoint)
{
return(i);
}
}
}
return(-1);
}
private void AddToFollowList(PublicInfo follow)
{
if (follow != null)
{
GameObject go = Instantiate(FollowerPrefab, followListContent);
//the name
go.GetComponentInChildren <TextMeshProUGUI>().SetText(string.Format("{0}#{1}", follow.Username, follow.Discriminator));
//the online status
go.GetComponentInChildren <Image>().color = follow.Status == MessageEnums.AccountStatus.Online ? Color.green : Color.grey;
//the delete button
go.GetComponentInChildren <Button>().onClick.AddListener(delegate {
Debug.Log("Unfollow: " + follow.Username + "#" + follow.Discriminator);
Client.Self.RequestAddRemoveFollow(true, follow.Username + "#" + follow.Discriminator, Utilities.StringTpye.UsernameAndDiscriminator);
//TODO: run and check it's working fine
print(follow.ToString());
followInfoDic.Remove(follow.Email);
Destroy(go);
});
followInfoDic[follow.Email] = new Follow {
info = follow, goRef = go
};
}
}
/// <summary>
/// 对手回合结束的清场
/// </summary>
public List <string> TurnEnd(bool IsMyTurn)
{
PublicInfo PlayInfo = IsMyTurn ? actionStatus.AllRole.MyPublicInfo : actionStatus.AllRole.YourPublicInfo;
List <string> ActionLst = new List <string>();
//对手回合加成属性的去除
int ExistMinionCount = PlayInfo.BattleField.MinionCount;
for (int i = 0; i < ExistMinionCount; i++)
{
if (PlayInfo.BattleField.BattleMinions[i] != null)
{
PlayInfo.BattleField.BattleMinions[i].本回合生命力加成 = 0;
PlayInfo.BattleField.BattleMinions[i].本回合攻击力加成 = 0;
if (PlayInfo.BattleField.BattleMinions[i].特殊效果 == MinionCard.特殊效果枚举.回合结束死亡)
{
PlayInfo.BattleField.BattleMinions[i] = null;
}
}
}
PlayInfo.BattleField.ClearDead(事件处理组件, false);
ActionLst.AddRange(ActionStatus.Settle(actionStatus));
ActionLst.AddRange(事件处理组件.事件处理(actionStatus));
return(ActionLst);
}
private void timer1_Tick(object sender, EventArgs e)
{
string tmpstr = "";
if (m_ArrayContents != null)
{
if (richTextBox1.Lines.Length >= m_MaxLines)
{
//考虑到效率问题，先把内容复制到另外一个RichEdit中
richTextBox2.AppendText(richTextBox1.Text);
richTextBox1.Clear();
}
//此处有可能导致配置返回处理慢，需要考虑处理优化
if (m_ArrayContents.Count != 0)
{
tmpstr = m_ArrayContents[0] as string;
richTextBox1.AppendText(tmpstr);
richTextBox1.SelectionStart = richTextBox1.Text.Length;
richTextBox1.ScrollToCaret();
lock (m_ArrayContents)
{
m_ArrayContents.RemoveAt(0);
}
}
}
if (m_ServerInfoList != null)
{
BaseManage tmpManage = null;
int index = 0;
string tmpstatus = "未连接";
foreach (int id in m_ServerInfoList.Keys)
{
tmpManage = m_ServerInfoList[id] as BaseManage;
if (listBox_Online.Items.Count >= (index + 1))
{
switch (tmpManage.IdleFlag)
{
case -2:
tmpstatus = "正在连接";
break;
case -1:
tmpstatus = "未连接";
break;
case 0:
tmpstatus = "空闲";
break;
case 1:
tmpstatus = "忙碌";
break;
case 2:
tmpstatus = "帐号密码错误";
break;
case 3:
tmpstatus = "工作号密码错误";
break;
case 4:
tmpstatus = "异常错误";
break;
}
int tmpsecondtime = PublicInfo.DateDiff(DateTime.Now, tmpManage.SetBusyTime);
//检查配置，如果超过10秒钟仍为忙碌状态，则重新进行配置认证
if ((tmpManage.IdleFlag == 1) && (tmpsecondtime > 10))
{
//设置为异常状态，等待重新进行配置认证
Log.Record("server.log", "配置：" + tmpManage.OriginalConfigManage.Original_ConfigName + "(" + tmpManage.OriginalConfigManage.Original_OfficeNumber + ")" + tmpManage.OriginalConfigManage.Original_Ip + " 超过10秒钟仍为忙碌状态，设状态为异常，等待重新进行配置认证...");
tmpManage.IdleFlag = 4;
}
//Kevin 2012-12-09修改
//如果配置长时间都是 “正在连接” 或 “配置异常”状态，则重启线程
tmpsecondtime = PublicInfo.DateDiff(DateTime.Now, tmpManage.SendCmdTime);
//如果20秒还是正在连接状态，则重启线程
if ((tmpsecondtime > 20) && (tmpManage.IdleFlag == -2))
{
//“正在连接”状态异常
Log.Record("heart.log", "配置：" + tmpManage.OriginalConfigManage.Original_ConfigName + "(" + tmpManage.OriginalConfigManage.Original_OfficeNumber + ")" + tmpManage.OriginalConfigManage.Original_Ip + " 配置状态异常（超过20秒处于'正在连接'状态），重新启动线程进行配置认证...");
//启动专门的一个线程进行处理异常重启的配置
/////////////////////////////////////////
Thread tmpThread = new Thread(new ThreadStart(tmpManage.ReStartEterm));
tmpThread.Start();
}
//发送心跳包异常重新启动配置
tmpsecondtime = PublicInfo.DateDiff(tmpManage.HeartStartTime, tmpManage.HeartEndTime);
if (tmpManage.IdleFlag == 4)
{
//Log.Record("heart.log", "配置：" + tmpManage.OriginalConfigManage.Original_ConfigName + "(" + tmpManage.OriginalConfigManage.Original_OfficeNumber + ")" + tmpManage.OriginalConfigManage.Original_Ip +
// " 异常状态，心跳包间隔："+tmpsecondtime.ToString()+"秒，发送心跳包时间："+
// tmpManage.HeartStartTime.ToString("yyyy-MM-dd HH:mm:ss")+"，接收心跳包返回时间："+
// tmpManage.HeartEndTime.ToString("yyyy-MM-dd HH:mm:ss"));
tmpsecondtime = PublicInfo.DateDiff(DateTime.Now, tmpManage.ErrorTime);
if (tmpsecondtime > 60)
{
tmpManage.ErrorTime = DateTime.Now;
}
else
{
if (tmpsecondtime > 20)
{
Log.Record("heart.log", "配置：" + tmpManage.OriginalConfigManage.Original_ConfigName + "(" + tmpManage.OriginalConfigManage.Original_OfficeNumber + ")" + tmpManage.OriginalConfigManage.Original_Ip + " 配置状态异常（超过20秒处于'异常'状态），重新启动线程进行配置认证...");
//启动专门的一个线程进行处理异常重启的配置
/////////////////////////////////////////
Thread tmpThread = new Thread(new ThreadStart(tmpManage.ReStartEterm));
tmpThread.Start();
}
}
}
if ((tmpManage.IdleFlag != 0) && (tmpManage.HeartStartTime.CompareTo(tmpManage.HeartEndTime) > 0) && (tmpsecondtime > 10))
{
//发送心跳包线程异常，需要重新启动线程
Log.Record("heart.log", "配置：" + tmpManage.OriginalConfigManage.Original_ConfigName + "(" + tmpManage.OriginalConfigManage.Original_OfficeNumber + ")" + tmpManage.OriginalConfigManage.Original_Ip + " 发送心跳包间隔时间异常，重新启动线程进行配置认证...");
//启动专门的一个线程进行处理异常重启的配置
/////////////////////////////////////////
Thread tmpThread = new Thread(new ThreadStart(tmpManage.ReStartEterm));
tmpThread.Start();
}
if (tmpManage.EtermType == "地址认证")
{
listBox_Online.Items[index] = "(" + tmpManage.OriginalConfigManage.Original_OfficeNumber.ToUpper() + ")" + tmpManage.OriginalConfigManage.Original_LocalIp + ":" + tmpManage.OriginalConfigManage.Original_Port.ToString() + " " + tmpstatus;
}
else
{
listBox_Online.Items[index] = "(" + tmpManage.OriginalConfigManage.Original_OfficeNumber.ToUpper() + ")" + tmpManage.OriginalConfigManage.Original_ConfigName + ":" + tmpManage.OriginalConfigManage.Original_Port.ToString() + " " + tmpstatus;
}
index++;
}
else
{
if (tmpManage.EtermType == "地址认证")
{
listBox_Online.Items.Add("(" + tmpManage.OriginalConfigManage.Original_OfficeNumber.ToUpper() + ")" + tmpManage.OriginalConfigManage.Original_LocalIp + ":" + tmpManage.OriginalConfigManage.Original_Port.ToString() + " " + tmpstatus);
}
else
{
listBox_Online.Items.Add("(" + tmpManage.OriginalConfigManage.Original_OfficeNumber.ToUpper() + ")" + tmpManage.OriginalConfigManage.Original_ConfigName + ":" + tmpManage.OriginalConfigManage.Original_Port.ToString() + " " + tmpstatus);
}
}
}
}
}
public async Task <IHttpActionResult> Google([FromBody] GoogleRequestModel model)
{
try
{
if (!ModelState.IsValid || model == null)
{
return(BadRequest());
}
var body = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("grant_type", "authorization_code"),
new KeyValuePair <string, string>("code", model.Code),
new KeyValuePair <string, string>("redirect_uri", "http://localhost/signin-google"),
new KeyValuePair <string, string>("client_id", model.ClientId)
};
var client = new HttpClient();
var url = new Uri(Constants.TokenEndpoint);
var form = new FormUrlEncodedContent(body);
var tokenResponse = await client.PostAsync(url, form);
if (tokenResponse.IsSuccessStatusCode == false)
{
return(BadRequest());
}
string text = await tokenResponse.Content.ReadAsStringAsync();
JObject response = JObject.Parse(text);
string accessToken = response.Value <string>("access_token");
string tokenType = response.Value <string>("token_type");
if (string.IsNullOrEmpty(accessToken))
{
return(NotFound());
}
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, Constants.UserInfoEndpoint);
request.Headers.Authorization = new AuthenticationHeaderValue(tokenType, accessToken);
HttpResponseMessage userInfoResponse = await client.SendAsync(request);
if (userInfoResponse.IsSuccessStatusCode == false)
{
return(BadRequest());
}
text = await userInfoResponse.Content.ReadAsStringAsync();
JObject userObj = JObject.Parse(text);
string userEmail = _responseValuesGetter.TryGetValue(userObj, "email");
string googleId = _responseValuesGetter.TryGetValue(userObj, "id");
User user = await _userRepository.FindByEmailAsync(userEmail);
if (user == null)
{
var info = new PublicInfo
{
NickName = _responseValuesGetter.TryGetValue(userObj, "name"),
PictureUrl = _responseValuesGetter.TryGetValue(userObj, "picture")
};
user = new User
{
Email = userEmail,
Gender = _responseValuesGetter.GetGender(_responseValuesGetter.TryGetValue(userObj, "gender")),
PublicInfo = info
};
user.ExternalKeys.Add(new ExternalKey
{
Key = googleId,
Type = ExternalSystemType.Google
});
await _userRepository.AddAsync(user);
}
List <User> userFriends = await _userRepository.FindUsersByIds(user.FriendsIds);
string sendToken = _tokenManager.CreateSendToken(user);
var responseModel = new GoogleResponseModel
{
User = new UserResponseModel
{
ServerId = user.Id.ToString(),
Email = user.Email,
PublicInfo = user.PublicInfo,
BirthDate = user.BirthDate,
Gender = user.Gender,
LookingFor = user.LookingFor,
Seconds = user.Seconds,
FriendsList = userFriends.Select(x => new UserResponseModel
{
ServerId = x.Id.ToString(),
Email = x.Email,
PublicInfo = x.PublicInfo,
BirthDate = x.BirthDate,
Gender = x.Gender,
LookingFor = x.LookingFor,
Seconds = x.Seconds,
}).ToList()
},
Token = sendToken
};
return(Ok(responseModel));
}
catch (Exception)
{
return(InternalServerError());
}
}
private void timer1_Tick(object sender, EventArgs e)
{
string tmpstr = "";
if (m_ArrayContents != null)
{
if (richTextBox1.Lines.Length >= m_MaxLines)
{
//考虑到效率问题，先把内容复制到另外一个RichEdit中
richTextBox2.AppendText(richTextBox1.Text);
richTextBox1.Clear();
}
//此处有可能导致配置返回处理慢，需要考虑处理优化
if (m_ArrayContents.Count != 0)
{
tmpstr = m_ArrayContents[0] as string;
richTextBox1.AppendText(tmpstr);
richTextBox1.SelectionStart = richTextBox1.Text.Length;
richTextBox1.ScrollToCaret();
lock (m_ArrayContents)
{
m_ArrayContents.RemoveAt(0);
}
}
}
if (m_ServerInfoList != null)
{
BaseManage tmpManage = null;
int index = 0;
string tmpstatus = "未连接";
foreach (int id in m_ServerInfoList.Keys)
{
tmpManage = m_ServerInfoList[id] as BaseManage;
if (listBox_Online.Items.Count >= (index + 1))
{
switch (tmpManage.IdleFlag)
{
case -1:
tmpstatus = "未连接";
break;
case 0:
tmpstatus = "空闲";
break;
case 1:
tmpstatus = "忙碌";
break;
case 2:
tmpstatus = "帐号密码错误";
break;
case 3:
tmpstatus = "工作号密码错误";
break;
case 4:
tmpstatus = "异常错误";
break;
}
int tmpsecondtime = PublicInfo.DateDiff(DateTime.Now, tmpManage.SetBusyTime);
//检查配置，如果超过10秒钟仍为忙碌状态，则重新进行配置认证
if ((tmpManage.IdleFlag == 1) && (tmpsecondtime > 10))
{
//设置为异常状态，等待重新进行配置认证
Log.Record("server.log", "配置：" + tmpManage.OriginalConfigManage.Original_ConfigName + "(" + tmpManage.OriginalConfigManage.Original_OfficeNumber + ")" + tmpManage.OriginalConfigManage.Original_Ip + " 超过10秒钟仍为忙碌状态，设为状态为异常，等待重新进行配置认证...");
tmpManage.IdleFlag = 4;
}
if (tmpManage.EtermType == "地址认证")
{
listBox_Online.Items[index] = "(" + tmpManage.OriginalConfigManage.Original_OfficeNumber.ToUpper() + ")" + tmpManage.OriginalConfigManage.Original_LocalIp + ":" + tmpManage.OriginalConfigManage.Original_Port.ToString() + " " + tmpstatus;
}
else
{
listBox_Online.Items[index] = "(" + tmpManage.OriginalConfigManage.Original_OfficeNumber.ToUpper() + ")" + tmpManage.OriginalConfigManage.Original_ConfigName + ":" + tmpManage.OriginalConfigManage.Original_Port.ToString() + " " + tmpstatus;
}
index++;
}
else
{
if (tmpManage.EtermType == "地址认证")
{
listBox_Online.Items.Add("(" + tmpManage.OriginalConfigManage.Original_OfficeNumber.ToUpper() + ")" + tmpManage.OriginalConfigManage.Original_LocalIp + ":" + tmpManage.OriginalConfigManage.Original_Port.ToString() + " " + tmpstatus);
}
else
{
listBox_Online.Items.Add("(" + tmpManage.OriginalConfigManage.Original_OfficeNumber.ToUpper() + ")" + tmpManage.OriginalConfigManage.Original_ConfigName + ":" + tmpManage.OriginalConfigManage.Original_Port.ToString() + " " + tmpstatus);
}
}
}
}
}
/// <summary>
/// 检查中文拼音是否支持，防止出现缺少汉字的情况
/// </summary>
/// <param name="content"></param>
/// <returns></returns>
private bool CheckChinesePinYin(string content)
{
//先把字节包转换为字符串
string tmpcontent = content;
//源字符串长度
int count = tmpcontent.Length;
//序号
int index = 0;
//汉字的起始、结束字节标志
byte[] beginbuf = { 0x1B, 0x0E };
byte[] endbuf = { 0x1B, 0x0F };
int code = 0;
byte tmpbyte;
//汉字范围
//范围（0x4e00～0x9fff）转换成int（chfrom～chend）
int chfrom = Convert.ToInt32("4e00", 16);
int chend = Convert.ToInt32("9fff", 16);
bool isChinese = false;//是否汉字
//临时存储连续的汉字
string tmpstr = "";
string tmppinyin = "";//拼音
ArrayList al = new ArrayList();
PublicInfo thepub = new PublicInfo();
bool flag = true;
for (int i = 0; i < count; i++)
{
//获得字符串中指定索引i处字符unicode编码
code = Char.ConvertToUtf32(tmpcontent, i);
if (code >= chfrom && code <= chend)
{
//Base_PinYin _Base_PinYin = m_BasePinYinList.Find(delegate(Base_PinYin x)
//{
// if (x.HanZi == tmpcontent.Substring(i, 1))
// {
// return true;
// }
// else
// {
// return false;
// }
//});
//if ((_Base_PinYin == null) || (_Base_PinYin.BianMa.Trim() == "") || (_Base_PinYin.PinYin.Trim() == ""))
//{
// if (_Base_PinYin == null)
// {
// //添加到数据库
// _Base_PinYin = new Base_PinYin();
// _Base_PinYin.HanZi = tmpcontent.Substring(i, 1);
// _Base_PinYin.PinYin = "";
// _Base_PinYin.BianMa = "";
// _Base_PinYin.Remarks = "";
// ManageSpace.Manage.Add_Base_PinYin(_Base_PinYin);
// }
// flag = false;
//}
//检查中文拼音是否支持
byte[] hanziBt;
tmppinyin = chs2py.convert(tmpcontent.Substring(i, 1), out hanziBt);
if (hanziBt == null)
{
Log.Record("chinese.log", "不支持汉字：" + tmpcontent.Substring(i, 1) + " ||| " + tmpcontent);
return(false);
}
}
}
if (!flag)
{
Log.Record("chinese.log", "不支持汉字：" + tmpcontent);
return(false);
}
else
{
return(true);
}
}
private static void Combo(ActionStatus actionStatus, CardBasicInfo card, List <string> ActionCodeLst, PublicInfo PlayInfo)
{
if ((card.卡牌种类 != CardBasicInfo.资源类型枚举.法术) &&
PlayInfo.连击状态 && (!string.IsNullOrEmpty(card.连击效果)))
{
//初始化 Buff效果等等
SpellCard ablity = (SpellCard)CardUtility.GetCardInfoBySN(card.连击效果);
if (ablity != null)
{
var ResultArg = ablity.UseSpell(actionStatus);
if (ResultArg.Count != 0)
{
ActionCodeLst.AddRange(ResultArg);
//英雄技能等的时候，不算[本方施法]
if (ablity.法术卡牌类型 == CardBasicInfo.法术卡牌类型枚举.普通卡牌)
{
actionStatus.battleEvenetHandler.事件池.Add(new EventCard.全局事件()
{
触发事件类型 = EventCard.事件类型枚举.施法,
触发位置 = PlayInfo.Hero.战场位置
});
}
}
}
}
}
public string DealHero(ActionStatus game, PublicInfo PlayInfo)
{
throw new NotImplementedException();
}
public ResponseMsg_FollowUpdate(PublicInfo follow)
{
op = MessageEnums.OperationCode.FollowUpdateResponse;
this.Follow = follow;
}
public ResponseMsg_FollowAddRemove(MessageEnums.Status status, PublicInfo follow)
{
op = MessageEnums.OperationCode.FollowAddRemoveResponse;
this.Status = status;
this.Follow = follow;
}
