/*
* Callback function getting called by the listener loop timer
*/
private void CheckListeners()
{
this.LogDebug(lang.GetMessage("debug_checklisteners", this, ""));
// Iterate over every configured listener
for (int i = 0; i < this.config_data.configured_listeners.Count; i++)
{
// Make sure listener is currently not blocked
if (!this.config_data.configured_listeners[i].IsBlocked())
{
// Check if broadcasters on the listeners configured frequency are currently active
var broadcasters = RFManager.GetBroadcasterList(this.config_data.configured_listeners[i].GetFrequency());
if (broadcasters.Count > 0)
{
this.Log(this.config_data.configured_listeners[i].GetMessage());
// Enable blocking for next loop(s) if configured
this.config_data.configured_listeners[i].EnableBlocking();
}
}
else
{
this.LogDebug(string.Format(lang.GetMessage("debug_listenerblocked", this, ""), this.config_data.configured_listeners[i].GetFrequency()));
}
}
}
public void ServerSetFrequency(BaseEntity.RPCMessage msg)
{
if (msg.player == null || !msg.player.CanBuild())
{
return;
}
if (base.GetOwnerPlayer() != msg.player)
{
return;
}
if (UnityEngine.Time.time < this.nextChangeTime)
{
return;
}
this.nextChangeTime = UnityEngine.Time.time + 2f;
int num = msg.read.Int32();
if (RFManager.IsReserved(num))
{
RFManager.ReserveErrorPrint(msg.player);
return;
}
RFManager.ChangeFrequency(this.frequency, num, this, false, base.IsOn());
this.frequency = num;
base.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
Item item = this.GetItem();
if (item != null)
{
item.MarkDirty();
}
}
public static void ChangeFrequency(
int oldFrequency,
int newFrequency,
IRFObject obj,
bool isListener,
bool isOn = true)
{
newFrequency = RFManager.ClampFrequency(newFrequency);
if (isListener)
{
RFManager.RemoveListener(oldFrequency, obj);
if (!isOn)
{
return;
}
RFManager.AddListener(newFrequency, obj);
}
else
{
RFManager.RemoveBroadcaster(oldFrequency, obj);
if (!isOn)
{
return;
}
RFManager.AddBroadcaster(newFrequency, obj);
}
}
void RfToolDisable(IPlayer player, string command, string[] args)
{
int frequency = 0;
// Check if player specified a frequency
if (args.Length != 1)
{
this.ReplyToPlayer(player, string.Format(lang.GetMessage("cmd_rftool.disable_help", this, player.Id), this.frequency_min, this.frequency_max));
return;
}
// Get & check frequency
frequency = this.GetFrequency(player, args);
if (frequency == 0)
{
return;
}
// Get all listeners for given frequency and disable them
var listeners = RFManager.GetListenList(frequency);
for (int i = 0; i < listeners.Count; i++)
{
listeners[i].RFSignalUpdate(false);
}
this.ReplyToPlayer(player, string.Format(lang.GetMessage("cmd_rftool.disable_success", this, player.Id), listeners.Count, frequency));
}
public void ServerSetFrequency(BaseEntity.RPCMessage msg)
{
if (msg.player == null || !msg.player.CanBuild())
{
return;
}
if (!this.playerUsable)
{
return;
}
if (UnityEngine.Time.time < this.nextChangeTime)
{
return;
}
this.nextChangeTime = UnityEngine.Time.time + 2f;
int num = msg.read.Int32();
if (RFManager.IsReserved(num))
{
RFManager.ReserveErrorPrint(msg.player);
return;
}
RFManager.ChangeFrequency(this.frequency, num, this, false, this.IsPowered());
this.frequency = num;
this.MarkDirty();
base.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
}
public static void MarkFrequencyDirty(int frequency)
{
frequency = RFManager.ClampFrequency(frequency);
List <IRFObject> broadcasterList = RFManager.GetBroadcasterList(frequency);
List <IRFObject> listenList = RFManager.GetListenList(frequency);
bool on = broadcasterList.Count > 0;
bool flag1 = false;
bool flag2 = false;
foreach (IRFObject rfObject1 in listenList)
{
if (!rfObject1.IsValidEntityReference <IRFObject>())
{
flag1 = true;
}
else
{
if (on)
{
on = false;
foreach (IRFObject rfObject2 in broadcasterList)
{
if (!rfObject2.IsValidEntityReference <IRFObject>())
{
flag2 = true;
}
else if ((double)Vector3.Distance(rfObject2.GetPosition(), rfObject1.GetPosition()) <= (double)rfObject2.GetMaxRange())
{
on = true;
break;
}
}
}
rfObject1.RFSignalUpdate(on);
}
}
if (flag1)
{
Debug.LogWarning((object)("Found null entries in the RF listener list for frequency " + (object)frequency + "... cleaning up."));
for (int index = listenList.Count - 1; index >= 0; --index)
{
if (listenList[index] == null)
{
listenList.RemoveAt(index);
}
}
}
if (!flag2)
{
return;
}
Debug.LogWarning((object)("Found null entries in the RF broadcaster list for frequency " + (object)frequency + "... cleaning up."));
for (int index = broadcasterList.Count - 1; index >= 0; --index)
{
if (broadcasterList[index] == null)
{
broadcasterList.RemoveAt(index);
}
}
}
internal void InternalSetPressed(bool pressed)
{
base.SetFlag(BaseEntity.Flags.On, pressed, false, true);
if (pressed)
{
RFManager.AddBroadcaster(this.frequency, this);
return;
}
RFManager.RemoveBroadcaster(this.frequency, this);
}
public static void RemoveListener(int frequency, IRFObject obj)
{
frequency = RFManager.ClampFrequency(frequency);
List <IRFObject> listenList = RFManager.GetListenList(frequency);
if (listenList.Contains(obj))
{
listenList.Remove(obj);
}
obj.RFSignalUpdate(false);
}
public static void RemoveBroadcaster(int frequency, IRFObject obj)
{
frequency = RFManager.ClampFrequency(frequency);
List <IRFObject> broadcasterList = RFManager.GetBroadcasterList(frequency);
if (broadcasterList.Contains(obj))
{
broadcasterList.Remove(obj);
}
RFManager.MarkFrequencyDirty(frequency);
}
public void Start()
{
RFManagerReference = GameObject.Find("PrizmGameManager").GetComponent <RFManager> ();
socket = GetComponent <SocketIOComponent>();
socket.On("smarttouch-start", SmartTouch);
socket.On("smarttouch-end", SmartTouch);
//socket.On ("toTabletop", HHMessage);
//player = GameObject.Find ("Player").GetComponent<PlayerHandler>();
gameManager = GameObject.Find("GameManager").GetComponent <GameManager> ();
}
public override void IOStateChanged(int inputAmount, int inputSlot)
{
if (inputAmount <= 0)
{
base.Invoke(new Action(this.StopBroadcasting), Mathf.Clamp01(this.nextStopTime - UnityEngine.Time.time));
return;
}
base.CancelInvoke(new Action(this.StopBroadcasting));
RFManager.AddBroadcaster(this.frequency, this);
base.SetFlag(BaseEntity.Flags.Reserved3, true, false, true);
this.nextStopTime = UnityEngine.Time.time + 1f;
}
public static List <IRFObject> GetListenList(int frequency)
{
frequency = RFManager.ClampFrequency(frequency);
List <IRFObject> rFObjects = null;
if (!RFManager._listeners.TryGetValue(frequency, out rFObjects))
{
rFObjects = new List <IRFObject>();
RFManager._listeners.Add(frequency, rFObjects);
}
return(rFObjects);
}
public static void AddBroadcaster(int frequency, IRFObject obj)
{
frequency = RFManager.ClampFrequency(frequency);
List <IRFObject> broadcasterList = RFManager.GetBroadcasterList(frequency);
if (broadcasterList.Contains(obj))
{
return;
}
broadcasterList.Add(obj);
RFManager.MarkFrequencyDirty(frequency);
}
public static List <IRFObject> GetBroadcasterList(int frequency)
{
frequency = RFManager.ClampFrequency(frequency);
List <IRFObject> rfObjectList = (List <IRFObject>)null;
if (!RFManager._broadcasters.TryGetValue(frequency, out rfObjectList))
{
rfObjectList = new List <IRFObject>();
RFManager._broadcasters.Add(frequency, rfObjectList);
}
return(rfObjectList);
}
internal void InternalSetPressed(bool pressed)
{
this.SetFlag(BaseEntity.Flags.On, pressed, false, true);
if (pressed)
{
RFManager.AddBroadcaster(this.frequency, (IRFObject)this);
}
else
{
RFManager.RemoveBroadcaster(this.frequency, (IRFObject)this);
}
}
internal void InternalSetPressed(bool pressed)
{
SetFlag(Flags.On, pressed);
if (pressed)
{
RFManager.AddBroadcaster(frequency, this);
}
else
{
RFManager.RemoveBroadcaster(frequency, this);
}
}
public void ServerSetFrequency(BaseEntity.RPCMessage msg)
{
if (msg.player == null || !msg.player.CanBuild())
{
return;
}
int num = msg.read.Int32();
RFManager.ChangeFrequency(this.frequency, num, this, true, true);
this.frequency = num;
this.MarkDirty();
base.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
}
public void ServerSetFrequency(BaseEntity.RPCMessage msg)
{
if (Object.op_Equality((Object)msg.player, (Object)null) || !msg.player.CanBuild())
{
return;
}
int newFrequency = msg.read.Int32();
RFManager.ChangeFrequency(this.frequency, newFrequency, (IRFObject)this, true, true);
this.frequency = newFrequency;
this.MarkDirty();
this.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
}
public void ServerSetFrequency(BaseEntity.RPCMessage msg)
{
if (Object.op_Equality((Object)msg.player, (Object)null) || !msg.player.CanBuild() || (double)Time.get_time() < (double)this.nextChangeTime)
{
return;
}
this.nextChangeTime = Time.get_time() + 2f;
int newFrequency = msg.read.Int32();
RFManager.ChangeFrequency(this.frequency, newFrequency, (IRFObject)this, true, true);
this.frequency = newFrequency;
this.SendNetworkUpdateImmediate(false);
}
public static void AddListener(int frequency, IRFObject obj)
{
frequency = RFManager.ClampFrequency(frequency);
List <IRFObject> listenList = RFManager.GetListenList(frequency);
if (listenList.Contains(obj))
{
Debug.Log("adding same listener twice");
return;
}
listenList.Add(obj);
RFManager.MarkFrequencyDirty(frequency);
}
public override void IOStateChanged(int inputAmount, int inputSlot)
{
if (inputAmount > 0)
{
this.CancelInvoke(new Action(this.StopBroadcasting));
RFManager.AddBroadcaster(this.frequency, (IRFObject)this);
this.SetFlag(BaseEntity.Flags.Reserved3, true, false, true);
this.nextStopTime = Time.get_time() + 1f;
}
else
{
this.Invoke(new Action(this.StopBroadcasting), Mathf.Clamp01(this.nextStopTime - Time.get_time()));
}
}
public void ServerSetFrequency(BaseEntity.RPCMessage msg)
{
if (msg.player == null || !msg.player.CanBuild())
{
return;
}
if (UnityEngine.Time.time < this.nextChangeTime)
{
return;
}
this.nextChangeTime = UnityEngine.Time.time + 2f;
int num = msg.read.Int32();
RFManager.ChangeFrequency(this.frequency, num, this, true, true);
this.frequency = num;
base.SendNetworkUpdateImmediate(false);
}
void RfToolInspect(IPlayer player, string command, string[] args)
{
for (int cur_freq = frequency_min; cur_freq <= frequency_max; cur_freq++)
{
var listeners = RFManager.GetListenList(cur_freq);
if (listeners.Count > 0)
{
this.ReplyToPlayer(player, string.Format(lang.GetMessage("cmd_rftool.inspect_listeners", this, player.Id), listeners.Count, cur_freq));
}
}
for (int cur_freq = frequency_min; cur_freq <= frequency_max; cur_freq++)
{
var broadcasters = RFManager.GetBroadcasterList(cur_freq);
if (broadcasters.Count > 0)
{
this.ReplyToPlayer(player, string.Format(lang.GetMessage("cmd_rftool.inspect_broadcaster", this, player.Id), broadcasters.Count, cur_freq));
}
}
}
public void ServerSetFrequency(BaseEntity.RPCMessage msg)
{
if (Object.op_Equality((Object)msg.player, (Object)null) || !msg.player.CanBuild() || (Object.op_Inequality((Object)this.GetOwnerPlayer(), (Object)msg.player) || (double)Time.get_time() < (double)this.nextChangeTime))
{
return;
}
this.nextChangeTime = Time.get_time() + 2f;
int num = msg.read.Int32();
if (RFManager.IsReserved(num))
{
RFManager.ReserveErrorPrint(msg.player);
}
else
{
RFManager.ChangeFrequency(this.frequency, num, (IRFObject)this, false, this.IsOn());
this.frequency = num;
this.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
this.GetItem()?.MarkDirty();
}
}
public void ServerSetFrequency(RPCMessage msg)
{
if (msg.player == null || !msg.player.CanBuild() || GetOwnerPlayer() != msg.player || UnityEngine.Time.time < nextChangeTime)
{
return;
}
nextChangeTime = UnityEngine.Time.time + 2f;
int num = msg.read.Int32();
if (RFManager.IsReserved(num))
{
RFManager.ReserveErrorPrint(msg.player);
}
else
{
if (Interface.CallHook("OnRfFrequencyChange", this, num, msg.player) != null)
{
return;
}
RFManager.ChangeFrequency(frequency, num, this, false, IsOn());
frequency = num;
SendNetworkUpdate();
Item item = GetItem();
if (item != null)
{
if (item.instanceData == null)
{
item.instanceData = new ProtoBuf.Item.InstanceData();
item.instanceData.ShouldPool = false;
}
item.instanceData.dataInt = frequency;
item.MarkDirty();
}
Interface.CallHook("OnRfFrequencyChanged", this, num, msg.player);
}
}
internal override void DoServerDestroy()
{
RFManager.RemoveListener(this.frequency, (IRFObject)this);
base.DoServerDestroy();
}
public override void ServerInit()
{
base.ServerInit();
RFManager.AddListener(this.frequency, (IRFObject)this);
}
public void ChangeFrequency(int newFreq)
{
RFManager.ChangeFrequency(this.frequency, newFreq, (IRFObject)this, true, true);
this.frequency = newFreq;
}
internal override void DoServerDestroy()
{
RFManager.RemoveBroadcaster(this.frequency, this);
base.DoServerDestroy();
}
public void StopBroadcasting()
{
base.SetFlag(BaseEntity.Flags.Reserved3, false, false, true);
RFManager.RemoveBroadcaster(this.frequency, this);
}
