SquadService

Companion object SquadService

class SquadService extends Actor

Source: SquadService.scala

Linear Supertypes

Actor, AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

SquadService
Actor
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Instance Constructors

new SquadService()

Type Members

type Receive = PartialFunction[Any, Unit]
Definition Classes
Actor

Value Members

final def !=(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def ##: Int
Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean
Definition Classes
AnyRef → Any
def AddInvite(invitedPlayer: Long, invite: Invitation): Option[Invitation]
Assign a provided invitation object to either the active or inactive position for a player.

The determination for the active position is whether or not something is currently in the active position or whether some mechanism tried to shift invitation object into the active position but found nothing to shift.
Assign a provided invitation object to either the active or inactive position for a player.

The determination for the active position is whether or not something is currently in the active position or whether some mechanism tried to shift invitation object into the active position but found nothing to shift. If an invitation object originating from the reported player already exists, a new one is not appended to the inactive queue. This method should always be used as the entry point for the active and inactive invitation options or as a part of the entry point for the aforesaid options.
invitedPlayer
the unique character identifier for the player being invited; in actuality, represents the player who will address the invitation object
invite
the "new" invitation envelop object
returns
an optional invite; the invitation object in the active invite position; None, if it is not added to either the active option or inactive position
See also
AddInviteAndRespond
AltAddInviteAndRespond
def AddInviteAndRespond(invitedPlayer: Long, targetInvite: Invitation, invitingPlayer: Long, name: String): Unit
Enqueue a newly-submitted invitation object either as the active position or into the inactive positions and dispatch a response for any invitation object that is discovered.
Enqueue a newly-submitted invitation object either as the active position or into the inactive positions and dispatch a response for any invitation object that is discovered. Implementation of a workflow.
invitedPlayer
the unique character identifier for the player being invited; in actuality, represents the player who will address the invitation object
targetInvite
a comparison invitation object
invitingPlayer
the unique character identifier for the player who invited the former
name
a name to be used in message composition
See also
AddInvite
indirectInviteResp
def AddWaypoint(guid: PlanetSideGUID, waypointType: types.SquadWaypoints.Value, info: WaypointInfo): Option[WaypointData]
Display the indicated waypoint.

Despite the name, no waypoints are actually "added." All of the waypoints constantly exist as long as the squad to which they are attached exists.
Display the indicated waypoint.

Despite the name, no waypoints are actually "added." All of the waypoints constantly exist as long as the squad to which they are attached exists. They are merely "activated" and "deactivated."
guid
the squad's unique identifier
waypointType
the type of the waypoint
info
information about the waypoint, as was reported by the client's packet
returns
the waypoint data, if the waypoint type is changed
See also
SquadWaypointRequest
WaypointInfo
def AltAddInviteAndRespond(invitedPlayer: Long, targetInvite: Invitation, invitingPlayer: Long, name: String): Unit
Enqueue a newly-submitted invitation object either as the active position or into the inactive positions and dispatch a response for any invitation object that is discovered.
Enqueue a newly-submitted invitation object either as the active position or into the inactive positions and dispatch a response for any invitation object that is discovered. Implementation of a workflow.
invitedPlayer
the unique character identifier for the player being invited
targetInvite
a comparison invitation object
invitingPlayer
the unique character identifier for the player who invited the former
name
a name to be used in message composition
See also
AddInvite
altIndirectInviteResp
def CloseSquad(squad: Squad): Unit
All players are made to leave the squad and the squad will stop existing.
All players are made to leave the squad and the squad will stop existing. Any member of the squad missing an ActorRef object used to message the player's client will still leave the squad, but will not attempt to send feedback to the said unreachable client. If the player is in the process of unsubscribing from the service, the no-messaging pathway is useful to avoid accumulating dead letters.
squad
the squad
See also
Publish
RemoveAllInvitesToSquad
SquadDetail
TryResetSquadId
UpdateSquadList
def DisbandSquad(squad: Squad): Unit
All players are made to leave the squad and the squad will stop existing.
All players are made to leave the squad and the squad will stop existing. Essentially, perform the same operations as CloseSquad but treat the process as if the squad is being disbanded in terms of messaging.
squad
the squad
See also
PanicDisbandSquad
Publish
SquadResponse.Membership
def EnsureEmptySquad(charId: Long): Boolean
Determine whether a player is sufficiently unemployed and has no grand delusions of being a squad leader.
Determine whether a player is sufficiently unemployed and has no grand delusions of being a squad leader.
charId
the player
returns
true, if the target player possesses no squad or a squad that is suitably nonexistent; false, otherwise
See also
CloseSquad
def GetLeadingSquad(charId: Long, opt: Option[Squad]): Option[Squad]
If the player associated with this unique character identifier number is the leader of any squad, discover that squad.
If the player associated with this unique character identifier number is the leader of any squad, discover that squad.
charId
the potential member identifier
opt
an optional squad to check; the expectation is that the provided squad is a known participating squad
returns
the discovered squad, or None
See also
GetParticipatingSquad
Squad->Leader
def GetLeadingSquad(player: Player, opt: Option[Squad]): Option[Squad]
If this player is a member of any squad, discover that squad.
If this player is a member of any squad, discover that squad.
player
the potential member
opt
an optional squad to check; the expectation is that the provided squad is a known participating squad
returns
the discovered squad, or None
See also
GetParticipatingSquad
Squad::Leader
def GetNextSquadId(): PlanetSideGUID
Produce the next available unique squad identifier.
Produce the next available unique squad identifier. The first number is always 1. The greatest possible identifier is 65535 (an unsigned 16-bit integer) before it wraps back around to 1.
returns
the current squad unique identifier number
def GetParticipatingSquad(charId: Long): Option[Squad]
If the player associated with this unique character identifier number is a member of any squad, discover that squad.
If the player associated with this unique character identifier number is a member of any squad, discover that squad.
charId
the potential member identifier
returns
the discovered squad, or None
def GetParticipatingSquad(player: Player): Option[Squad]
If this player is a member of any squad, discover that squad.
If this player is a member of any squad, discover that squad.
player
the potential member
returns
the discovered squad, or None
def GetSquad(id: PlanetSideGUID): Option[Squad]
If a squad exists for an identifier, return that squad.
If a squad exists for an identifier, return that squad.
id
the squad unique identifier number
returns
the discovered squad, or None
def HandleRequestRole(bid: Invitation, guid: PlanetSideGUID, player: Player): Boolean
The functionality for handling indirection for handling one player requesting a specific squad role or when messaging the squad leader about an invite.

At this point in the squad join process, the only consent required is that of the squad leader.
The functionality for handling indirection for handling one player requesting a specific squad role or when messaging the squad leader about an invite.

At this point in the squad join process, the only consent required is that of the squad leader. An automatic consent flag exists on the squad; but, if that is not set, then the squad leader must be asked whether or not to accept or to reject the recruit. If the squad leader changes in the middle or the latter half of the process, the invitation may still fail even if the old squad leader accepts. If the squad leader changes in the middle of the latter half of the process, the inquiry might be posed again of the new squad leader, of whether to accept or to reject the recruit.
bid
the Invitation object that was the target of this request
guid
the unique squad identifier number
player
the player who wants to join the squad
returns
true, if the player is not denied the possibility of joining the squad; false, otherwise, of it the squad does not exist
def HandleRequestRole(bid: IndirectInvite, player: Player): Boolean
An overloaded entry point to the functionality for handling indirection when messaging the squad leader about an invite.
An overloaded entry point to the functionality for handling indirection when messaging the squad leader about an invite.
bid
a specific kind of Invitation object
player
the player who wants to join the squad
returns
true, if the player is not denied the possibility of joining the squad; false, otherwise, of it the squad does not exist
def HandleRequestRole(bid: RequestRole, player: Player): Boolean
An overloaded entry point to the functionality for handling one player requesting a specific squad role.
An overloaded entry point to the functionality for handling one player requesting a specific squad role.
bid
a specific kind of Invitation object
player
the player who wants to join the squad
returns
true, if the player is not denied the possibility of joining the squad; false, otherwise, of it the squad does not exist
def HandleVacancyInvite(squad: Squad, invitedPlayer: Long, invitingPlayer: Long, recruit: Player): Option[(Squad, Int)]
Resolve an invitation to a general, not guaranteed, position in someone else's squad.

Originally, the instigating type of invitation object was a "VacancyInvite" which indicated a type of undirected invitation extended from the squad leader to another player but the resolution is generalized enough to suffice for a number of invitation objects.
Resolve an invitation to a general, not guaranteed, position in someone else's squad.

Originally, the instigating type of invitation object was a "VacancyInvite" which indicated a type of undirected invitation extended from the squad leader to another player but the resolution is generalized enough to suffice for a number of invitation objects. First, an actual position is determined; then, the squad is tested for recruitment conditions, including whether the person who solicited the would-be member is still the squad leader. If the recruitment is manual and the squad leader is not the same as the recruiting player, then the real squad leader is sent an indirect query regarding the player's eligibility. These IndirectInvite invitation objects also are handled by calls to HandleVacancyInvite.
squad
the squad
invitedPlayer
the unique character identifier for the player being invited
invitingPlayer
the unique character identifier for the player who invited the former
recruit
the player being invited
returns
the squad object and a role position index, if properly invited; None, otherwise
See also
AltAddInviteAndRespond
IndirectInvite
SquadFeatures::AutoApproveInvitationRequests
VacancyInvite
def HandleVacancyInvite(squad_guid: PlanetSideGUID, invitedPlayer: Long, invitingPlayer: Long, recruit: Player): Option[(Squad, Int)]
Resolve an invitation to a general, not guaranteed, position in someone else's squad.
Resolve an invitation to a general, not guaranteed, position in someone else's squad. For the moment, just validate the provided parameters and confirm the eligibility of the user.
squad_guid
the unique squad identifier number
invitedPlayer
the unique character identifier for the player being invited
invitingPlayer
the unique character identifier for the player who invited the former
recruit
the player being invited
returns
the squad object and a role position index, if properly invited; None, otherwise
See also
VacancyInvite
def InitSquadDetail(guid: PlanetSideGUID, to: Iterable[Long], squad: Squad): Unit
Dispatch an intial message entailing the strategic information and the composition of this squad.
Dispatch an intial message entailing the strategic information and the composition of this squad. The details of the squad will be updated in full and be sent to all indicated observers.
guid
the unique squad identifier to be used when composing the details for this message
to
the unique character identifier numbers of the players who will receive this message
squad
the squad from which the squad details shall be composed
See also
SquadService.PublishFullDetails
def InitSquadDetail(squad: Squad): Unit
Dispatch a message entailing the composition of this squad.
Dispatch a message entailing the composition of this squad. This is considered the first time this information will be dispatched to any relevant observers so the details of the squad will be updated in full and be sent to all relevant observers, namely, all the occupants of the squad. External observers are ignored.
squad
the squad
See also
InitSquadDetail(PlanetSideGUID, Iterable[Long], Squad)
def InitWaypoints(toCharId: Long, guid: PlanetSideGUID): Unit
Dispatch all of the information about a given squad's waypoints to a user.
Dispatch all of the information about a given squad's waypoints to a user.
toCharId
the player to whom the waypoint data will be dispatched
guid
the squad's unique identifier
def InitialAssociation(squad: Squad): Unit
Pertains to the original message of squad synchronicity sent to the squad leader by the server under specific conditions.
Pertains to the original message of squad synchronicity sent to the squad leader by the server under specific conditions. The initial formation of a squad of two players is the most common expected situation. While the underlying flag is normally only set once, its state can be reset and triggered anew if necessary.
squad
the squad
See also
Publish
ResetAll
SquadResponse.AssociateWithSquad
SquadResponse.Detail
SquadService.PublishFullDetails
def InviteResponseTemplate(indirectVacancyFunc: (IndirectInvite, Player, Long, Long, String) => Boolean)(targetInvite: Invitation, actualInvite: Option[Invitation], invitedPlayer: Long, invitingPlayer: Long, name: String): Unit
A branched response for processing (new) invitation objects that have been submitted to the system.

A comparison is performed between the original invitation object and an invitation object that represents the potential modification or redirection of the current active invitation obect.
A branched response for processing (new) invitation objects that have been submitted to the system.

A comparison is performed between the original invitation object and an invitation object that represents the potential modification or redirection of the current active invitation obect. Any further action is only performed when an "is equal" comparison is true. When passing, the system publishes up to two messages to users that would anticipate being informed of squad join activity.
indirectVacancyFunc
the method that cans the respondign behavior should an IndirectVacancy object being consumed
targetInvite
a comparison invitation object; represents the unmodified, unadjusted invite
actualInvite
a comparaison invitation object; proper use of this field should be the output of another process upon the following actualInvite
invitedPlayer
the unique character identifier for the player being invited in actuality, represents the player who will address the invitation object
invitingPlayer
the unique character identifier for the player who invited the former
name
a name to be used in message composition
def JoinByCharacterId(charId: String, sender: ActorRef): Unit
def JoinByFaction(faction: String, sender: ActorRef): Unit
def JoinSquad(player: Player, squad: Squad, position: Int): Boolean
Behaviors and exchanges necessary to complete the fulfilled recruitment process for the squad role.

This operation is fairly safe to call whenever a player is to be inducted into a squad.
Behaviors and exchanges necessary to complete the fulfilled recruitment process for the squad role.

This operation is fairly safe to call whenever a player is to be inducted into a squad. The aforementioned player must have a callback retained in UserEvents and conditions imposed by both the role and the player must be satisfied.
player
the new squad member; this player is NOT the squad leader
squad
the squad the player is joining
position
the squad member role that the player will be filling
returns
true, if the player joined the squad in some capacity; false, if the player did not join the squad or is already a squad member
See also
InitialAssociation
InitSquadDetail
InitWaypoints
Publish
RemoveAllInvitesWithPlayer
SquadDetail
SquadInfo
SquadPositionDetail
SquadPositionEntry
SquadResponse.Join
StatConverter.Health
UpdateSquadListWhenListed
def LeaveByCharacterId(charId: String, sender: ActorRef): Unit
def LeaveByFaction(faction: String, sender: ActorRef): Unit
def LeaveInGeneral(sender: ActorRef): Unit
def LeaveService(charId: Long, sender: ActorRef): Unit
na
na
charId
the player's unique character identifier number
sender
the ActorRef associated with this character
def LeaveService(charId: String, sender: ActorRef): Unit
na
na
charId
the player's unique character identifier number
sender
the ActorRef associated with this character
def LeaveSquad(charId: Long, squad: Squad): Boolean
Behaviors and exchanges necessary to undo the recruitment process for the squad role.
Behaviors and exchanges necessary to undo the recruitment process for the squad role.
charId
the player
squad
the squad
returns
true, if the player, formerly a normal member of the squad, has been ejected from the squad; false, otherwise
See also
PanicLeaveSquad
Publish
def NextInvite(invitedPlayer: Long): Option[Invitation]
Select the next invitation object to be shifted into the active position.

The determination for the active position is whether or not something is currently in the active position or whether some mechanism tried to shift invitation object into the active position but found nothing to shift.
Select the next invitation object to be shifted into the active position.

The determination for the active position is whether or not something is currently in the active position or whether some mechanism tried to shift invitation object into the active position but found nothing to shift. After handling of the previous invitation object has completed or finished, the temporary block on adding new invitations is removed and any queued inactive invitation on the head of the inactive queue is shifted into the active position.
invitedPlayer
the unique character identifier for the player being invited; in actuality, represents the player who will address the invitation object
returns
an optional invite; the invitation object in the active invite position; None, if not shifted into the active position
See also
NextInviteAndRespond
def NextInviteAndRespond(invitedPlayer: Long): Unit
Select the next invitation object to be shifted into the active position and dispatch a response for any invitation object that is discovered.
Select the next invitation object to be shifted into the active position and dispatch a response for any invitation object that is discovered.
invitedPlayer
the unique character identifier for the player being invited; in actuality, represents the player who will address the invitation object
returns
an optional invite; the invitation object in the active invite position; None, if not shifted into the active position
See also
InviteResponseTemplate
NextInvite
def PanicDisbandSquad(squad: Squad, membership: Iterable[Long]): Unit
All players are made to leave the squad and the squad will stop existing.

The complement of the prior DisbandSquad method.
All players are made to leave the squad and the squad will stop existing.

The complement of the prior DisbandSquad method. This method deals entirely with other squad members observing the squad become abandoned. The distinction is useful when unsubscribing from this service, as the ActorRef object used to message the player's client is no longer reliable and has probably ceased to exist.
squad
the squad
membership
the unique character identifier numbers of the other squad members
returns
if a role/index pair is provided
See also
CloseSquad
DisbandSquad
Publish
SquadResponse.Membership
def PanicLeaveSquad(charId: Long, squad: Squad, entry: Option[(Member, Int)]): Boolean
Behaviors and exchanges necessary to undo the recruitment process for the squad role.

The complement of the prior LeaveSquad method.
Behaviors and exchanges necessary to undo the recruitment process for the squad role.

The complement of the prior LeaveSquad method. This method deals entirely with other squad members observing the given squad member leaving the squad while the other method handles messaging only for the squad member who is leaving. The distinction is useful when unsubscribing from this service, as the ActorRef object used to message the player's client is no longer reliable and has probably ceased to exist.
charId
the player
squad
the squad
entry
a paired membership role with its index in the squad
returns
if a role/index pair is provided
See also
LeaveSquad
Publish
SquadDetail
SquadInfo
SquadPositionDetail
SquadPositionEntry
SquadResponse.Leave
UpdateSquadDetail
UpdateSquadListWhenListed
def Publish[ANY >: Any](to: ANY, msg: Response, excluded: Iterable[Long]): Unit
Overloaded message-sending operation.
Overloaded message-sending operation. No message can be sent using this distinction. Log a warning.
to
something that was expected to be used as the channel for the message but is not handled as such
msg
a message that can be stored in a SquadServiceResponse object
excluded
a group of character identifier numbers who should not receive the message
def Publish[ANY >: Any](to: ANY, msg: Response): Unit
Overloaded message-sending operation.
Overloaded message-sending operation. No message can be sent using this distinction. Log a warning.
to
something that was expected to be used as the channel for the message but is not handled as such
msg
a message that can be stored in a SquadServiceResponse object
def Publish(to: Long, msg: Response, excluded: Iterable[Long]): Unit
Overloaded message-sending operation.
Overloaded message-sending operation. Always publishes on the ActorRef objects retained by the UserEvents object.
to
a unique character identifier used as the channel for the message
msg
a message that can be stored in a SquadServiceResponse object
excluded
a group of character identifier numbers who should not receive the message
def Publish(to: Long, msg: Response): Unit
Overloaded message-sending operation.
Overloaded message-sending operation. Always publishes on the ActorRef objects retained by the UserEvents object.
to
a unique character identifier used as the channel for the message
msg
a message that can be stored in a SquadServiceResponse object
def Publish(to: String, msg: Response, excluded: Iterable[Long]): Unit
Overloaded message-sending operation.
Overloaded message-sending operation. Strings come in three accepted patterns. The first resolves into a faction name, as determined by PlanetSideEmpire when transformed into a string. The second resolves into a squad's dedicated channel, a name that is formulaic. The third resolves as a unique character identifier number.
to
a string used as the channel for the message
msg
a message that can be stored in a SquadServiceResponse object
excluded
a group of character identifier numbers who should not receive the message (resolved at destination, usually)
def Publish(to: String, msg: Response): Unit
Overloaded message-sending operation.
Overloaded message-sending operation. Strings come in three accepted patterns. The first resolves into a faction name, as determined by PlanetSideEmpire when transformed into a string. The second resolves into a squad's dedicated channel, a name that is formulaic. The third resolves as a unique character identifier number.
to
a string used as the channel for the message
msg
a message that can be stored in a SquadServiceResponse object
def Publish(to: Type, msg: Response, excluded: Iterable[Long]): Unit
Overloaded message-sending operation.
Overloaded message-sending operation. Always publishes on the SquadEvents object.
to
a faction affiliation used as the channel for the message
msg
a message that can be stored in a SquadServiceResponse object
excluded
a group of character identifier numbers who should not receive the message (resolved at destination)
def Publish(to: Type, msg: Response): Unit
Overloaded message-sending operation.
Overloaded message-sending operation. Always publishes on the SquadEvents object.
to
a faction affiliation used as the channel for the message
msg
a message that can be stored in a SquadServiceResponse object
def Publish(to: ActorRef, msg: Response, excluded: Iterable[Long]): Unit
Overloaded message-sending operation.
Overloaded message-sending operation. The Actor version wraps around the expected ! functionality.
to
an ActorRef which to send the message
msg
a message that can be stored in a SquadServiceResponse object
excluded
a group of character identifier numbers who should not receive the message (resolved at destination)
def Publish(to: ActorRef, msg: Response): Unit
Overloaded message-sending operation.
Overloaded message-sending operation. The Actor version wraps around the expected ! functionality.
to
an ActorRef which to send the message
msg
a message that can be stored in a SquadServiceResponse object
def PublishedLists(guids: Iterable[PlanetSideGUID]): Vector[SquadInfo]
Transform a list of squad unique identifiers into a list of SquadInfo objects for updating the squad list window.
Transform a list of squad unique identifiers into a list of SquadInfo objects for updating the squad list window.
guids
the list of squad unique identifier numbers
returns
a Vector of transformed squad data
def PublishedLists(faction: Type): Vector[SquadInfo]
Transform a list of squad unique identifiers into a list of SquadInfo objects for updating the squad list window.
Transform a list of squad unique identifiers into a list of SquadInfo objects for updating the squad list window.
faction
the faction to which the squads belong
returns
a Vector of transformed squad data
def Refused(charId: Long, list: List[Long]): List[Long]
This player has refused to join squad leader's squads or some other players's offers to form a squad.
This player has refused to join squad leader's squads or some other players's offers to form a squad.
charId
the player who is doing the refusal
list
the players who are refused
returns
the list of other players who have been refused
def Refused(charId: Long, refusedCharId: Long): List[Long]
This player has refused to join squad leader's squads or some other players's offers to form a squad.
This player has refused to join squad leader's squads or some other players's offers to form a squad.
charId
the player who is doing the refusal
refusedCharId
the player who is refused
returns
the list of other players who have been refused
def Refused(charId: Long): List[Long]
This player has refused to join squad leader's squads or some other players's offers to form a squad.
This player has refused to join squad leader's squads or some other players's offers to form a squad.
charId
the player who refused other players
returns
the list of other players who have been refused
def RemoveAllInvitesToSquad(sguid: PlanetSideGUID): Unit
Remove all active and inactive invitation objects that are related to the particular squad.
Remove all active and inactive invitation objects that are related to the particular squad. Specifically used to safely disarm obsolete invitation objects by specific criteria. Affects all invitation object types and all data structures that deal with the squad.
sguid
the squad identifier
See also
RequestRole
IndirectInvite
LookingForSquadRoleInvite
ProximityInvite
RemoveInvite
VacancyInvite
def RemoveAllInvitesWithPlayer(charId: Long): Unit
Remove all active and inactive invitation objects that are related to the particular player.
Remove all active and inactive invitation objects that are related to the particular player. Specifically used to safely disarm obsolete invitation objects by specific criteria. Affects all invitation object types and all data structures that deal with the player.
charId
the player's unique identifier number
See also
RequestRole
IndirectInvite
LookingForSquadRoleInvite
RemoveInvite
RemoveProximityInvites
VacancyInvite
def RemoveInvite(invitedPlayer: Long): Option[Invitation]
Remove any invitation object from the active position.
Remove any invitation object from the active position. Flag the temporary field to indicate that the active position, while technically available, should not yet have a new invitation object shifted into it yet. This is the "proper" way to demote invitation objects from the active position whether or not they are to be handled.
invitedPlayer
the unique character identifier for the player being invited; in actuality, represents the player who will address the invitation object
returns
an optional invite; the invitation object formerly in the active invite position; None, if no invitation was in the active position
See also
NextInvite
NextInviteAndRespond
def RemoveInvitesForSquadAndPosition(guid: PlanetSideGUID, position: Int): Unit
Remove all active invitation objects that are related to the particular squad and the particular role in the squad.
Remove all active invitation objects that are related to the particular squad and the particular role in the squad. Specifically used to safely disarm obsolete invitation objects related to the specific criteria. Affects only certain invitation object types.
guid
the squad identifier
position
the role position index
See also
RequestRole
LookingForSquadRoleInvite
RemoveInvite
RemoveQueuedInvitesForSquadAndPosition
def RemoveProximityInvites(guid: PlanetSideGUID): Iterable[(Long, String)]
Remove all active and inactive proximity squad invites for a specific squad.
Remove all active and inactive proximity squad invites for a specific squad.
guid
the squad
returns
a list of all players (unique character identifier number and name) who had active proximity invitations
def RemoveProximityInvites(list: Iterable[(Long, PlanetSideGUID)]): Unit
Remove all queued proximity squad invite information retained by the squad object.
Remove all queued proximity squad invite information retained by the squad object.
list
a list of players to squads with expected entry redundancy
See also
RemoveProximityInvites(Long)
SquadFeatures.ProxyInvites
SquadFeatures.SearchForRole
def RemoveProximityInvites(invitingPlayer: Long): Iterable[(Long, String)]
Remove all active and inactive proximity squad invites related to the recruiter.
Remove all active and inactive proximity squad invites related to the recruiter.
invitingPlayer
the player who did the recruiting
returns
a list of all players (unique character identifier number and name) who had active proximity invitations
See also
RemoveProximityInvites(Iterable[(Long, PlanetSideGUID)])
def RemoveQueuedInvites(invitedPlayer: Long): List[Invitation]
Remove all inactive invites.
Remove all inactive invites.
invitedPlayer
the unique character identifier for the player being invited; in actuality, represents the player who will address the invitation object
returns
a list of the removed inactive invitation objects
def RemoveQueuedInvitesForSquadAndPosition(guid: PlanetSideGUID, position: Int): Unit
Remove all inactive invitation objects that are related to the particular squad and the particular role in the squad.
Remove all inactive invitation objects that are related to the particular squad and the particular role in the squad. Specifically used to safely disarm obsolete invitation objects by specific criteria. Affects only certain invitation object types.
guid
the squad identifier
position
the role position index
See also
RequestRole
LookingForSquadRoleInvite
RemoveInvitesForSquadAndPosition
def RemoveWaypoint(guid: PlanetSideGUID, waypointType: types.SquadWaypoints.Value): Unit
Hide the indicated waypoint.
Hide the indicated waypoint. Unused waypoints are marked by having a non-zero z-coordinate.

Despite the name, no waypoints are actually "removed." All of the waypoints constantly exist as long as the squad to which they are attached exists. They are merely "activated" and "deactivated."
guid
the squad's unique identifier
waypointType
the type of the waypoint
def SquadActionDefinition(tplayer: Player, zone: Zone, guid: PlanetSideGUID, line: Int, action: packet.game.SquadAction, sendTo: ActorRef): Unit
def SquadActionDefinitionAddSquadMemberPosition(tplayer: Player, lSquadOpt: Option[Squad], position: Int): Unit
def SquadActionDefinitionAssignSquadMemberToRole(squad: Squad, guid: PlanetSideGUID, char_id: Long, position: Int): Unit
the following action can be performed by ???
def SquadActionDefinitionAutoApproveInvitationRequests(tplayer: Player, lSquadOpt: Option[Squad], state: Boolean): Unit
def SquadActionDefinitionCancelFind(lSquadOpt: Option[Squad]): Unit
def SquadActionDefinitionCancelSelectRoleForYourself(tplayer: Player, guid: PlanetSideGUID): Unit
the following action can be performed by anyone who has tried to join a squad
def SquadActionDefinitionChangeSquadMemberRequirementsCertifications(tplayer: Player, lSquadOpt: Option[Squad], position: Int, certs: Set[Certification]): Unit
def SquadActionDefinitionChangeSquadMemberRequirementsDetailedOrders(tplayer: Player, lSquadOpt: Option[Squad], position: Int, orders: String): Unit
def SquadActionDefinitionChangeSquadMemberRequirementsRole(tplayer: Player, lSquadOpt: Option[Squad], position: Int, role: String): Unit
def SquadActionDefinitionChangeSquadPurpose(tplayer: Player, lSquadOpt: Option[Squad], purpose: String): Unit
def SquadActionDefinitionChangeSquadZone(tplayer: Player, lSquadOpt: Option[Squad], zone_id: PlanetSideZoneID, sendTo: ActorRef): Unit
def SquadActionDefinitionCloseSquadMemberPosition(tplayer: Player, lSquadOpt: Option[Squad], position: Int): Unit
def SquadActionDefinitionDeleteSquadFavorite(tplayer: Player, line: Int, sendTo: ActorRef): Unit
def SquadActionDefinitionDisplaySquad(tplayer: Player, guid: PlanetSideGUID, sendTo: ActorRef): Unit
the following action can be performed by anyone
def SquadActionDefinitionFindLfsSoldiersForRole(tplayer: Player, zone: Zone, lSquadOpt: Option[Squad], position: Int): Unit
def SquadActionDefinitionLoadSquadFavorite(tplayer: Player, line: Int, pSquadOpt: Option[Squad], lSquadOpt: Option[Squad], sendTo: ActorRef): Unit
def SquadActionDefinitionLocationFollowsSquadLead(tplayer: Player, lSquadOpt: Option[Squad], state: Boolean): Unit
def SquadActionDefinitionRequestListSquad(tplayer: Player, lSquadOpt: Option[Squad], sendTo: ActorRef): Unit
def SquadActionDefinitionResetAll(lSquadOpt: Option[Squad]): Unit
def SquadActionDefinitionSaveSquadFavorite(tplayer: Player, line: Int, lSquadOpt: Option[Squad], sendTo: ActorRef): Unit
def SquadActionDefinitionSelectRoleForYourself(tplayer: Player, guid: PlanetSideGUID, position: Int): Unit
the following action can be performed by an unaffiliated player
def SquadActionDefinitionStopListSquad(tplayer: Player, lSquadOpt: Option[Squad], sendTo: ActorRef): Unit
def SquadActionInitCharId(tplayer: Player): Unit
def SquadActionMembershipAccept(tplayer: Player, invitedPlayer: Long): Unit
def SquadActionMembershipCancel(cancellingPlayer: Long): Unit
def SquadActionMembershipDisband(charId: Long): Unit
def SquadActionMembershipInvite(tplayer: Player, invitingPlayer: Long, _invitedPlayer: Long, invitedName: String): Unit
def SquadActionMembershipLeave(tplayer: Player, actingPlayer: Long, _leavingPlayer: Option[Long], name: String): Unit
def SquadActionMembershipPromote(promotingPlayer: Long, _promotedPlayer: Long, promotedName: String): Unit
def SquadActionMembershipProximityInvite(tplayer: Player, zone: Zone, invitingPlayer: Long): Unit
def SquadActionMembershipReject(tplayer: Player, rejectingPlayer: Long): Unit
def SquadActionUpdate(charId: Long, health: Int, maxHealth: Int, armor: Int, maxArmor: Int, pos: Vector3, zoneNumber: Int, sendTo: ActorRef): Unit
def SquadActionWaypoint(tplayer: Player, waypointType: types.SquadWaypoints.Value, info: Option[WaypointInfo]): Unit
def StartSquad(player: Player): Squad
Establish a new squad.
Establish a new squad. Create all of the support structures for the squad and link into them. At a minimum, by default, the squad needs a squad leader and a stronger, more exposed connection between the squad and leader needs to be recognized.

Usually, a squad is created by modifying some aspect of its necessary fields. The primary necessary fields required for a squad include the squad's task and the squad's zone of operation.
player
the player who would become the squad leader
returns
the squad that has been created
See also
GetNextSquadId
Squad
SquadFeatures
SquadFeatures::Start
def SwapMemberPosition(toMember: Member, fromMember: Member): Unit
Move one player into one squad role and, if encountering a player already recruited to the destination role, swap that other player into the first player's position.
Move one player into one squad role and, if encountering a player already recruited to the destination role, swap that other player into the first player's position. If no encounter, just blank the original role.
toMember
the squad role where the player is being placed
fromMember
the squad role where the player is being encountered; if a conflicting player is discovered, swap that player into fromMember
See also
AssignSquadMemberToRole
SelectRoleForYourself
def TerminatedBy(requestee: ActorRef): Unit
def TryResetSquadId(): Boolean
Set the unique squad identifier back to the start (1) if no squads are active and no players are logged on.
Set the unique squad identifier back to the start (1) if no squads are active and no players are logged on.
returns
true, if the identifier is reset; false, otherwise
def UpdateSquadDetail(guid: PlanetSideGUID, toGuid: PlanetSideGUID, excluding: Iterable[Long], details: SquadDetail): Unit
Send a message entailing some of the strategic information and the composition to the existing members of the squad.
Send a message entailing some of the strategic information and the composition to the existing members of the squad. Also send the same information to any users who are watching the squad, potentially for want to join it. The squad-specific message is contingent on finding the squad's features using the unique identifier number and, from that, reporting to the specific squad's messaging channel. Anyone watching the squad will always be updated the given details.
guid
the unique squad identifier number to be used for the squad detail message
toGuid
the unique squad identifier number indicating the squad broadcast channel name
excluding
the explicit unique character identifier numbers of individuals who should not receive the message
details
the squad details to be included in the message
See also
DisplaySquad
Publish
SquadDetail
SquadResponse.Detail
def UpdateSquadDetail(guid: PlanetSideGUID, details: SquadDetail): Unit
Send a message entailing some of the strategic information and the composition to the existing members of the squad.
Send a message entailing some of the strategic information and the composition to the existing members of the squad.
guid
the unique identifier number of the squad
details
the squad details to be included in the message
See also
SquadResponse.Detail
UpdateSquadDetail(PlanetSideGUID, PlanetSideGUID, List[Long], SquadDetail)
def UpdateSquadDetail(guid: PlanetSideGUID, squad: Squad): Unit
Send a message entailing the strategic information and the composition of the squad to the existing members of the squad.
Send a message entailing the strategic information and the composition of the squad to the existing members of the squad. Rather than using the squad's existing unique identifier number, a meaningful substitute identifier will be employed in the message. The "meaningful substitute" is usually PlanetSideGUID(0) which indicates the local non-squad squad data on the client of a squad leader.
squad
the squad
See also
SquadService.PublishFullDetails
UpdateSquadDetail(PlanetSideGUID, PlanetSideGUID, List[Long], SquadDetail)
def UpdateSquadDetail(squad: Squad): Unit
Send a message entailing the strategic information and the composition of the squad to the existing members of the squad.
Send a message entailing the strategic information and the composition of the squad to the existing members of the squad.
squad
the squad
See also
SquadService.PublishFullDetails
UpdateSquadDetail(PlanetSideGUID, PlanetSideGUID, List[Long], SquadDetail)
def UpdateSquadList(squad: Squad, changes: Option[SquadInfo]): Unit
Dispatch a message entailing the composition of this squad and focus on any specific aspects of it, purported as being changed recently.

What sort of message is dispatched is not only based on the input parameters but also on the state of previously listed squad information.
Dispatch a message entailing the composition of this squad and focus on any specific aspects of it, purported as being changed recently.

What sort of message is dispatched is not only based on the input parameters but also on the state of previously listed squad information. Listed squad information is queued when it is first published, organized first by faction affinity, then by chronology. The output is first determinate on whether the squad had previously been listed as available. If so, it will either update its data to all valid faction associated entities with the provided changed data; or, it will be removed from the list of available squads, if there is no provided change data. If the squad can not be found, the change data, whatever it is, is unimportant, and the squad will be listed in full for the first time.

When a squad is first introduced to the aforementioned list, thus first being published to all faction-associated parties, the entirety of the squad list for that faction will be updated in one go. It is not necessary to do this, but doing so saves index and unique squad identifier management at the cost of the size of the packet to be dispatched. When a squad is removed to the aforementioned list, the same process occurs where the full list for that faction affiliation is sent as an update. The procedure for updating individual squad fields is precise and targeted, and has been or should be prepared in advance by the caller to this method. As a consequence, when updating the entry for that squad, the information used as the update does not necessarily reflect the actual information currently in the squad.
squad
the squad
changes
the optional highlighted aspects of the squad; these "changes" do not have to reflect the actual squad but are related to the contents of the message
See also
SquadResponse.InitList
SquadResponse.UpdateList
SquadService.SquadList.Publish
def altIndirectInviteResp(invite: IndirectInvite, player: Player, invitedPlayer: Long, invitingPlayer: Long, name: String): Boolean
Component method used for the response behavior for processing the invitation object as an IndirectInvite object.
Component method used for the response behavior for processing the invitation object as an IndirectInvite object.
invite
the original invitation object that started this process
player
the target of the response and invitation
invitedPlayer
the unique character identifier for the player being invited in actuality, represents the player who will address the invitation object
invitingPlayer
the unique character identifier for the player who invited the former
name
a name to be used in message composition
returns
na
See also
HandleRequestRole
def aroundPostRestart(reason: Throwable): Unit
Attributes
protected[akka]
Definition Classes
Actor
Annotations
@InternalApi()
def aroundPostStop(): Unit
Attributes
protected[akka]
Definition Classes
Actor
Annotations
@InternalApi()
def aroundPreRestart(reason: Throwable, message: Option[Any]): Unit
Attributes
protected[akka]
Definition Classes
Actor
Annotations
@InternalApi()
def aroundPreStart(): Unit
Attributes
protected[akka]
Definition Classes
Actor
Annotations
@InternalApi()
def aroundReceive(receive: akka.actor.Actor.Receive, msg: Any): Unit
Attributes
protected[akka]
Definition Classes
Actor
Annotations
@InternalApi()
final def asInstanceOf[T0]: T0
Definition Classes
Any
def clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native()
implicit val context: ActorContext
Definition Classes
Actor
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable])
final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
def indirectInviteResp(invite: IndirectInvite, player: Player, invitedPlayer: Long, invitingPlayer: Long, name: String): Boolean
Component method used for the response behavior for processing the invitation object as an IndirectInvite object.
Component method used for the response behavior for processing the invitation object as an IndirectInvite object.
invite
the original invitation object that started this process
player
the target of the response and invitation
invitedPlayer
the unique character identifier for the player being invited; in actuality, represents the player who will address the invitation object; not useful here
invitingPlayer
the unique character identifier for the player who invited the former; not useful here
name
a name to be used in message composition; not useful here
returns
na
See also
HandleRequestRole
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
def postRestart(reason: Throwable): Unit
Definition Classes
Actor
Annotations
@throws(classOf[java.lang.Exception])
def postStop(): Unit
Definition Classes
SquadService → Actor
def preRestart(reason: Throwable, message: Option[Any]): Unit
Definition Classes
Actor
Annotations
@throws(classOf[java.lang.Exception])
def preStart(): Unit
Definition Classes
Actor
Annotations
@throws(classOf[java.lang.Exception])
def receive: Receive
Definition Classes
SquadService → Actor
implicit final val self: ActorRef
Definition Classes
Actor
final def sender(): ActorRef
Definition Classes
Actor
def supervisorStrategy: SupervisorStrategy
Definition Classes
Actor
final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
def toString(): String
Definition Classes
AnyRef → Any
def unhandled(message: Any): Unit
Definition Classes
Actor
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()

Packages

SquadService

Companion object SquadService

class SquadService extends Actor

Instance Constructors

Type Members

Value Members

Inherited from Actor

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

SquadService

Companion object SquadService

class SquadService extends Actor

Instance Constructors

Type Members

Value Members

Inherited from Actor

Inherited from AnyRef

Inherited from Any

Ungrouped

SquadService