public void Listen(ObjectMessage <string> message)
{
if (string.Compare(message.Content, "Cancel") == 0)
{
cancels = true;
}
}
public void onMessage(ObjectMessage m)
{
if (animator != null)
{
if (m.message == "trigger_ShootAnim")
{
animator.SetTrigger("Shooting");
Character.Instance.canRotate = true;
}
if (m.message == "Snap_true")
{
animator.SetBool("Snapped", true);
}
if (m.message == "Snap_false")
{
animator.SetBool("Snapped", false);
}
if (m.message == "Trigger_Hello")
{
Debug.Log("Sey hello");
animator.SetTrigger("Hello");
}
if (m.message.Contains("draw_line"))
{
string[] s = m.message.Split('@');
json = JsonUtility.FromJson <DrawLineMessage>(s[1]);
Debug.Log(json.x1);
color = new Color(1.0f, 1f, 1.0f);
}
//Debug.Log(m.message);
}
}
public void Handle(ObjectMessage message)
{
Bus.Reply(new ObjectResponseMessage
{
Property = "PropertyValue"
});
}
public void Add(ObjectMessage message)
{
if (!TryAdd(message))
{
throw new InvalidOperationException();
}
}
public void Handle(ObjectMessage message)
{
log.Info($"Received ObjectMessage. Property:'{message.Property}'");
bus.Reply(new ReplyMessage
{
Property = $"Handler Received '{message.Property}'"
});
}
public async Task <ActionResult> SendObjectMessage()
{
ObjectMessage message = new ObjectMessage();
Task <ObjectResponseMessage> responseTask = MvcApplication.Bus.Send("Samples.Callbacks.Receiver", message)
.Register(completion => (ObjectResponseMessage)completion.Messages[0]);
return(View("SendObjectMessage", await responseTask));
}
public void Handle(ObjectMessage message)
{
log.InfoFormat("Received ObjectMessage. Property:'{0}'", message.Property);
bus.Reply(new ReplyMessage
{
Property = string.Format("Handler Received '{0}'", message.Property)
});
}
public void onMessage(ObjectMessage m)
{
Debug.Log("Message to crocodile");
if (m.message == "text_Eat")
{
BubblesController.Instance.createBubble("I'm gonna eat You!\nAre you ready?", gameObject, 100);
}
}
public async Task Handle(ObjectMessage message, IMessageHandlerContext context)
{
log.Info($"Received ObjectMessage. Property:'{message.Property}'");
await context.Reply(new ReplyMessage
{
Property = $"Handler Received '{message.Property}'"
});
}
public async Task<ActionResult> SendObjectMessage()
{
ObjectMessage message = new ObjectMessage();
SendOptions sendOptions = new SendOptions();
sendOptions.SetDestination("Samples.Callbacks.Receiver");
Task<ObjectResponseMessage> responseTask = MvcApplication.Endpoint.Request<ObjectResponseMessage>(message, sendOptions);
return View("SendObjectMessage", await responseTask);
}
public async Task<ActionResult> SendObjectMessage()
{
var message = new ObjectMessage();
var sendOptions = new SendOptions();
sendOptions.SetDestination("Samples.Callbacks.Receiver");
Task<ObjectResponseMessage> responseTask = MvcApplication.EndpointInstance.Request<ObjectResponseMessage>(message, sendOptions);
return View("SendObjectMessage", await responseTask.ConfigureAwait(false));
}
public void onMessage(ObjectMessage m)
{
var pos = JsonUtility.FromJson <HelperMessage>(m.message);
QuixConsole.Log("Helper", pos.positions.Count);
trailPositions = pos.positions;
// trailPositions = pos;
}
public async Task<ActionResult> SendObjectMessage()
{
ObjectMessage message = new ObjectMessage();
Task<ObjectResponseMessage> responseTask = MvcApplication.Bus.Send("Samples.Callbacks.Receiver", message)
.Register(completion => (ObjectResponseMessage) completion.Messages[0]);
return View("SendObjectMessage", await responseTask);
}
public Task Handle(ObjectMessage message, IMessageHandlerContext context)
{
var objectResponseMessage = new ObjectResponseMessage
{
Property = "PropertyValue"
};
return(context.Reply(objectResponseMessage));
}
public void Handle(ObjectMessage message)
{
var response = new ObjectResponseMessage
{
Property = "PropertyValue"
};
Bus.Reply(response);
}
public async virtual void sendMessageToRoom(string mess)
{
ObjectMessage obms = new ObjectMessage();
obms.uID = this.state.uID;
obms.room = Client.Instance.room.SessionId;
obms.message = mess;
await Client.Instance.room.Send("objectMessage", obms);
}
public async Task <ActionResult> SendObjectMessage()
{
ObjectMessage message = new ObjectMessage();
SendOptions sendOptions = new SendOptions();
sendOptions.SetDestination("Samples.Callbacks.Receiver");
Task <ObjectResponseMessage> responseTask = MvcApplication.Endpoint.Request <ObjectResponseMessage>(message, sendOptions);
return(View("SendObjectMessage", await responseTask));
}
public async Task Handle(ObjectMessage message, IMessageHandlerContext context)
{
string format = $"Received ObjectMessage. Property:'{message.Property}'";
Console.WriteLine(format);
await context.Reply(new ReplyMessage
{
Property = $"Handler Received '{message.Property}'"
});
}
public async Task <ActionResult> SendObjectMessage()
{
var message = new ObjectMessage();
var bus = MvcApplication.Bus;
var responseTask = bus.Send("Samples.Callbacks.Receiver", message)
.Register(completion => (ObjectResponseMessage)completion.Messages[0])
.ConfigureAwait(false);
return(View("SendObjectMessage", await responseTask));
}
public async Task <ActionResult> SendObjectMessage()
{
var message = new ObjectMessage();
var sendOptions = new SendOptions();
sendOptions.SetDestination("Samples.Callbacks.Receiver");
Task <ObjectResponseMessage> responseTask = MvcApplication.EndpointInstance.Request <ObjectResponseMessage>(message, sendOptions);
return(View("SendObjectMessage", await responseTask.ConfigureAwait(false)));
}
public void Handle(ObjectMessage message)
{
string format = string.Format("Received ObjectMessage. Property:'{0}'", message.Property);
Console.WriteLine(format);
bus.Reply(new ReplyMessage
{
Property = string.Format("Handler Received '{0}'", message.Property)
});
}
static async Task SendObject()
{
ObjectMessage message = new ObjectMessage
{
Property = "The Property Value"
};
ReplyMessage response = await Send <ObjectMessage, ReplyMessage>(message);
Console.WriteLine("Response: " + response.Property);
}
public Task Handle(ObjectMessage message, IMessageHandlerContext context)
{
log.Info($"Received ObjectMessage. Property:'{message.Property}'");
var replyMessage = new ReplyMessage
{
Property = $"Handler Received '{message.Property}'"
};
return(context.Reply(replyMessage));
}
static async Task SendObject()
{
var message = new ObjectMessage
{
Property = "The Property Value"
};
var response = await Send <ObjectMessage, ReplyMessage>(message)
.ConfigureAwait(false);
Console.WriteLine($"Response: {response.Property}");
}
public void SendObjectEvent(ObjectMessage objectMessage)
{
EventObject[] eventObjects = GameObject.FindObjectsOfType <EventObject>();
foreach (EventObject eventObject in eventObjects)
{
if (eventObject.transform.name == objectMessage.GameObjectID)
{
eventObject.TriggerEvent(objectMessage);
}
}
}
private void onObjectMessage(ObjectMessage obj)
{
if (objects.ContainsKey(obj.uID))
{
objects[obj.uID].onMessage(obj);
}
else
{
Debug.Log("Could'nt find " + obj.uID);
}
}
// 計算状況の表示 + 経路情報の受取り (Header でハンドリング)
public void Listen(ObjectMessage <object> message)
{
if (message.Header == ComputationMessageHeader.Message)
{
AddHistoryMessage(message.Content as string);
}
else if (message.Header == ComputationMessageHeader.RouteToGoal)
{
var mapPositionList = message.Content as List <MazeMapPosition>;
AddToTreeView(mapPositionList);
}
}
private static async Task SendObjectMessage(IEndpointInstance endpointInstance)
{
Console.Write("Object message sent");
var message = new ObjectMessage();
var sendOptions = new SendOptions();
sendOptions.SetDestination(Endpoints.Receiver);
var responseMessage = await endpointInstance.Request <ObjectMessageResponse>(message, sendOptions).ConfigureAwait(false);
Console.WriteLine($"Object callback received with property value: {responseMessage.Property}");
}
public override void onMessage(ObjectMessage m)
{
if (m.message.Contains("c:"))
{
QuixConsole.Log(m.message);
var func = m.message.Split(':');
ColorUtility.TryParseHtmlString(func[1], out Color color);
gameObject.GetComponent <Renderer>().sharedMaterial.SetColor("Color", color);
}
base.onMessage(m);
// text.text = m.message;
}
public GameObjectObservableCollection(Int32 instanceId, RemoteGameObjects context, IEnumerable <IRemotingMessage> messageCollection)
{
_instanceId = instanceId;
_context = context;
_dispatcher = Application.Current.Dispatcher;
foreach (IRemotingMessage item in messageCollection)
{
ObjectMessage message = (ObjectMessage)item;
_keyToIndex.Add(message.InstanceId, _values.Count);
_values.Add(Wrap(message));
}
}
public void SendObjectMessageAsync()
{
ObjectMessage message = new ObjectMessage();
AsyncManager.OutstandingOperations.Increment();
MvcApplication.Bus.Send("Samples.Callbacks.Receiver", message)
.Register(ar =>
{
CompletionResult localResult = (CompletionResult)ar.AsyncState;
ObjectResponseMessage response = (ObjectResponseMessage)localResult.Messages[0];
AsyncManager.Parameters["response"] = response;
AsyncManager.OutstandingOperations.Decrement();
}, this);
}
static async Task SendObjectMessage(IEndpointInstance endpointInstance)
{
Console.WriteLine("Message sent");
#region SendObjectMessage
ObjectMessage message = new ObjectMessage();
SendOptions sendOptions = new SendOptions();
sendOptions.SetDestination("Samples.Callbacks.Receiver");
ObjectResponseMessage response = await endpointInstance.Request <ObjectResponseMessage>(message, sendOptions);
Console.WriteLine("Callback received with response property value:" + response.Property);
#endregion
}
public void ParseReal()
{
Parser parser = new Parser("12.34");
object expression = parser.ParseExpression();
Assert.IsNotNull(expression);
Assert.IsInstanceOfType(expression, typeof(ObjectMessage));
ObjectMessage msg = (ObjectMessage)expression;
Assert.AreEqual(12.34, msg.Object);
Assert.IsNull(parser.ParseExpression());
}
public void ToMessageSimplyReturnsMessageAsIsIfSuppliedWithMessage()
{
SerializableWithAttribute content = new SerializableWithAttribute();
ObjectMessage message = new ObjectMessage(tibcoSession, content);
mocks.ReplayAll();
Message msg = converter.ToMessage(message, session);
Assert.AreSame(message, msg);
mocks.VerifyAll();
}
static async void SendObjectMessage(IBus bus)
{
#region SendObjectMessage
ObjectMessage message = new ObjectMessage();
SendOptions sendOptions = new SendOptions();
sendOptions.SetDestination("Samples.Callbacks.Receiver");
ObjectResponseMessage response = await bus.Request<ObjectResponseMessage>(message, sendOptions);
Console.WriteLine("Callback received with response property value:" + response.Property);
#endregion
Console.WriteLine("Message sent");
}
static void SendObjectMessage(IBus bus)
{
#region SendObjectMessage
ObjectMessage message = new ObjectMessage();
bus.Send("Sample.Callbacks.Receiver", message)
.Register(ar =>
{
CompletionResult localResult = (CompletionResult) ar.AsyncState;
ObjectResponseMessage response = (ObjectResponseMessage)localResult.Messages[0];
Console.WriteLine("Callback received with response property value:" + response.Property);
}, null);
#endregion
Console.WriteLine("Message sent");
}
static async Task SendObjectMessage(IEndpointInstance endpointInstance)
{
Console.WriteLine("Message sent");
#region SendObjectMessage
var message = new ObjectMessage();
var sendOptions = new SendOptions();
sendOptions.SetDestination("Samples.Callbacks.Receiver");
var response = await endpointInstance.Request<ObjectResponseMessage>(message, sendOptions)
.ConfigureAwait(false);
Console.WriteLine("Callback received with response property value:" + response.Property);
#endregion
}
