// TODO : Target must not be optional
public void Send(GameObject srcObject, PacketStream data, SendTarget target = SendTarget.Self)
{
byte[] byteData = data.GetPacket().ToArray();
if (target == SendTarget.Self && srcObject.SubType != GameObjectSubType.Player)
{
ConsoleUtils.Write(ConsoleMsgType.Error, "Non-Player object trying to send packet to Self");
return;
}
else if (target == SendTarget.Self)
{
SendPacket((Player)srcObject, byteData);
}
uint rx = RegionMngr.GetRegionX(srcObject.Position.X);
uint ry = RegionMngr.GetRegionY(srcObject.Position.Y);
foreach (Player p in GObjectManager.Players.Values)
{
if (target == SendTarget.Area)
{
// If it's out of range
if (p.RegionX < rx - 3 || p.RegionX > rx + 3 ||
p.RegionY < ry - 3 || p.RegionY > ry + 3
)
{
continue;
}
}
SendPacket(p, byteData);
}
}
public async Task <Result <Sent> > Send(int orderId, SendTarget target, MessageType messageType)
{
try
{
var memberIds = await GetMembers(orderId, target);
if (memberIds.Length == 0)
{
return(SendErrors.NoMembersFound);
}
var content = GetMessageText(messageType);
var requests = memberIds.Select(memberId => new AddMessageRequest(content, memberId, orderId)).ToArray();
var success = await messagesService.AddMessages(requests);
if (!success)
{
return(SendErrors.FailedToAddMessages);
}
return(new Sent(memberIds, content));
}
catch (System.Exception ex)
{
throw;
}
}
byte[] PreparePacket(PacketBase packet, SendTarget type, ulong target, ulong[] targets, bool isBroadcast)
{
packet.Sender = MyAPIGateway.Multiplayer.MyId;
packet.ModId = _modId;
var res = packet.ToBinary();
if (!(packet is PacketProxy) && res.Length >= 1024 * 64)
{
MyAPIGateway.Parallel.Start(() =>
{
var pack = new PacketGZip
{
Data = res.Compress(),
Sender = packet.Sender,
ModId = _modId
};
switch (type)
{
case SendTarget.ToOthers:
SendMessageToOthers(pack);
break;
case SendTarget.ToOthersExcluding:
SendMessageToOthers(pack, targets);
break;
case SendTarget.ToServer:
SendMessageToServer(pack);
break;
case SendTarget.ToTarget:
SendMessageTo(pack, target);
break;
case SendTarget.ToTargets:
SendMessageTo(pack, targets);
break;
case SendTarget.Proxy:
SendMessageToServer(new PacketProxy {
Data = pack.ToBinary(), IsBroadcast = isBroadcast, Targets = targets
});
break;
default:
throw new Exception("WTF?");
}
});
return(null);
}
return(res);
}
async Task <int[]> GetMembers(int orderId, SendTarget target)
{
var order = await orderingService.GetOrder(orderId);
switch (target)
{
case OrderOpener _: return(new[] { order.RequestingMemberId });
case MemberTarget mt:
var unitId = mt.OrderSide == OrderSide.Lending ? order.LendingUnitId : order.RequestingUnitId;
var members = await orderingService.GetMembers(unitId, mt.Permission);
return(members.Select(a => a.Id).ToArray());
}
return(new int[0]);
}
//A slightly modified version of the virtual OnDoubleClick
public override void OnDoubleClick(Mobile from)
{
if (!this.IsChildOf(from.Backpack))
{
from.SendLocalizedMessage(501661); // That key is unreachable.
return;
}
Target t;
int number;
if (KeyValue != 0)
{
number = 501662; // What shall I use this key on?
t = new SendTarget(this);
from.SendLocalizedMessage(number);
from.Target = t;
}
}
private void SendRPC <T>(T data, SendTarget sendTargets = SendTarget.ToTarget) where T : MessageData
{
data.senderId = UserManager.Instance.userID;
string requestJsonString = MessageSenderUtil.Encode <T>(data);
RpcTarget target = RpcTarget.Others;
switch (sendTargets)
{
case SendTarget.ToAll:
target = RpcTarget.All;
break;
case SendTarget.ToOthers:
target = RpcTarget.Others;
break;
default:
target = RpcTarget.Others;
break;
}
pv?.RPC("RecvRPCData", target, requestJsonString, data.action);
}
//A slightly modified version of the virtual OnDoubleClick
public override void OnDoubleClick(Mobile from)
{
if (!this.IsChildOf(from.Backpack))
{
from.SendLocalizedMessage(501661); // That key is unreachable.
return;
}
Target t;
int number;
if (KeyValue != 0)
{
number = 501662; // What shall I use this key on?
t = new SendTarget(this);
from.SendLocalizedMessage(number);
from.Target = t;
}
}
public void SendBroadcastMessage <T>(T data, SendTarget sendTarget) where T : MessageData
{
messageSender.SendBroadcastMessage(SalinTokens.UserToken, data, sendTarget);
}
public void SendBroadcastMessage <T>(string userToken, T data, SendTarget sendTargets) where T : MessageData
{
SendRPC <T>(data, sendTargets);
}
public static void SendBroadcastMessage <T>(T data, SendTarget sendTarget = SendTarget.ToOthers) where T : MessageData
{
_multiplayManager.SendBroadcastMessage(data, sendTarget);
}
public MessageSendTarget()
{
SendTarget = SendTarget.Self;
}
