PSForever/PSF-BotServer
1
0
Fork 0
mirror of https://github.com/2revoemag/PSF-BotServer.git synced 2026-07-15 16:34:39 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

/kick support; fixing a bug with the supplemental squad id

Browse source
This commit is contained in:
FateJH 2019-10-16 15:26:55 -04:00
parent 1f578c9e5d
commit 35a8d87941
2 changed files with 53 additions and 40 deletions
Download patch file Download diff file Expand all files Collapse all files

91
common/src/main/scala/services/teamwork/SquadService.scala
View file

@ -378,7 +378,7 @@ class SquadService extends Actor {
case Service.Leave(Some(char_id)) => LeaveService(char_id, sender) case Service.Leave(Some(char_id)) => LeaveService(char_id, sender)
case Service.Leave(None) | Service.LeaveAll() => UserEvents find { case(_, subscription) => subscription == sender} match { case Service.Leave(None) | Service.LeaveAll() => UserEvents find { case(_, subscription) => subscription.path.equals(sender.path)} match {
case Some((to, _)) => case Some((to, _)) =>
LeaveService(to, sender) LeaveService(to, sender)
case _ => ; case _ => ;
@ -414,14 +414,17 @@ class SquadService extends Actor {
//this is just busy work; for actual joining operations, see SquadRequestType.Accept //this is just busy work; for actual joining operations, see SquadRequestType.Accept
(if(invitedName.nonEmpty) { (if(invitedName.nonEmpty) {
//validate player with name exists //validate player with name exists
LivePlayerList.WorldPopulation({ case (_, a : Avatar) => a.name == invitedName }).headOption match { LivePlayerList.WorldPopulation({ case (_, a : Avatar) => a.name.equalsIgnoreCase(invitedName) && a.faction == tplayer.Faction }).headOption match {
case Some(player) => UserEvents.keys.find(_ == player.CharId) case Some(player) => UserEvents.keys.find(_ == player.CharId)
case None => None case None => None
} }
} }
else { else {
//validate player with id exists //validate player with id exists
UserEvents.keys.find(_ == _invitedPlayer) LivePlayerList.WorldPopulation({ case (_, a : Avatar) => a.CharId == _invitedPlayer && a.faction == tplayer.Faction }).headOption match {
case Some(player) => Some(_invitedPlayer)
case None => None
}
}) match { }) match {
case Some(invitedPlayer) => case Some(invitedPlayer) =>
(memberToSquad.get(invitingPlayer), memberToSquad.get(invitedPlayer)) match { (memberToSquad.get(invitingPlayer), memberToSquad.get(invitedPlayer)) match {
@ -738,44 +741,54 @@ class SquadService extends Actor {
} }
NextInviteAndRespond(invitedPlayer) NextInviteAndRespond(invitedPlayer)
case SquadAction.Membership(SquadRequestType.Leave, leavingPlayer, optionalPlayer, name, _) => case SquadAction.Membership(SquadRequestType.Leave, actingPlayer, _leavingPlayer, name, _) =>
GetParticipatingSquad(leavingPlayer) match { GetParticipatingSquad(actingPlayer) match {
case Some(squad) => case Some(squad) =>
val kickedPlayer = if(name.nonEmpty) { val leader = squad.Leader.CharId
(if(name.nonEmpty) {
//validate player with name //validate player with name
LivePlayerList.WorldPopulation({ case (_, a : Avatar) => a.name == name }).headOption match { LivePlayerList.WorldPopulation({ case (_, a : Avatar) => a.name.equalsIgnoreCase(name) }).headOption match {
case Some(player) => UserEvents.keys.find(_ == player.CharId) case Some(a) => UserEvents.keys.find(_ == a.CharId)
case None => None case None => None
} }
} }
else { else {
//validate player with id //validate player with id
optionalPlayer match { _leavingPlayer match {
case Some(id) => UserEvents.keys.find(_ == id) case Some(id) => UserEvents.keys.find(_ == id)
case None => None case None => None
} }
} }) match {
val leader = squad.Leader.CharId case out @ Some(leavingPlayer) if GetParticipatingSquad(leavingPlayer).contains(squad) => //kicked player must be in the same squad
if(leavingPlayer == leader || squad.Size == 2) { log.info(s"leader=$leader, acting=$actingPlayer, leaving=$leavingPlayer")
//squad leader is leaving his own squad, so it will be disbanded if(actingPlayer == leader) {
//alternately, squad is only composed of two people, so it will be closed-out when one of them leaves if(leavingPlayer == leader || squad.Size == 2) {
DisbandSquad(squad) //squad leader is leaving his own squad, so it will be disbanded
} //OR squad is only composed of two people, so it will be closed-out when one of them leaves
else { DisbandSquad(squad)
if(kickedPlayer.isEmpty || kickedPlayer.contains(leavingPlayer)) { }
//leaving the squad of own accord else {
LeaveSquad(tplayer.CharId, squad) //kicked by the squad leader
} Publish(leavingPlayer, SquadResponse.Membership(SquadResponseType.Leave, 0, 0, leavingPlayer, Some(leader), tplayer.Name, false, Some(None)))
else if(kickedPlayer.contains(leader)) { Publish(leader, SquadResponse.Membership(SquadResponseType.Leave, 0, 0, leader, Some(leavingPlayer), "", true, Some(None)))
//kicked by the squad leader squadFeatures(squad.GUID).Refuse = leavingPlayer
Publish(leavingPlayer, SquadResponse.Membership(SquadResponseType.Leave, 0, 0, leavingPlayer, Some(leader), tplayer.Name, false, Some(None))) LeaveSquad(leavingPlayer, squad)
Publish(leader, SquadResponse.Membership(SquadResponseType.Leave, 0, 0, leader, Some(leavingPlayer), "", true, Some(None))) }
squadFeatures(squad.GUID).Refuse = leavingPlayer }
LeaveSquad(leavingPlayer, squad) else if(leavingPlayer == actingPlayer) {
} if(squad.Size == 2) {
} //squad is only composed of two people, so it will be closed-out when one of them leaves
DisbandSquad(squad)
}
else {
//leaving the squad of own accord
LeaveSquad(actingPlayer, squad)
}
}
case None => case _ => ;
}
case _ => ;
} }
case SquadAction.Membership(SquadRequestType.Reject, rejectingPlayer, _, _, _) => case SquadAction.Membership(SquadRequestType.Reject, rejectingPlayer, _, _, _) =>
@ -2244,9 +2257,9 @@ class SquadService extends Actor {
.filterNot { case (member, _) => member.CharId == 0 } .filterNot { case (member, _) => member.CharId == 0 }
.toList .toList
.unzip { case (member, index) => (member.CharId, index) } .unzip { case (member, index) => (member.CharId, index) }
val toChannel = s"/${features.ToChannel}/Squad" val toChannel = features.ToChannel
memberCharIds.foreach { charId => memberCharIds.foreach { charId =>
SquadEvents.subscribe(UserEvents(charId), toChannel) SquadEvents.subscribe(UserEvents(charId), s"/$toChannel/Squad")
Publish(charId, Publish(charId,
SquadResponse.Join( SquadResponse.Join(
squad, squad,
@ -2262,29 +2275,29 @@ class SquadService extends Actor {
else { else {
//joining an active squad; everybody updates differently //joining an active squad; everybody updates differently
val updatedIndex = List(position) val updatedIndex = List(position)
val toChannel = s"/${features.ToChannel}/Squad" val toChannel = features.ToChannel
//new member gets full squad UI updates //new member gets full squad UI updates
Publish( Publish(
charId, charId,
SquadResponse.Join( SquadResponse.Join(
squad, squad,
squad.Membership position +: squad.Membership
.zipWithIndex .zipWithIndex
.collect({ case (member, index) if member.CharId > 0 => index }) .collect({ case (member, index) if member.CharId > 0 => index })
.filterNot(_== position) .filterNot(_ == position)
.toList :+ position, .toList,
toChannel toChannel
) )
) )
//other squad members see new member joining the squad //other squad members see new member joining the squad
Publish(features.ToChannel, SquadResponse.Join(squad, updatedIndex, "")) Publish(toChannel, SquadResponse.Join(squad, updatedIndex, ""))
InitWaypoints(charId, squad.GUID) InitWaypoints(charId, squad.GUID)
InitSquadDetail(squad.GUID, Seq(charId), squad) InitSquadDetail(squad.GUID, Seq(charId), squad)
UpdateSquadDetail( UpdateSquadDetail(
squad.GUID, squad.GUID,
SquadDetail().Members(List(SquadPositionEntry(position, SquadPositionDetail().CharId(charId).Name(player.Name)))) SquadDetail().Members(List(SquadPositionEntry(position, SquadPositionDetail().CharId(charId).Name(player.Name))))
) )
SquadEvents.subscribe(UserEvents(charId), toChannel) SquadEvents.subscribe(UserEvents(charId), s"/$toChannel/Squad")
} }
UpdateSquadListWhenListed(features, SquadInfo().Size(size)) UpdateSquadListWhenListed(features, SquadInfo().Size(size))
true true
@ -2378,7 +2391,7 @@ class SquadService extends Actor {
member.Name = "" member.Name = ""
member.CharId = 0 member.CharId = 0
//other squad members see the member leaving //other squad members see the member leaving
Publish(squadFeatures(squad.GUID).ToChannel, SquadResponse.Leave(squad, List(entry))) Publish(squadFeatures(squad.GUID).ToChannel, SquadResponse.Leave(squad, List(entry)), Seq(charId))
UpdateSquadListWhenListed(squadFeatures(squad.GUID), SquadInfo().Size(squad.Size)) UpdateSquadListWhenListed(squadFeatures(squad.GUID), SquadInfo().Size(squad.Size))
UpdateSquadDetail( UpdateSquadDetail(
squad.GUID, squad.GUID,

2
pslogin/src/main/scala/WorldSessionActor.scala
View file

@ -493,6 +493,7 @@ class WorldSessionActor extends Actor with MDCContextAware {
lfs = false lfs = false
//a finalization? what does this do? //a finalization? what does this do?
sendResponse(SquadDefinitionActionMessage(PlanetSideGUID(0), 0, SquadAction.Unknown(18))) sendResponse(SquadDefinitionActionMessage(PlanetSideGUID(0), 0, SquadAction.Unknown(18)))
squad_supplement_id = 0
updateSquad = NoSquadUpdates updateSquad = NoSquadUpdates
squadChannel = None squadChannel = None
case _ => case _ =>
@ -507,7 +508,6 @@ class WorldSessionActor extends Actor with MDCContextAware {
) )
} }
StopBundlingPackets() StopBundlingPackets()
squad_supplement_id = 0
case SquadResponse.AssignMember(squad, from_index, to_index) => case SquadResponse.AssignMember(squad, from_index, to_index) =>
//we've already swapped position internally; now we swap the cards //we've already swapped position internally; now we swap the cards