// Use this for initialization
void Start()
{
meshub = GameObject.Find("MessageHub").GetComponent<MessageHub>();
navagent = this.gameObject.GetComponent<NavMeshAgent>();
fullhealth = health;
}
// Use this for initialization
void Start()
{
meshub = GameObject.Find("MessageHub").GetComponent<MessageHub>();
meshub.setMesPos("maxZombies", new Vector3((float)MaxZombies, 0, 0));
meshub.setMesPos("amountZombies", new Vector3(0.0f,0,0));
meshub.setMesBool("zombiereset", false);
spawntime = Random.Range(minWait, maxWait);
}
// Use this for initialization
void Start()
{
Cursor.lockState = CursorLockMode.Locked;
Cursor.visible = false;
meshub = GameObject.Find("MessageHub").GetComponent<MessageHub>();
meshub.setMesPos("playerpos",this.transform.position);
meshub.setMesBool("gamedone", false);
meshub.setMesBool("lost", false);
}
public ActionResult Contact()
{
ViewBag.Message = "Your contact page.";
MessageHub.UpdateMessage();
return(View());
}
public void CheckScan()
{ // Invoked on a parallel thread in LargeNaniteOreDetecotrLogic
if (!m_block.Enabled || !m_block.IsFunctional || !Sink.IsPoweredByType(MyResourceDistributorComponent.ElectricityId))
{
MyAPIGateway.Utilities.InvokeOnGameThread(() =>
{
m_depositGroupsByEntity.Clear();
m_inRangeCache.Clear();
});
return;
}
CheckIsTooCloseToOtherDetector();
if (m_tooCloseToOtherDetector)
{
MyAPIGateway.Utilities.InvokeOnGameThread(() =>
{
m_depositGroupsByEntity.Clear();
m_inRangeCache.Clear();
m_block.Enabled = false;
});
return;
}
Vector3D position = m_block.GetPosition();
BoundingSphereD sphere = new BoundingSphereD(position, Range);
MyGamePruningStructure.GetAllVoxelMapsInSphere(ref sphere, m_inRangeCache);
RemoveVoxelMapsOutOfRange();
AddVoxelMapsInRange();
UpdateDeposits(ref sphere);
m_inRangeCache.Clear();
int totalInitialTasks = m_depositGroupsByEntity.Sum((x) => x.Value.InitialTasks);
int totalProcessedTasks = m_depositGroupsByEntity.Sum((x) => x.Value.ProcessedTasks);
float scanProgress = 0f;
if (totalInitialTasks != 0)
{
scanProgress = (float)totalProcessedTasks / (float)totalInitialTasks;
}
if (scanProgress != m_scanProgress)
{
m_scanProgress = scanProgress;
MessageHub.SendToPlayerInSyncRange(new MessageOreDetectorScanProgress()
{
EntityId = m_block.EntityId,
Progress = m_scanProgress
}, m_block.GetPosition());
}
StringBuilder oreListCache = new StringBuilder();
foreach (var item in m_depositGroupsByEntity.SelectMany((x) => x.Value.Materials.GetMaterialList()).GroupBy((x) => x.Material.MinedOre))
{
oreListCache.Append($"- {item.Key}: {item.Sum((x) => x.Count)}\n");
}
if (oreListCache != m_oreListCache)
{
m_oreListCache = oreListCache;
MessageHub.SendToPlayerInSyncRange(new MessageOreDetectorScanComplete()
{
EntityId = m_block.EntityId,
OreListCache = m_oreListCache.ToString()
}, m_block.GetPosition());
}
}
public void Run()
{
var hub = new MessageHub();
// As the hub is a singleton, we have to add this as a hack to allow
// multiple assertions each with their own GlobalHandler registered to pass
var isUsageExampleRunning = true;
var errors = new Queue <KeyValuePair <Guid, Exception> >();
hub.RegisterGlobalErrorHandler(
(token, e) => errors.Enqueue(new KeyValuePair <Guid, Exception>(token, e)));
var auditQueue = new Queue <MessageBase>();
var allMessagesQueue = new Queue <MessageBase>();
var commandsQueue = new Queue <Command>();
var ordersQueue = new Queue <Order>();
void AuditHandler(Type type, object msg)
{
// ReSharper disable once AccessToModifiedClosure
if (!isUsageExampleRunning)
{
return;
}
msg.ShouldBeAssignableTo <MessageBase>();
auditQueue.Enqueue((MessageBase)msg);
}
hub.RegisterGlobalHandler(AuditHandler);
hub.Publish(new MessageBase {
Name = "Base"
});
commandsQueue.ShouldBeEmpty();
ordersQueue.ShouldBeEmpty();
auditQueue.Count.ShouldBe(1);
auditQueue.Dequeue().Name.ShouldBe("Base");
allMessagesQueue.ShouldBeEmpty();
hub.Subscribe <MessageBase>(msg =>
{
msg.ShouldBeAssignableTo <MessageBase>();
allMessagesQueue.Enqueue(msg);
});
hub.Subscribe <Command>(msg =>
{
msg.ShouldBeAssignableTo <MessageBase>();
msg.ShouldBeAssignableTo <Command>();
commandsQueue.Enqueue(msg);
});
hub.Subscribe <OpenCommand>(msg =>
{
msg.ShouldBeAssignableTo <Command>();
msg.ShouldBeOfType <OpenCommand>();
commandsQueue.Enqueue(msg);
});
hub.Subscribe <CloseCommand>(msg =>
{
msg.ShouldBeAssignableTo <Command>();
msg.ShouldBeOfType <CloseCommand>();
commandsQueue.Enqueue(msg);
});
hub.Subscribe <Order>(msg =>
{
msg.ShouldBeOfType <Order>();
ordersQueue.Enqueue(msg);
});
hub.Publish(new Command {
Name = "Command"
});
auditQueue.Count.ShouldBe(1);
auditQueue.Dequeue().Name.ShouldBe("Command");
allMessagesQueue.Count.ShouldBe(1);
allMessagesQueue.Dequeue().Name.ShouldBe("Command");
commandsQueue.Count.ShouldBe(1);
commandsQueue.Dequeue().Name.ShouldBe("Command");
ordersQueue.ShouldBeEmpty();
hub.Publish(new Order {
Name = "Order1"
});
auditQueue.Count.ShouldBe(1);
auditQueue.Dequeue().Name.ShouldBe("Order1");
allMessagesQueue.Count.ShouldBe(1);
allMessagesQueue.Dequeue().Name.ShouldBe("Order1");
commandsQueue.ShouldBeEmpty();
ordersQueue.Count.ShouldBe(1);
ordersQueue.Dequeue().Name.ShouldBe("Order1");
hub.Subscribe(new Action <Order>(o => ordersQueue.Enqueue(o)));
hub.Publish(new Order {
Name = "Order2"
});
auditQueue.Count.ShouldBe(1);
auditQueue.Dequeue().Name.ShouldBe("Order2");
allMessagesQueue.Count.ShouldBe(1);
allMessagesQueue.Dequeue().Name.ShouldBe("Order2");
ordersQueue.Count.ShouldBe(2);
ordersQueue.Dequeue().Name.ShouldBe("Order2");
ordersQueue.Dequeue().Name.ShouldBe("Order2");
commandsQueue.ShouldBeEmpty();
hub.Publish(new OpenCommand {
Name = "OpenCommand"
});
auditQueue.Count.ShouldBe(1);
auditQueue.Dequeue().Name.ShouldBe("OpenCommand");
allMessagesQueue.Count.ShouldBe(1);
allMessagesQueue.Dequeue().Name.ShouldBe("OpenCommand");
ordersQueue.ShouldBeEmpty();
commandsQueue.Count.ShouldBe(2);
errors.ShouldBeEmpty("No errors should have occurred!");
isUsageExampleRunning = false;
}
public Worker(ILogger <Worker> logger, IOptions <RabbitMQConfiguration> config, MessageHub hub)
{
_config = config;
_hub = hub;
}
public SearchViewModel(IMediaSearcherFactory mediaSearcherFactory, ITabSearcher tabSearcher, ConfigService configService, IDataContextService database, MessageHub hub)
: base(database, hub)
{
_tabSearcher = tabSearcher;
_configService = configService;
_mediaSearcherFactory = mediaSearcherFactory;
CurrentPageIndex = 1;
CurrentSearchText = String.Empty;
HeaderPagingVisibility = Visibility.Collapsed;
_searchGroupTabs = new TabsByName(database, true);
CreateCommands();
RegisterEvents();
SetConfigVariables();
}
public void SendValueUpdate(T value)
{
Value = value;
MessageHub.SendMessage(new ChannelHandlerValueChangedMessage(ChannelId.ToString(), value));
}
// Start is called before the first frame update
void Start()
{
Fx = GetComponentsInChildren <ParticleSystem> ();
MessageHub.Subscribe(MessageTopics.DisplayUI_FX_string, DisplayFx);
}
private void Done()
{
MessageHub.Publish(new DateSelectedMessage(this, StartDate, EndDate));
}
/// <summary>
/// Configures the <see cref="MessageHub"/> subscriptions.
/// </summary>
private static void ConfigureSubscriptions()
{
MessageHub.Subscribe <IOmdbService, ShowStoredEvent>(nameof(IOmdbService.EnrichShowWithRating));
}
public Session(MessageHub messageHub)
{
_messageHub = messageHub;
}
public SuggestedGroupViewModel(IMediaSearcherFactory mediaSearcherFactory, ConfigService configService, IDataContextService database, MessageHub hub)
: base(database, hub)
{
_mediaSearcherFactory = mediaSearcherFactory;
_configService = configService;
CreateCommands();
SetConfigVariables();
}
private async void ContentPage_Disappearing(object sender, EventArgs e)
{
SourceText = EdMain.Text;
await MessageHub.SendMessageAsync(this, MessageType.SourceTextChanged, SourceText);
}
public MessageDistributor()
{
MessageHub.Create(this);
}
/// <summary>
/// Post selected category to message hub
/// </summary>
protected override void Selected(Category category)
{
MessageHub.Publish(new CategorySelectedMessage(this, category));
Close(this);
}
public WeaponHandler(MessageHub messageHub, CollisionHandler collisionHandler)
{
_messageHub = messageHub;
_collisionHandler = collisionHandler;
}
private void Done(Category category)
{
MessageHub.Publish(new CategorySelectedMessage(this, category));
Close(this);
}
public Consumer(IMemoryCache memoryCache, MessageHub hub)
{
_memoryCache = memoryCache;
_hub = hub;
}
public MapEditor(MessageHub messageHub, ISession session, MapSettings settings)
: base(messageHub, session, settings)
{
}
public Variables(MessageHub messageHub)
{
messageHub.Subscribe <SetGlobalVariableMessage>(SetGlobalVariable);
}
public MessageQueueWorker(MessageHub hub, IServiceBroker broker)
{
this.hub = hub;
this.broker = broker;
}
public TextTabViewModel(IAudioSearcherFactory audioSearcherFactory, IDataContextService database, PopUpMessageService popUpMessageService, ConfigService configService, MessageHub hub)
: base(audioSearcherFactory, database, popUpMessageService, configService, hub)
{
_textTabAdapter = new TextTabAdapter();
}
public WeatherForecastController(ILogger <WeatherForecastController> logger, MessageHub messageHub)
{
_logger = logger;
_messageHub = messageHub;
}
public MapEditor(MessageHub messageHub, ISession session, int width, int height)
: base(messageHub, session, width, height)
{
}
public StartupViewModel(IDataContextService database, PopUpMessageService ratingService, ConfigService configService, MessageHub hub)
: base(database, hub)
{
_ratingService = ratingService;
_configService = configService;
RegisterEvents();
CreateCommands();
SetConfigVariables();
ProductVersion = App.Version;
}
public async Task SendMessage(MessageHub message)
{
message.Date = DateTime.Now;
await Clients.All.SendAsync("send", message);
}
public unsafe PublishOps()
{
var provider = new ServiceCollection().AddMessagePipe().BuildServiceProvider();
prism = new Prism.Events.EventAggregator().GetEvent <Message>();
prismStrong = new Prism.Events.EventAggregator().GetEvent <Message>();
var mdiatr = new ServiceCollection().AddMediatR(typeof(PublishOps).Assembly).BuildServiceProvider();
medi = mdiatr.GetRequiredService <IMediator>();
p = provider.GetRequiredService <IPublisher <Message> >();
var s = provider.GetRequiredService <ISubscriber <Message> >();
keyed = provider.GetRequiredService <IPublisher <Guid, Message> >();
var keyedS = provider.GetRequiredService <ISubscriber <Guid, Message> >();
hub = Hub.Default;
var px = new ServiceCollection().AddMessagePipe().BuildServiceProvider();
filter1 = px.GetRequiredService <IPublisher <Message> >();
var filter1Sub = px.GetRequiredService <ISubscriber <Message> >();
var px2 = new ServiceCollection().AddMessagePipe().BuildServiceProvider();
filter2 = px2.GetRequiredService <IPublisher <Message> >();
var filter2Sub = px2.GetRequiredService <ISubscriber <Message> >();
m = new Message();
subject = new Subject <Message>();
signalBus = SetupZenject();
easyMsgHub = new MessageHub();
asyncP = provider.GetRequiredService <IAsyncPublisher <Message> >();
asyncS = provider.GetRequiredService <IAsyncSubscriber <Message> >();
#if WinBenchmark
mvvmLight = new Messenger();
mvvmLightStrong = new Messenger();
#endif
toolkitStrong = new Microsoft.Toolkit.Mvvm.Messaging.StrongReferenceMessenger();
toolkitWeak = new Microsoft.Toolkit.Mvvm.Messaging.WeakReferenceMessenger();
simpleArray = new PlainAction[8];
actionDelegate = new Action[8];
interfaceArray = new IInvoke[8];
for (int i = 0; i < 8; i++)
{
s.Subscribe(new EmptyMessageHandler());
prism.Subscribe(lambdaRef.Delegate);
prismStrong.Subscribe(_ => { }, true);
ev += _ => { };
subject.Subscribe(_ => { });
hub.Subscribe <Message>(_ => { });
#if WinBenchmark
UniRx.MessageBroker.Default.Receive <Message>().Subscribe(new NopObserver());
mvvmLight.Register <Message>(this, _ => { }, false);
// mvvmLightStrong.Register<Message>(this, _ => { }, true);
#endif
keyedS.Subscribe(key, _ => { });
filter1Sub.Subscribe(new EmptyMessageHandler(), new EmptyMessageHandlerFilter());
filter2Sub.Subscribe(new EmptyMessageHandler(), new EmptyMessageHandlerFilter(), new EmptyMessageHandlerFilter());
easyMsgHub.Subscribe <Message>(_ => { });
simpleArray[i] = new PlainAction();
actionDelegate[i] = new PlainAction().DelegateAction;
interfaceArray[i] = new PlainAction();
asyncS.Subscribe((_, _) => default(ValueTask));
toolkitStrong.Register <Message>(new object(), lambdaRef2.Delegate);
toolkitWeak.Register <Message>(new object(), lambdaRef2.Delegate);
}
signalBus.Subscribe <Message>(_ => { });
signalBus.Subscribe <Message>(_ => { });
signalBus.Subscribe <Message>(_ => { });
signalBus.Subscribe <Message>(_ => { });
signalBus.Subscribe <Message>(_ => { });
signalBus.Subscribe <Message>(_ => { });
signalBus.Subscribe <Message>(_ => { });
signalBus.Subscribe <Message>(_ => { });
}
public ActionResult About()
{
ViewBag.Message = "Your application description page.";
MessageHub.Hello();
return(View());
}
public GenreGroupsViewModel(IGenreBrowser genreBrowser, ConfigService configService, IDataContextService database, MessageHub hub)
: base(database, hub)
{
_genreBrowser = genreBrowser;
_configService = configService;
CreateCommands();
RegisterEvents();
SetConfigVariables();
this.Groups = new ObservableCollection <Group>();
}
internal MessageWorker(MessageHub messageHub)
: base(0x08, messageHub)
{
}
public void Close()
{
MessageHub.Hub.Clients.All.LocalDisconnect();
WebServer.Stop();
MessageHub.StoptHub();
}
public UnitHandler(MessageHub messageHub, ISession session)
{
_messageHub = messageHub;
_session = session;
}
// Use this for initialization
void Start()
{
meshub = GameObject.Find("MessageHub").GetComponent<MessageHub>();
}
