private void storeProposal(ProposalRequest request, LeaderState state)
{
if (!leadersOrReplicasAskedVoteForThisSlot(request.SlotNumber, state))
{
state.ProposalsBySlotId.Add(request.SlotNumber, request.Command);
}
}
void LeaderAction() // FSM 상태별 동작
{
switch (leaderstate)
{
case LeaderState.Wander:
if (GetComponent <Transform>().position.x == nvAgent.destination.x &&
GetComponent <Transform>().position.z == nvAgent.destination.z)
{
nvAgent.destination = p[Random.Range(0, 4)].position;
}
break;
case LeaderState.GoToGrass:
nvAgent.destination = Target.GetComponent <Transform>().position;
FoundGrass = false;
break;
case LeaderState.WaitEating:
waitingTime += Time.deltaTime;
if (waitingTime > 3)
{
waitingTime = 0;
Destroy(Target);
nvAgent.destination = p[Random.Range(0, 4)].position;
leaderstate = LeaderState.Wander;
}
break;
default:
break;
}
}
private void onBallotRejected(LeaderState state, SolicitateBallotResponse response)
{
updateBallotNumber(state, response);
clearState(state);
state.BallotStatus = BallotStatus.Rejected;
BallotRejected?.Invoke(this, EventArgs.Empty);
}
private void storePreviousAcceptedValuesFromAcceptors(LeaderState state, VoteResponse responseDecision)
{
if (responseDecision != null)
{
state.ValuesAcceptedByAcceptors.Add(responseDecision);
}
}
public static void Postfix(BlueprintKingdomEventBase __instance, ref LeaderState __result)
{
if (Settings.toggleIgnoreStartTaskRestrictions)
{
__result = new LeaderState(__instance.GetDefaultResolutionType());
}
}
private void sendRequestToAcceptors(LeaderState state, VoteRequest objMessage)
{
state.VoteRequestPendingDecisionPerSlot[objMessage.SlotNumber] = new List <MessageSender>();
foreach (MessageSender acceptor in state.Acceptors)
{
state.VoteRequestPendingDecisionPerSlot[objMessage.SlotNumber].Add(acceptor);
broker.SendMessage(acceptor.UniqueId, objMessage);
}
}
private void sendRequestToAcceptors(LeaderState state, SolicitateBallotRequest objMessage)
{
state.BallotRequestPendingDecisionByAcceptors.Clear();
foreach (MessageSender acceptor in state.Acceptors)
{
state.BallotRequestPendingDecisionByAcceptors.Add(acceptor);
broker.SendMessage(acceptor.UniqueId, objMessage);
}
}
private void onBallotApproved(LeaderState state, SolicitateBallotResponse response)
{
removeAcceptorFromWaitingQueue(state, response.MessageSender);
storePreviousAcceptedValuesFromAcceptors(state, response.Decision);
if (majorityOfAcceptorsReplied(state))
{
state.BallotStatus = BallotStatus.Adopted;
BallotApproved?.Invoke(this, EventArgs.Empty);
}
}
public IdleState(Model model, LeaderState state, Transform goal, float distToGoal, float critHealthAmount, int team, INode node)
{
_model = model;
_state = state;
_goal = goal;
_distToGoal = distToGoal;
_critHealthAmount = critHealthAmount;
_team = team;
_node = node;
}
void ILeaderElection.LeadershipChanged(LeaderState state)
{
if (State == state)
{
return;
}
_logger.LogDebug("Leadership state changed to: {state}.", state);
State = state;
LeadershipChange?.Invoke(this, state);
}
public void Execute(MessageStrategyExecuteArg <IMessage> obj)
{
if (!(obj.Message is ProposalRequest))
{
throw new MessageStrategyException("This strategy shouldn't be invoked with this message type");
}
ProposalRequest request = obj.Message as ProposalRequest;
LeaderState state = obj.RoleState as LeaderState;;
storeProposal(request, state);
OnProposalReceived?.Invoke(this, EventArgs.Empty);
}
public MoveState(MoveSetup mS, MoveRun mR, Model model, LeaderState state, Transform goal, float critHealthAmount, int team, float distToGoal, INode node)
{
_moveSetup += mS;
_moveRun += mR;
_model = model;
_state = state;
_goal = goal;
_critHealthAmount = critHealthAmount;
_team = team;
_distToGoal = distToGoal;
_node = node;
}
private async void LeadershipChanged(object?sender, LeaderState state)
{
if (state == LeaderState.Leader)
{
_logger.LogInformation("This instance was elected as leader, starting event queue.");
_services.EventQueue.ResourceEvent += OnResourceEvent;
await _services.EventQueue.Start();
return;
}
_logger.LogInformation(
"This instance has either resigned from leadership, was elected candidate or is shutting down. Stopping event queue.");
await _services.EventQueue.Stop();
_services.EventQueue.ResourceEvent -= OnResourceEvent;
}
void CheckLeaderState() // FSM 상태간의 전환
{
if (leaderstate == LeaderState.Wander &&
FoundGrass)
{
leaderstate = LeaderState.GoToGrass;
}
if (leaderstate == LeaderState.GoToGrass &&
GetComponent <Transform>().position.x == nvAgent.destination.x &&
GetComponent <Transform>().position.z == nvAgent.destination.z)
{
leaderstate = LeaderState.WaitEating;
}
if (leaderstate == LeaderState.WaitEating)
{
return;
}
}
public void Execute(MessageStrategyExecuteArg <IMessage> obj)
{
if (!(obj.Message is SolicitateBallotResponse))
{
throw new MessageStrategyException("This strategy shouldn't be invoked with this message type");
}
SolicitateBallotResponse response = obj.Message as SolicitateBallotResponse;
LeaderState state = obj.RoleState as LeaderState;
if (ballotIsApproved(state.BallotNumber, response.BallotNumber))
{
onBallotApproved(state, response);
}
else if (higherBallotHasBeenApproved(state.BallotNumber, response.BallotNumber))
{
onBallotRejected(state, response);
}
}
public void Execute(MessageStrategyExecuteArg <IMessage> obj)
{
if (!(obj.Message is VoteResponse))
{
throw new MessageStrategyException("This strategy shouldn't be invoked with this message type");
}
VoteResponse response = obj.Message as VoteResponse;
LeaderState state = obj.RoleState as LeaderState;
state.VoteRequestPendingDecisionPerSlot[response.SlotNumber].Remove(response.MessageSender);
if (isBallotValid(response.BallotNumber, state.BallotNumber))
{
if (isElected(response, state))
{
OnApprovalElected?.Invoke(this, response);
}
}
else
{
OnApprovalPreempted?.Invoke(this, EventArgs.Empty);
}
}
public void UpdateLeader(LeaderState newState)
{
if (curLeaderSprite == null)
{
curLeaderSprite = Instantiate(leaderSprite);
curLeaderSprite.enabled = false;
}
if (curLeaderState == LeaderState.none)
{
if (newState == LeaderState.necromancer)
{
curLeaderSprite.enabled = true;
curLeaderState = LeaderState.necromancer;
curLeaderSprite.sprite = necroSprite;
curLeaderSprite.transform.position = this.transform.position;
curLeaderSprite.transform.parent = this.GetComponentInParent <Tile>().transform;
}
else if (newState == LeaderState.taskmaster)
{
curLeaderSprite.enabled = true;
curLeaderState = LeaderState.taskmaster;
leaderDir = Vector2Int.up;
//leaderSprite = upLeader;
curLeaderSprite.sprite = upLeader;
curLeaderSprite.transform.position = this.transform.position;
curLeaderSprite.transform.parent = this.GetComponentInParent <Tile>().transform;
}
}
else if (curLeaderState == LeaderState.taskmaster && newState == LeaderState.taskmaster)
{
Debug.Log("Updating Existing taskmaster");
//Rotate in an infuriating fashion
leaderDir.Set(leaderDir.y, leaderDir.x);
if (leaderDir.x != 0)
{
leaderDir *= -1;
}
if (leaderDir == Vector2Int.right)
{
curLeaderSprite.sprite = rightLeader;
}
else if (leaderDir == Vector2Int.left)
{
curLeaderSprite.sprite = leftLeader;
}
else if (leaderDir == Vector2Int.up)
{
curLeaderSprite.sprite = upLeader;
}
else if (leaderDir == Vector2Int.down)
{
curLeaderSprite.sprite = downLeader;
}
}
else if (newState != curLeaderState)
{
curLeaderState = LeaderState.none;
curLeaderSprite.enabled = false;
UpdateLeader(newState);
}
}
private bool leadersOrReplicasAskedVoteForThisSlot(int requestSlotNumber, LeaderState state)
{
return(state.ProposalsBySlotId.ContainsKey(requestSlotNumber));
}
private bool majorityOfAcceptorsReplied(LeaderState state)
{
return(state.BallotRequestPendingDecisionByAcceptors.Count < state.Acceptors.Count / 2);
}
void ILeaderElection.LeadershipChanged(LeaderState state)
{
}
private void Awake()
{
_model = GetComponent <Model>();
_leaderState = GetComponent <LeaderState>();
_agentTheta = GetComponent <AgentTheta>();
}
private void removeAcceptorFromWaitingQueue(LeaderState state, MessageSender acceptor)
{
state.BallotRequestPendingDecisionByAcceptors.Remove(acceptor);
}
private bool isElected(VoteResponse response, LeaderState state)
{
return(state.VoteRequestPendingDecisionPerSlot[response.SlotNumber].Count < state.Acceptors.Count / 2);
}
private void clearState(LeaderState state)
{
state.BallotRequestPendingDecisionByAcceptors.Clear();
state.ValuesAcceptedByAcceptors.Clear();
}
private void updateBallotNumber(LeaderState state, SolicitateBallotResponse response)
{
state.BallotNumber = response.BallotNumber.Increment();
}
