internal void HandleFlagGrab(ServerPlayer player, MsgGrabFlag message)
{
if (message == null || !player.CanDoPlayActions())
{
return;
}
int flagID = message.FlagData.FlagID;
FlagInstance candidateFlag = FindFlagByID(flagID);
if (candidateFlag == null || !candidateFlag.Grabable())
{
return;
}
float dist = Vector3F.Distance(player.Info.LastSentUpdate.Position, candidateFlag.Position);
if (false && dist > GetFlagGrabDistance(player))
{
return;
}
Logger.Log4("Player " + player.Callsign + " wants to grab flag " + candidateFlag.FlagID.ToString() + " " + candidateFlag.ToString());
GrantFlag(player, candidateFlag);
}
private void HandleDropFlag(NetworkMessage msg)
{
MsgDropFlag df = msg as MsgDropFlag;
var owner = PlayerList.GetPlayerByID(df.PlayerID);
FlagInstance flag = FindFlagByID(df.FlagID);
if (owner != null)
{
owner.SetFlag(null);
}
if (flag != null)
{
flag.Owner = null;
flag.Status = FlagStatuses.FlagInAir;
if (owner != null)
{
flag.CurrentPosition = owner.Position;
}
if (FlagDropped != null)
{
FlagDropped.Invoke(this, flag);
}
}
}
public void GroundFlag(FlagInstance flag, MsgFlagUpdate update = null)
{
bool send = update == null;
if (send)
{
update = new MsgFlagUpdate();
}
flag.Status = FlagStatuses.FlagOnGround;
flag.Position = flag.LandingPostion;
flag.LaunchPosition = flag.LandingPostion;
flag.InitalVelocity = 0;
if (update.FlagUpdates.Count > 10)
{
Players.SendToAll(update, false);
update = new MsgFlagUpdate();
}
update.FlagUpdates.Add(flag);
flag.DropStarted = double.MinValue;
if (send)
{
Players.SendToAll(update, false);
}
}
protected FlagInstance SetupNewFlag(FlagType flag, Vector3F location, bool spawnInAir)
{
FlagInstance inst = new FlagInstance();
inst.Flag = flag;
inst.Position = location;
inst.Owner = null;
inst.OwnerID = -1;
if (spawnInAir)
{
inst.Status = FlagStatuses.FlagComing;
ComputeFlagAdd?.Invoke(null, inst);
}
else
{
inst.Status = FlagStatuses.FlagOnGround;
}
inst.FlagID = GetNewFlagID();
if (inst.FlagID < 0)
{
return(null);
}
lock (ActiveFlags)
{
ActiveFlags.Add(inst.FlagID, inst);
WorldFlags.Add(inst.FlagID, inst);
}
Logger.Log3("Setup new flag " + inst.FlagID.ToString() + " of type " + flag.FlagAbbv);
return(inst);
}
protected FlagInstance CreateFlag(FlagUpdateData data)
{
FlagInstance inst = new FlagInstance();
inst.ID = data.FlagID;
inst.Flag = FlagTypeList.GetFromAbriv(data.Abreviation);
WorldFlags.Add(inst);
return(inst);
}
public bool SetFlag(FlagInstance flag)
{
if (flag == CurrentFlag)
{
return(false);
}
CurrentFlag = flag;
return(true);
}
private void HandleGrabFlag(NetworkMessage msg)
{
MsgGrabFlag gf = msg as MsgGrabFlag;
var owner = PlayerList.GetPlayerByID(gf.PlayerID);
FlagInstance flag = SetFlagUpdateData(gf.FlagData);
if (FlagGrabbed != null)
{
FlagGrabbed.Invoke(this, flag);
}
}
public bool GrantFlag(ServerPlayer player, FlagInstance flag)
{
if (flag.Owner != null || player.Info.CariedFlag != null)
{
return(false);
}
OnGrantFlag?.Invoke(player, flag);
FlagEventArgs args = new FlagEventArgs();
args.Player = player;
args.Flag = flag;
FlagPreGrab?.Invoke(this, args);
if (flag.Status == FlagStatuses.FlagNoExist)
{
return(false);
}
lock (ActiveFlags)
{
if (!args.Allow || flag.Owner != null)
{
return(false);
}
lock (WorldFlags)
WorldFlags.Remove(flag.FlagID);
lock (CarriedFlags)
CarriedFlags.Add(flag.FlagID, flag);
flag.Owner = player;
flag.Status = FlagStatuses.FlagOnTank;
flag.OwnerID = player.PlayerID;
}
FlagGrabbed?.Invoke(this, flag);
player.Info.CariedFlag = flag;
MsgGrabFlag grabMessage = new MsgGrabFlag();
grabMessage.PlayerID = player.PlayerID;
grabMessage.FlagData = flag;
Logger.Log2("Player " + player.Callsign + " granted flag " + flag.FlagID.ToString() + " " + flag.ToString());
Players.SendToAll(grabMessage, false);
return(true);
}
protected FlagInstance GetFlag(FlagUpdateData data)
{
FlagInstance inst = FindFlagByID(data.FlagID);
if (inst != null)
{
return(inst);
}
inst = new FlagInstance();
inst.ID = data.FlagID;
inst.Flag = FlagTypeList.GetFromAbriv(data.Abreviation);
WorldFlags.Add(inst);
return(inst);
}
public void StandardDrop(ServerPlayer player, FlagInstance flag)
{
flag.LaunchPosition = flag.Position + new Vector3F(0, 0, Cache.TankHeight);
float thrownAltitude = Cache.FlagAltitude;
if (flag.Flag == FlagTypeList.Shield)
{
thrownAltitude *= Cache.ShieldFlight;
}
// TODO, compute the intersection point
flag.FlightTime = 0;
if (player == null)
{
flag.FlightEnd = 2.0f * (float)Math.Sqrt(-2.0f * Cache.FlagAltitude / Cache.Gravity);
flag.InitalVelocity = -0.5f * Cache.Gravity * flag.FlightEnd;
flag.Status = FlagStatuses.FlagComing;
flag.LandingPostion = new Vector3F(flag.Position.X, flag.Position.Y, 0);
}
else if (flag.Endurance == FlagEndurances.FlagUnstable)
{
flag.FlightEnd = 2.0f * (float)Math.Sqrt(-2.0f * Cache.FlagAltitude / Cache.Gravity);
flag.InitalVelocity = -0.5f * Cache.Gravity * flag.FlightEnd;
flag.Status = FlagStatuses.FlagGoing;
flag.LandingPostion = new Vector3F(flag.Position.X, flag.Position.Y, flag.Position.Z + thrownAltitude);
}
else
{
float maxAltitude = flag.Position.Z + thrownAltitude;
float upTime = (float)Math.Sqrt(-2.0f * thrownAltitude / Cache.Gravity);
float downTime = (float)Math.Sqrt(-2.0f * (maxAltitude - flag.Position.Z) / Cache.Gravity);
flag.FlightEnd = upTime + downTime;
flag.InitalVelocity = -Cache.Gravity * upTime;
flag.Status = FlagStatuses.FlagInAir;
flag.LandingPostion = new Vector3F(flag.Position.X, flag.Position.Y, 0);
}
flag.DropStarted = GameTime.Now;
}
public FlagInstance AddFlag(FlagType flag, Vector3F location, bool spawnInAir)
{
FlagInstance inst = SetupNewFlag(flag, location, spawnInAir);
if (inst != null)
{
FlagAdded?.Invoke(this, inst);
}
MsgFlagUpdate upd = new MsgFlagUpdate();
upd.FlagUpdates.Add(inst);
Players.SendToAll(upd, false);
Logger.Log2("Added new flag " + inst.FlagID.ToString() + " of type " + flag.FlagAbbv);
return(inst);
}
protected FlagInstance SetFlagUpdateData(FlagUpdateData u)
{
bool created = false;
FlagInstance flag = FindFlagByID(u.FlagID);
if (flag == null)
{
created = true;
flag = CreateFlag(u);
}
flag.Status = u.Status;
flag.Endurance = u.Endurance;
var owner = PlayerList.GetPlayerByID(u.Owner);
flag.Owner = owner;
if (owner != null)
{
owner.SetFlag(flag);
}
flag.CurrentPosition = u.Postion;
flag.LastUpdatePostion = u.Postion;
flag.LaunchPosition = u.LaunchPosition;
flag.LandingPostion = u.LandingPostion;
flag.FlightTime = u.FlightTime;
flag.FlightEnd = u.FlightEnd;
flag.InitialVelocity = u.InitalVelocity;
if (created && FlagCreated != null)
{
FlagCreated.Invoke(this, flag);
}
else if (!created && FlagUpdated != null)
{
FlagUpdated.Invoke(this, flag);
}
return(flag);
}
public void DropFlag(ServerPlayer player)
{
if (player == null || player.Info.CariedFlag == null)
{
return;
}
if (player.Info.CariedFlag.Flag == FlagTypeList.Identify)
{
player.SendMessage(new MsgNearFlag()); // send them an empty ID message to clear out the display
}
FlagInstance flag = player.Info.CariedFlag;
ComputeFlagDrop?.Invoke(player, flag);
MsgDropFlag drop = new MsgDropFlag();
drop.FlagID = flag.FlagID;
drop.PlayerID = player.PlayerID;
drop.Data = flag;
player.Info.CariedFlag = null;
flag.Owner = null;
Players.SendToAll(drop, false);
lock (CarriedFlags)
{
if (CarriedFlags.ContainsKey(flag.FlagID))
{
CarriedFlags.Remove(flag.FlagID);
}
}
lock (WorldFlags)
WorldFlags.Add(flag.FlagID, flag);
FlagDropped?.Invoke(this, flag);
}
public void RemoveFlag(FlagInstance flag)
{
DropFlag(flag.Owner);
flag.Status = FlagStatuses.FlagNoExist;
lock (ActiveFlags)
{
ActiveFlags.Remove(flag.FlagID);
lock (WorldFlags)
{
if (WorldFlags.ContainsKey(flag.FlagID))
{
WorldFlags.Remove(flag.FlagID);
}
}
lock (CarriedFlags)
{
if (WorldFlags.ContainsKey(flag.FlagID))
{
WorldFlags.Remove(flag.FlagID);
}
}
}
MsgFlagUpdate upd = new MsgFlagUpdate();
upd.FlagUpdates.Add(flag);
Players.SendToAll(upd, false);
lock (EmptyFlagIDs)
EmptyFlagIDs.Add(flag.FlagID);
FlagRemoved?.Invoke(this, flag);
Logger.Log2("Removed flag " + flag.FlagID.ToString() + " of type " + flag.Flag.FlagAbbv);
}
public FlagInstance GetNearestFlag(Vector3F postion)
{
var flags = GetGroundFlags();
if (flags.Length == 0)
{
return(null);
}
FlagInstance nearest = null;
float dist = float.MaxValue;
foreach (var f in flags)
{
float d = Vector3F.DistanceSquared(postion, f.Position);
if (d < dist)
{
dist = d;
nearest = f;
}
}
return(nearest);
}
