/// <summary>
/// Tries setting the requested state parameter
/// </summary>
/// <param name="parameter">The state parameter that is being requested</param>
/// <param name="server">The server to excecute on</param>
/// <param name="sender">The player that is requesting the state change</param>
public void TrySetState(StateParameter parameter, GameServer server, Player sender)
{
if (parameter.Name == Names.NUM_INIT_CARDS && parameter.ParameterType == StateParameter.Type.Int && sender.IsHost)
{
server.GameState.Set(Names.NUM_INIT_CARDS, parameter.GetValueInt(), true);
}
}
private void StartMultipleMode()
{
if (client.Player.IsHost)
{
if (client.ConnectedServer == null)
{
MessageBox.Show("Error, client not connected to local server");
}
else
{
if (views.Count > 1)
{
var numCards = rbn20Cards.Checked ? 20 : rbn52Cards.Checked ? 52 : 36;
if (numCards / views.Count >= 6)
{
client.RequestState(StateParameter.Construct(Names.AMOUNT_INIT_CARDS, numCards, true));
client.RequestStart();
}
else
{
MessageBox.Show("You do not have enough cards for that number of players\nPlease ensure theres at least enough cards for 6 cards per player", "Alert", MessageBoxButtons.OK);
}
}
else
{
MessageBox.Show("You need at least 2 players to play", "Alert", MessageBoxButtons.OK);
}
}
}
}
/// <summary>
/// 判断技能是否使用完毕，有连招的会继续使用连招。
/// </summary>
/// <param name="actor">角色对象。</param>
/// <param name="skillid">技能编号。</param>
/// <returns>是否使用完毕。</returns>
public static bool IsCastSkillOver(ActorObj actor, int skillid)
{
if (actor.curActorState != ACTOR_STATE.AS_ATTACK)
{
return(true);
}
//如果在攻击状态没有动作，则视为技能施放完毕
if (actor.GetComponent <Animation>().isPlaying == false && actor.m_bIsTower == false)
{
return(true);
}
//判断连招，是否组合技能
ComposeSkillDesc desc = CoreEntry.gGameDBMgr.GetComposeSkillDesc(actor.curCastSkillID, skillid);
if (desc != null)
{
StateParameter param = new StateParameter();
param.state = ACTOR_STATE.AS_ATTACK;
param.skillID = skillid;
param.isComposeSkill = true;
param.composeSkillDesc = desc;
//请求连招切换，能连招则认为此技能结束了
bool bRet = actor.ComposeSkillCanCastSkill(param.composeSkillDesc.changeTime);
return(bRet);
}
return(false);
}
public static string ParameterToName(this StateParameter parameter)
{
switch (parameter)
{
case StateParameter.Idle:
return("Idle");
case StateParameter.SelectMove:
return("SelectMove");
case StateParameter.Pause:
return("Pause");
case StateParameter.Setting:
return("Setting");
case StateParameter.StartVacation:
return("StartVacation");
case StateParameter.Failure:
return("Failure");
case StateParameter.Victory:
return("Victory");
default:
DebugLogger.LogWarningFormat("StateParameterConverter::ParameterToName => 알 수 없는 매개변수 {0}이 주어졌습니다.", parameter);
return(string.Empty);
}
}
private void AttackingPlayersChanged(object sender, StateParameter p)
{
var attackingID = core.GameState.GetValueInt(Names.ATTACKING_PLAYER);
var defendingID = core.GameState.GetValueInt(Names.DEFENDING_PLAYER);
var attackingPlayer = core.ConnectedServer.Players[attackingID];
var defendingPlayer = core.ConnectedServer.Players[defendingID];
foreach (var pair in playerUIs)
{
if (pair.Value.Card != null)
{
pair.Value.Card.BackgroundImage =
pair.Key.ID == attackingID ? Properties.Resources.backAttacker
: pair.Key.ID == defendingID ? Properties.Resources.backDefender
: Properties.Resources.backThrower;
}
else if (pair.Value.SwordShieldDagger != null)
{
pair.Value.SwordShieldDagger.BackgroundImage =
pair.Key.ID == attackingID ? Properties.Resources.statusAttacker
: pair.Key.ID == defendingID ? Properties.Resources.statusDefender
: Properties.Resources.statusThrower;
}
if (pair.Value.Panel != null)
{
pair.Value.Panel.ShowBorder = false;
}
}
playerUIs[attackingPlayer].Panel.ShowBorder = true;
playerUIs[attackingPlayer].Panel.BorderColor = Color.Red;
playerUIs[defendingPlayer].Panel.ShowBorder = true;
playerUIs[defendingPlayer].Panel.BorderColor = Color.Blue;
}
public void TrySetState(StateParameter parameter, CoreDurakGame core, Player sender)
{
if (parameter.Name == Names.AMOUNT_INIT_CARDS && parameter.ParameterType == StateParameter.Type.Int && sender.IsHost)
{
core.GameState.Set(Names.AMOUNT_INIT_CARDS, parameter.GetValueInt(), true);
}
}
private void StartSingleMode()
{
if (singleServer.Player.IsHost)
{
if (singleServer.ConnectedServer == null)
{
MessageBox.Show("Error, client not connected to local server");
}
else
{
if (views.Count > 1)
{
var numCards = rbn20Cards.Checked ? 20 : rbn52Cards.Checked ? 52 : 36;
if (numCards / views.Count >= 6)
{
var parameter = StateParameter.Construct(Names.AMOUNT_INIT_CARDS, numCards, true);
singleServer.GameState.Set(Names.AMOUNT_INIT_CARDS, parameter.GetValueInt(), true);
singleServer.SetServerState(ServerState.InGame);
singleServer.SetBotSettings(chkSimulateBotThinkTime.Checked);
ServerStateUpdated(this, singleServer.ConnectedServer.State);
}
else
{
MessageBox.Show("You do not have enough cards for that number of players" +
"\nPlease ensure theres at least enough cards for 6 cards per player", "Alert", MessageBoxButtons.OK);
}
}
else
{
MessageBox.Show("You need at least 2 players to play", "Alert", MessageBoxButtons.OK);
}
}
}
}
/// <summary>
/// 立即切换根据当前状态是否切换成功
/// </summary>
/// <param name="name"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public bool ChangeStateImmediate(string name, StateParameter parameters)
{
if (ChangeState(name, parameters))
{
return(DoChangeState(name, parameters));
}
return(false);
}
public override void OnEnter(StateParameter parameters)
{
base.OnEnter(parameters);
param = (GameStateParam)parameters;
if (!string.IsNullOrEmpty(param.sceneName))
{
asyncOperation = SceneManager.LoadSceneAsync(param.sceneName);
}
}
public void RequestState(StateParameter parameter)
{
if (Player.IsHost)
{
lobbyWriter.Write((byte)NetMessageType.Data);
lobbyWriter.Write((byte)MessageType.RequestState);
parameter.Encode(lobbyWriter);
}
}
/// <summary>
/// Tries setting the requested state parameter
/// </summary>
/// <param name="parameter">The state parameter that is being requested</param>
/// <param name="server">The server to excecute on</param>
/// <param name="sender">The player that is requesting the state change</param>
public void TrySetState(StateParameter parameter, GameServer server, Player sender)
{
if (parameter.Name == Names.REQUEST_HELP && parameter.ParameterType == StateParameter.Type.Bool)
{
if (server.GameState.GetValueInt(Names.ATTACKING_PLAYER) == sender.PlayerId)
{
server.GameState.Set(Names.REQUEST_HELP, parameter.GetValueBool());
}
}
}
/// <summary>
/// Requests the server to set a state to a given value
/// </summary>
/// <param name="param">The parameter to request</param>
public void RequestState(StateParameter param)
{
if (IsConnected)
{
NetOutgoingMessage msg = myPeer.CreateMessage();
msg.Write((byte)MessageType.RequestState);
param.Encode(msg);
Send(msg);
}
}
/// <summary>
/// Handles the client requesting a state parameter to be set
/// </summary>
/// <param name="msg">The message to decode</param>
private void HandleGameStateRequest(NetIncomingMessage msg)
{
StateParameter parameter = StateParameter.CreateEmpty();
parameter.Decode(msg);
for (int index = 0; index < Rules.CLIENT_STATE_REQ_VALIDATORS.Count; index++)
{
Rules.CLIENT_STATE_REQ_VALIDATORS[index].TrySetState(parameter, this, myPlayers[msg.SenderConnection]);
}
}
/// <summary>
/// Invoked by game state when a parameter has changed
/// </summary>
/// <param name="sender">The object to invoke this method</param>
/// <param name="e">The event arguments</param>
private void MyGameState_OnStateChanged(object sender, StateParameter e)
{
if (myState == ServerState.InGame && e.IsSynced)
{
// Prepare the game state changed
NetOutgoingMessage msg = myServer.CreateMessage();
msg.Write((byte)MessageType.GameStateChanged);
e.Encode(msg);
// Send to all clients
SendToAll(msg);
}
}
private void ToggleState(StateParameter stateParameter, Action onTrueValue, Action onFalseValue)
{
bool value = stateAnimator.GetStateBool(stateParameter);
if (value)
{
onTrueValue();
}
else
{
onFalseValue();
}
}
public virtual void Update(float dt)
{
if (!string.IsNullOrEmpty(nextStateName))
{
DoChangeState(nextStateName, nextParameters);
nextStateName = null;
nextParameters = null;
}
if (curState != null)
{
curState.OnUpdate(dt);
}
}
/// <summary>
/// Requests that the game starts
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnStart_Click(object sender, EventArgs e)
{
if (myClient.IsHost)
{
if (myClient.ConnectedServer == null)
{
MessageBox.Show("Error, client not connected to local server");
}
else
{
if (myClient.KnownPlayers.PlayerCount > 1)
{
int numCards = 36;
if (rbn20Cards.Checked)
{
numCards = 20;
}
else if (rbn52Cards.Checked)
{
numCards = 52;
}
if (numCards / myClient.KnownPlayers.PlayerCount >= 6)
{
myClient.RequestBotSettings(chkSimulateBotThinkTime.Checked, 1000, 4000, Settings.Default.DefaultBotDifficulty);
myClient.RequestState(StateParameter.Construct <int>(Names.NUM_INIT_CARDS, numCards, true));
myClient.RequestStart();
}
else
{
MessageBox.Show("You do not have enough cards for that number of players\nPlease ensure theres at least enough cards for 6 cards per player", "Alert", MessageBoxButtons.OK);
}
}
else
{
MessageBox.Show("You need at least 2 players to play", "Alert", MessageBoxButtons.OK);
}
}
}
else
{
myViews.FirstOrDefault(X => X.Player.PlayerId == myClient.PlayerId).IsReady = true;
myClient.SetReadiness(true);
}
}
public virtual bool ChangeState(string name, StateParameter parameters)
{
bool isChange = true;
if (curState != null)
{
isChange = curState.CanChangeTo(name, parameters);
}
if (isChange)
{
nextParameters = parameters;
nextStateName = name;
}
return(isChange);
}
/// <summary>
/// Invoked when a state parameter has changed
/// </summary>
/// <param name="sender">The object to invoke the event (the GameState)</param>
/// <param name="e">The state parameter that has been updated</param>
private void StateChanged(object sender, StateParameter e)
{
bool exists = false;
for (int index = 0; index < dgvMainView.Rows.Count; index++)
{
if (dgvMainView.Rows[index].Cells[0].Value.Equals(e.Name))
{
dgvMainView.Rows[index].Cells[1].Value = e.RawValue;
exists = true;
break;
}
}
if (!exists)
{
dgvMainView.Rows.Add(e.Name, e.RawValue);
}
}
private void GameOver(object sender, StateParameter p)
{
var message = "Game Over!\n";
if (core.GameState.GetValueBool(Names.IS_TIE))
{
message += "It's a tie!";
}
else
{
Player durak = core.ConnectedServer.Players[core.GameState.GetValueInt(Names.LOSER_ID)];
message += durak.Name + " is the Durak";
}
message += "\nPress OK to exit to lobby";
MessageBox.Show(message, "Game over", MessageBoxButtons.OK);
Close();
}
public virtual bool DoChangeState(string name, StateParameter parameters)
{
if (string.IsNullOrEmpty(name) || !states.ContainsKey(name))
{
Debug.LogError("Error : C# StataMachine, states is exist， state name = " + name);
return(false);
}
StateBase stateBase = states[name];
// 退出
if (curState != null)
{
curState.OnExit(name);
}
curState = stateBase;
curState.OnEnter(parameters);
return(true);
}
private void Start(object parameter)
{
int check = StateParameter.GetValueAsInt();
if (check == 2)
{
Mediator.Instance.NotifyColleagues <object>("start", new Parameter("start", 1));
//Mediator.Instance.CommunicatorSend(new Parameter("start", 1));
}
else
{
if (check == 0)
{
Mediator.Instance.NotifyColleagues <object>("start", new Parameter("start", 1));
//Mediator.Instance.CommunicatorSend(new Parameter("start", 1));
}
else
{
Mediator.Instance.NotifyColleagues <object>("start", new Parameter("start", 2));
//Mediator.Instance.CommunicatorSend(new Parameter("start", 2));
}
}
}
/// <summary>
/// Invoked when the attacking or defending player has changed
/// </summary>
/// <param name="sender">The that raised the event (The GameState)</param>
/// <param name="p">The state parameter that was updated</param>
private void AttackingPlayersChanged(object sender, StateParameter p)
{
foreach (KeyValuePair <Player, PlayerUITag> pair in myPlayerUIs)
{
PlayerUITag tag = pair.Value;
if (tag.Panel != null)
{
tag.Panel.ShowBorder = false;
}
}
Player attackingPlayer = myClient.KnownPlayers[myClient.LocalState.GetValueByte(Names.ATTACKING_PLAYER)];
Player defendingPlayer = myClient.KnownPlayers[myClient.LocalState.GetValueByte(Names.DEFENDING_PLAYER)];
BorderPanel myAttackingPlayerContainer = myPlayerUIs[attackingPlayer].Panel;
BorderPanel myDefendingPlayerContainer = myPlayerUIs[defendingPlayer].Panel;
myAttackingPlayerContainer.ShowBorder = true;
myAttackingPlayerContainer.BorderColor = Color.Red;
myDefendingPlayerContainer.ShowBorder = true;
myDefendingPlayerContainer.BorderColor = Color.Blue;
}
/// <summary>
/// Invoked when the game is over
/// </summary>
/// <param name="sender">The that raised the event (The GameState)</param>
/// <param name="p">The state parameter that was updated</param>
private void GameOver(object sender, StateParameter p)
{
string message = "Game Over!\n";
if (myClient.LocalState.GetValueBool(Names.IS_TIE))
{
message += "It's a tie!";
}
else
{
Player durak = myClient.KnownPlayers[myClient.LocalState.GetValueByte(Names.LOSER_ID)];
message += durak.Name + " is the Durak";
}
message += myClient.IsHost ? "\nPress OK to exit to lobby" : "";
DialogResult result = MessageBox.Show(message, "Game over", MessageBoxButtons.OK);
if (myClient.IsHost && result == DialogResult.OK)
{
myClient.RequestServerState(ServerState.InLobby);
}
}
public static NetshResult SetFirewallState(ProfileParameter profile, StateParameter parameter)
{
return SetFirewallProperty(profile, "state", parameter.Value);
}
public static void SetStateTrigger(this Animator animator, StateParameter stateParameter)
{
animator.SetTrigger(stateParameter.ParameterToName());
}
/// <summary>
/// Invoked when the trump card has been picked up
/// </summary>
/// <param name="sender">The game state that invoked the event</param>
/// <param name="p">The state parameter that has been updated</param>
private void TrumpPickedUp(object sender, StateParameter p)
{
cbxTrump.Enabled = false;
}
public override void OnEnter(StateParameter parameters)
{
base.OnEnter(parameters);
}
public virtual bool CanChangeTo(string nextName, StateParameter parameters)
{
return(true);
}
public virtual void OnEnter(StateParameter parameters)
{
Debug.Log("STETE BASE =" + name);
}
/// <summary>
/// Invoked when the request help button is clicked
/// </summary>
/// <param name="sender">The object that raised the event (the button)</param>
/// <param name="e">The blank event arguments</param>
private void btnReqHelp_Click(object sender, EventArgs e)
{
StateParameter param = StateParameter.Construct <bool>(Names.REQUEST_HELP, !myClient.LocalState.GetValueBool(Names.REQUEST_HELP), true);
myClient.RequestState(param);
}
public Action(StateParameter parameter, ActionDirection direction)
{
Parameter = parameter;
Direction = direction;
}
