public void OnExitKey(Object p_sender, HotkeyEventArgs p_args)
{
ConversationManager conversationManager = LegacyLogic.Instance.ConversationManager;
if (p_args.KeyDown && conversationManager.IsOpen && m_finishFade && m_finishIndoorSceneLoad)
{
if (conversationManager.CurrentNpc != null && conversationManager.CurrentNpc.TradingInventory.IsTrading)
{
conversationManager.CurrentNpc.TradingInventory.StopTrading();
}
else if (conversationManager.CurrentNpc != null && conversationManager.CurrentNpc.TradingSpells.IsTrading)
{
conversationManager.CurrentNpc.TradingSpells.StopTrading();
}
else if (conversationManager.CurrentNpc != null && conversationManager.CurrentNpc.IdentifyController.IsIdentifying)
{
conversationManager.CurrentNpc.IdentifyController.StopIdentify();
}
else if (conversationManager.CurrentNpc != null && conversationManager.CurrentNpc.RepairController.IsRepairing)
{
conversationManager.CurrentNpc.RepairController.StopRepair();
}
else if (!PopupRequest.Instance.IsActive)
{
if (conversationManager.ShowNpcs)
{
LegacyLogic.Instance.ConversationManager.CloseNpcContainer(null);
}
}
}
}
// Start is called before the first frame update
void Start()
{
conversationManager = new ConversationManager(m_Viewport, m_ReceivedMessage, m_SentMessage);
conversation = null;
player = GameObject.Find("/Player").gameObject;
audioSource = player.GetComponent <AudioSource> ();
}
public void ConvFactoryGracefulFailure()
{
ConversationManager.RegisterNewConversationType(typeof(AliveRequest), typeof(SimpleRequestReplyInitiator));
Conversation testConv = ConversationManager.CreateNewConversation(new Envelope(new AliveReply()));
Assert.IsNull(testConv);
}
public void SetUpNewGame()
{
Texture2D spriteSheet = content.Load <Texture2D>(@"PlayerSprites\maleplayer");
player = new Player(GameRef, "Wesley", false, spriteSheet);
player.AddAvatar("fire", AvatarManager.GetAvatar("fire"));
player.SetAvatar("fire");
Texture2D tiles = GameRef.Content.Load <Texture2D>(@"Tiles\tileset1");
TileSet set = new TileSet(8, 8, 32, 32);
set.Texture = tiles;
TileLayer background = new TileLayer(200, 200);
TileLayer edge = new TileLayer(200, 200);
TileLayer building = new TileLayer(200, 200);
TileLayer decor = new TileLayer(200, 200);
map = new TileMap(set, background, edge, building, decor, "test-map");
map.FillEdges();
map.FillBuilding();
map.FillDecoration();
ConversationManager.CreateConversations(GameRef);
ICharacter teacherOne = Character.FromString(GameRef,
"Lance,teacherone,WalkDown,teacherone,water");
ICharacter teacherTwo = PCharacter.FromString(GameRef,
"Marissa,teachertwo,WalkDown,tearchertwo,wind,earth");
teacherOne.SetConversation("LanceHello");
teacherTwo.SetConversation("MarissaHello");
GameRef.CharacterManager.AddCharacter("teacherone", teacherOne);
GameRef.CharacterManager.AddCharacter("teachertwo", teacherTwo);
map.Characters.Add("teacherone", new Point(0, 4));
map.Characters.Add("teachertwo", new Point(4, 0));
camera = new Camera();
}
// Use this for initialization
void Start()
{
resourceManager = GameObject.FindGameObjectWithTag("Player").GetComponent<ResourceManager>();
choiceManager = GameObject.Find("Choices").GetComponent<ChoicesManager>();
conManager = defaultConversation.GetComponent<ConversationManager>();
eventHandler = GameObject.FindGameObjectWithTag("EventController").GetComponent<EventManagement>();
}
public AssassinationCaughtByGuardsLogic(ILocationCharacterProvider locationCharacterProvider, ConversationManager conversationManager, Settlement settlement, Hero assassinationTarget)
{
_locationCharacterProvider = locationCharacterProvider;
_conversationManager = conversationManager;
_settlement = settlement;
_assassinationTarget = assassinationTarget;
}
public void Initialize()
{
try
{
_lyncClient = LyncClient.GetClient();
_lyncClient.StateChanged += StateChanged;
if (_lyncClient.State == ClientState.SignedOut)
{
_lyncClient.BeginSignIn(
null,
null,
null,
(ar) =>
{
_lyncClient.EndSignIn(ar);
}
,
null);
}
else if (_lyncClient.State == ClientState.SignedIn)
{
_conversationManager = _lyncClient.ConversationManager;
_conversationManager.ConversationAdded += ConversationAdded;
}
}
catch (NotStartedByUserException)
{
throw new Exception("Lync is not running");
}
}
public override void OnInspectorGUI()
{
// Update the object and draw the default inspector
serializedObject.Update();
DrawDefaultInspector();
// Get the manager
ConversationManager manager = FindObjectOfType <ConversationManager>();
// If a manager was found, setup the tracker to drive the rect transforms of the name text and dialogue text
if (manager)
{
tracker = new DrivenRectTransformTracker();
tracker.Add(target, manager.NameText.rectTransform, DrivenTransformProperties.AnchoredPositionY);
tracker.Add(target, manager.DialogueText.rectTransform, DrivenTransformProperties.AnchoredPosition | DrivenTransformProperties.SizeDelta);
tracker.Add(target, manager.DialoguePanel, DrivenTransformProperties.SizeDeltaY);
// Use a button to toggle the npc
if (GUILayout.Button("Toggle NPC"))
{
manager.NpcIcon.enabled = !manager.NpcIcon.enabled;
// Validate the dialogue manager when the button is pressed
DialogueManager dialogue = target as DialogueManager;
dialogue.OnValidate();
}
}
// Apply modified properties
serializedObject.ApplyModifiedProperties();
}
public ConversationCtrlAppService(StatefulServiceContext serviceContext,
IReliableStateManager stateManager,
IEmployeeAppService employeeAppService) : base(serviceContext, stateManager)
{
_employeeAppService = employeeAppService;
_manager = new ConversationManager(stateManager);
}
public void RequestSucceed()
{
string RequestConvId = "5-562";
string RequestMessageId = "5-7-1654";
string ClientIp = "192.168.1.31";
int ClientPort = 5682;
var RequestMessage = new StockHistoryRequestMessage()
{
ConversationID = RequestConvId,
MessageID = RequestMessageId
};
Envelope Request = new TcpEnvelope(RequestMessage, ClientIp, ClientPort);
var localConv = ConversationManager.GetConversation(RequestConvId);
Assert.IsNull(localConv);
Assert.IsNull(mock);
var numClients = ClientManager.Clients.Count;
ConversationManager.ProcessIncomingMessage(Request);
localConv = ConversationManager.GetConversation(RequestConvId);
Assert.IsNotNull(localConv);
Assert.IsTrue(localConv.CurrentState is ConversationDoneState);
mock.Verify(state => state.Prepare(), Times.Once);
mock.Verify(state => state.Send(), Times.Once);
mock.Verify(state => state.HandleTimeout(), Times.Never);
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
if (converMgr != null)
{
foreach (var convKey in conversationContent.Keys)
{
var convItem = conversationContent[convKey];
var archivers = ArchiveHelper.GetArchivers();
foreach (var arcer in archivers)
{
var arcer1 = arcer;
Parallel.Invoke(() => arcer1.Save(convKey, convItem));
}
}
converMgr.ConversationAdded -= conversation_ConversationAdded;
converMgr = null;
}
conversationContent = null;
disposed = true;
}
}
}
internal void SendMessage(string contactUri, string imText)
{
try
{
if (_Client.State == ClientState.SignedIn)
{
ConversationManager myConversationManager = _Client.ConversationManager;
Conversation myConversation = myConversationManager.AddConversation();
Participant myParticipant = myConversation.AddParticipant(_Client.ContactManager.GetContactByUri(contactUri));
if (myParticipant.IsSelf == false)
{
if (myConversation.State == ConversationState.Active && myConversation.Properties.ContainsKey(ConversationProperty.Subject))
{
myConversation.Properties[ConversationProperty.Subject] = SUBJECT;
}
if (myConversation.Modalities.ContainsKey(ModalityTypes.InstantMessage))
{
InstantMessageModality imModality = (InstantMessageModality)myConversation.Modalities[ModalityTypes.InstantMessage];
if (imModality.CanInvoke(ModalityAction.SendInstantMessage))
{
Dictionary <InstantMessageContentType, string> textMessage = new Dictionary <InstantMessageContentType, string>();
textMessage.Add(InstantMessageContentType.PlainText, SUBJECT + " : " + imText);
imModality.BeginSendMessage(textMessage, SendMessageCallback, imModality);
}
}
}
}
}
catch
{
}
}
public bool PushData(string data)
{
Trace.Info($"PushData(), data length: {data.Length}");
if (string.IsNullOrWhiteSpace(data))
{
Trace.Error("PushData() was executed with empty content, exiting...");
return(false);
}
if (!data.StartsWith("{\"conversations\":"))
{
Trace.Error("Incorrect data format, exiting...");
return(false);
}
Trace.Info("Deserializing data");
ConversationManager.Instance = JsonConvert.DeserializeObject <ConversationManager>(data);
Trace.Info("Processing data");
var csvLines = ConversationManager.GetCsvConversations();
Trace.Info("Saving data");
FileManager.SaveToFile(csvLines, _cmdArgs["target-csv"]);
return(true);
}
public TraderModel()
{
if (Current == null)
{
Current = this;
}
else
{
throw new Exception("Only one Trader model should be used.");
}
Current = this;
var getStockHistConv = new StockHistoryRequestConversation();
getStockHistConv.SetInitialState(new StockHistoryRequestState(getStockHistConv));
ConversationManager.AddConversation(getStockHistConv);
var stockStreamConv = new StockStreamRequestConversation(Config.GetClientProcessNumber());
stockStreamConv.SetInitialState(new StockStreamRequestState(Config.GetClientProcessNumber(), stockStreamConv));
ConversationManager.AddConversation(stockStreamConv);
StockUpdateEventHandler += HandleStockUpdate;
}
public override void Startup()
{
//Init Conversation Manager
_convManager = new ConversationManager();
_convManager.Scene = "init";
Matrix toScreenSpace = Matrix.Identity;
toScreenSpace.M11 = 2 / 1024.0f;
toScreenSpace.M22 = 2 / 768.0f;
toScreenSpace.M41 = -1;
toScreenSpace.M42 = -1;
var cam = new Camera
{
PostWorldMatrix = toScreenSpace,
Position = Vector3.UnitZ,
IsPerspective = false,
ViewportWidth = 2,
ViewportHeight = -2
};
cam.Dirty();
Root = new UI.TransformNode
{
Transform = cam.WorldToProjectionMatrix,
Dispatcher = GameApp.Service<UIManager>().Root
};
var pageStyle = new Style.PageStyle(GameApp.Service<Styler>().GetPageStyle("Conversation"));
pageStyle.Initialize();
ConversationUIPage = pageStyle.TypedTarget;
((Panel)pageStyle.ChildIds["ConversationPanel"].Target).MouseButton1Up += new EventHandler<MouseEventArgs>(ConversationUI_MouseButton1Up);
}
protected override void OnAfterLoad()
{
lyncClient = null;
conversationManager = null;
conversationAdded = Conversations_ConversationAdded;
}
public static void ChangeCurrentCharaObject(CampaignGameStarter campaignGameStarter, Hero hero)
{
ConversationManager conversationManager = GetConversationManager(campaignGameStarter);
if (null != conversationManager)
{
IAgent iagent = conversationManager.ListenerAgent;
if (iagent.GetType() == typeof(Agent))
{
Agent agent = (Agent)iagent;
FieldInfo fieldInfo = agent.GetType().GetField("_character", BindingFlags.NonPublic | BindingFlags.Instance);
if (null != fieldInfo)
{
fieldInfo.SetValue(agent, hero.CharacterObject);
}
hero.CharacterObject.UpdatePlayerCharacterBodyProperties(agent.BodyPropertiesValue, hero.CharacterObject.IsFemale);
if (null != agent.Name)
{
hero.Name = new TextObject(String.Format("\"{0}\"", agent.Name) + hero.Name.ToString());
FieldInfo fieldInfo2 = agent.GetType().GetField("_name", BindingFlags.NonPublic | BindingFlags.Instance);
if (null != fieldInfo2)
{
fieldInfo2.SetValue(agent, hero.Name);
}
}
}
}
}
public void SucessfulRequest()
{
var stockStreamConv = new StockHistoryRequestConversation();
stockStreamConv.SetInitialState(new StockHistoryRequestState(stockStreamConv));
ConversationManager.AddConversation(stockStreamConv);
string conversationId = stockStreamConv.Id;
//Verify conversation exists in Conversation Manager
Assert.IsTrue(ConversationManager.ConversationExists(conversationId));
//Create fake response message and process it
var stockStreamResponse = new TcpEnvelope(new StockHistoryResponseMessage()
{
MessageID = "123-abc"
});
stockStreamResponse.Contents.ConversationID = stockStreamConv.Id;
ConversationManager.ProcessIncomingMessage(stockStreamResponse);
//Conversation over but we hold onto the done state for a little
//in case we need to handle a retry. Ensure it has not yet been
//removed from Conversation Manager
Assert.IsTrue(ConversationManager.ConversationExists(conversationId));
var retrycount = Config.GetInt(Config.DEFAULT_RETRY_COUNT);
var timeout = Config.GetInt(Config.DEFAULT_TIMEOUT);
Thread.Sleep((int)((retrycount * 2) * timeout * 1.5));
//Conversation should have cleaned itself up now...
Assert.IsFalse(ConversationManager.ConversationExists(conversationId));
}
public static IConversation GetChatConversation(DummyChatRoomId chatRoomId)
{
List <IContact> contacts = new List <IContact>();
List <TextMessage> messages = DummyConversationDataGenerator.GetMessageSet(chatRoomId);
List <ChatRoomInformation> chatInfoItems = new List <ChatRoomInformation>();
ChatRoomInformation chatRoomInfo = GetChatRoomInfo(chatRoomId);
chatInfoItems.Add(chatRoomInfo);
List <MessageAttachment> attachments = new List <MessageAttachment>();
foreach (string phoneNumberValue in chatRoomInfo.Participants)
{
IContact associatedContact = GetContactByPhoneNumber(phoneNumberValue);
if (associatedContact != null)
{
contacts.Add(associatedContact);
}
}
ConversationManager conversationManager = new ConversationManager(contacts, messages, chatInfoItems, attachments, null);
foreach (IConversation conversation in conversationManager)
{
if (conversation.MessageCount > 0)
{
return(conversation);
}
}
throw new ArgumentException("Shouldn't reach here!");
}
static void Main(string[] args)
{
Log.Debug($"{nameof(Main)} (enter)");
SignatureService.LoadPrivateKey("Team1/StockServer");
StockData.Init();
ConversationManager.Start(ConversationBuilder);
ComService.AddUdpClient(Config.DEFAULT_UDP_CLIENT, Config.GetInt(Config.STOCK_SERVER_PORT));
ComService.AddTcpListener(Config.DEFAULT_TCP_CLIENT, Config.GetInt(Config.STOCK_SERVER_TCP_PORT));
Log.Info("Starting simulation.");
Task.Run(() => RunSimulation());
Log.Info("Waiting for StockStreamRequestMessages.");
Log.Info("Pres any key to close program.");
Console.ReadKey();
lock (RunSimLock)
{
IsSimRunning = false;
}
Log.Debug($"{nameof(Main)} (exit)");
}
override protected void Start()
{
base.Start();
inst_Conv = ConversationManager.getInstance();
inst_Char = CharacterManager.getInstance();
inst_Cam = CameraManager.getInstance();
}
public static void RunSimulation()
{
var tickDelay = Config.GetInt(Config.STOCK_TICK_DELAY);
var runSimLocal = true;
lock (RunSimLock)
{
runSimLocal = IsSimRunning;
}
while (runSimLocal)
{
Thread.Sleep(tickDelay);
var nextMarketDay = StockData.AdvanceDay();
foreach (var clientIp in ClientManager.Clients.Keys)
{
var updateConv = new StockUpdateSendConversation(Config.GetInt(Config.STOCK_SERVER_PROCESS_NUM));
updateConv.SetInitialState(new StockUpdateSendState(nextMarketDay, clientIp, updateConv, null));
ConversationManager.AddConversation(updateConv);
}
lock (RunSimLock)
{
runSimLocal = IsSimRunning;
}
}
}
void Awake()
{
// find the script and allow me to check for collision
//zone = GameObject.Find("InteractionZone").GetComponent<ZoneCheck>();
zone = gameObject.transform.GetChild(0).GetComponent <ZoneCheck>();
playerAttention = false;
isMatched = false;
inMatchList = false;
if (likesPudding)
{
attribute += "Likes Pudding";
}
else
{
attribute += "Hates Pudding";
}
if (likesVideoGames)
{
attribute += ", Likes Video Games";
}
else
{
attribute += ", Hates Video Games";
}
convo = new ConversationPoint("Hey! I'm " + name + "!\nHere's some facts about me:\n" + attribute,
new ResponseTree {
{ "Cool story bro", new ConversationPoint("Press F to add me to the match list!") }
}
);
convoManager = GameObject.Find("Conversation Manager").GetComponent <ConversationManager>();
}
public void ConvFactoryCommunicatorInstance()
{
ConversationManager.RegisterNewConversationType(typeof(AliveRequest), typeof(SimpleRequestReplyInitiator));
Assert.IsNotNull(ConversationManager.PrimaryCommunicator);
Assert.IsFalse(ConversationManager.PrimaryCommunicator.IsActive);
Conversation testConv = ConversationManager.CreateNewConversation(new Envelope(new AliveRequest()));
ConversationManager.RegisterConversation(testConv);
Assert.IsNotNull(testConv);
Assert.IsFalse(testConv.IsActive);
Assert.AreEqual(testConv.GetType(), typeof(SimpleRequestReplyInitiator));
Assert.IsTrue(ConversationManager.ConversationDictionary.ContainsKey(testConv.Id));
testConv.Stop();
testConv.Start();
Thread.Sleep(250);
Assert.IsTrue(testConv.IsActive);
testConv.Stop();
Thread.Sleep(250);
Assert.IsFalse(testConv.IsActive);
ConversationManager.PrimaryCommunicator.Stop();
Thread.Sleep(250);
Assert.IsFalse(ConversationManager.PrimaryCommunicator.IsActive);
}
private static void RequestStockStream()
{
var conv = new StockHistoryRequestConversation(Config.GetInt(Config.BROKER_PROCESS_NUM));
conv.SetInitialState(new StockHistoryRequestState(conv));
ConversationManager.AddConversation(conv);
}
public GroupMembersUpdatedConsumer(IReliableStateManager stateManager, IGroupAppService groupAppService)
{
_groupAppService = groupAppService;
_stateManager = stateManager;
_manager = new ConversationManager(stateManager);
_logger = Log.ForContext <GroupMembersUpdatedConsumer>();
}
public void CreateConversationUseExternalUrl(string url, LyncConversation lyncConversation)
{
if (_currentLyncConversation != null)
{
_currentLyncConversation.Close();
}
_currentLyncConversation = lyncConversation;
ConversationManager.ConversationAdded += OnConversationManagerConversationAdded;
ConversationManager.ConversationRemoved += OnConversationManagerConversationRemoved;
_currentLyncConversation = lyncConversation;
var conferUrl = GetConferenceUrl(url);
_log.Info("ConferenceUrl:{0} ExternalUrl:{1}", conferUrl, url);
var existConversations = ConversationManager.Conversations;
foreach (var existConversation in existConversations)
{
_log.Debug((string)existConversation.Properties[ConversationProperty.ConferencingUri]);
if ((string)existConversation.Properties[ConversationProperty.ConferencingUri] + "?" == conferUrl)
{
existConversation.End();
}
}
var conversation = ConversationManager.JoinConference(conferUrl);
conversation.StateChanged += OnConversationStateChanged;
}
public string GetElementToAttach(DateTime time)
{
ConversationManager manager = new ConversationManager();
string elementToAttach = manager.CalculateElementToAttach(time);
return(elementToAttach);
}
public void Succeed()
{
string RequestConvId = "5-562";
string ClientIp = "192.168.1.31";
int ClientPort = 5682;
var testStock = new Stock("TST", "Test Stock");
ValuatedStock[] vStock = { new ValuatedStock(("1984-02-22,1,2,3,100,5").Split(','), testStock) };
MarketDay day = new MarketDay("day1", vStock);
var RequestMessage = new StockPriceUpdate(day)
{
ConversationID = RequestConvId,
};
Envelope Request = new Envelope(RequestMessage, ClientIp, ClientPort);
var localConv = ConversationManager.GetConversation(RequestConvId);
Assert.IsNull(localConv);
Assert.IsNull(mock);
ConversationManager.ProcessIncomingMessage(Request);
localConv = ConversationManager.GetConversation(RequestConvId);
Assert.IsNotNull(localConv);
Assert.IsTrue(localConv.CurrentState is ConversationDoneState);
mock.Verify(state => state.Prepare(), Times.Once);
mock.Verify(state => state.Send(), Times.Once);
mock.Verify(state => state.HandleTimeout(), Times.Never);
}
private static Conversation HandleStockPriceUpdate(Envelope e)
{
Conversation conv = null;
StockPriceUpdate m = e.Contents as StockPriceUpdate;
var sigServ = new SignatureService();
var bits = Convert.FromBase64String(m.SerializedStockList);
var StocksList = sigServ.Deserialize <MarketDay>(bits);
if (!sigServ.VerifySignature(StocksList, m.StockListSignature))
{
Log.Error("Stock Price Update signature validation failed. Ignoring message.");
}
else
{
LeaderboardManager.Market = StocksList;
conv = new StockUpdateConversation(m.ConversationID);
conv.SetInitialState(new ProcessStockUpdateState(e, conv));
//Send updated leaderboard to clients.
Task.Run(() =>
{
foreach (var clientIp in ClientManager.Clients.Keys)
{
var stockUpdateConv = new LeaderBoardUpdateRequestConversation(Config.GetInt(Config.BROKER_PROCESS_NUM));
stockUpdateConv.SetInitialState(new LeaderboardSendUpdateState(clientIp, stockUpdateConv, null));
ConversationManager.AddConversation(stockUpdateConv);
}
});
}
return(conv);
}
private static void Main(string[] args)
{
Log.Debug($"{nameof(Main)} (enter)");
SignatureService.LoadPublicKey("Team1/StockServer");
ConversationManager.Start(ConversationBuilder);
ComService.AddUdpClient(Config.DEFAULT_UDP_CLIENT, Config.GetInt(Config.BROKER_PORT));
RequestStockStream();
PrintMenu();
PortfolioManager.LoadPortfolios();
var input = Console.ReadLine();
while (!input.Equals("exit"))
{
RequestStockStream();
PrintMenu();
input = Console.ReadLine();
}
ConversationManager.Stop();
Log.Debug($"{nameof(Main)} (exit)");
}
static void Main(string[] args)
{
var suscriptionId = SecretManager.GetSecret("suscriptionId", "YourSuscriptionIdHere");
var region = SecretManager.GetSecret("regionId", "YourRegionHere");
var luisApplicationId = SecretManager.GetSecret("luisApplicationId", "YourLuisApplicationIdHere");
var luisSecretKey = SecretManager.GetSecret("luisKey", "YourSecretKeyHere");
var crmPassword = SecretManager.GetSecret("crmPassword", "YourCrmPasswordHere");
RecognitionManager recManager = new RecognitionManager(suscriptionId, region, "es-es");
speachManager = new SpeechManager();
ConversationManager conversation = new ConversationManager(luisApplicationId, luisSecretKey, crmPassword);
conversation.Context.OnMiddleConversationResponse += Context_OnMiddleConversationResponse;
conversation.OnProcessedRequest += Conversation_OnProcessedRequest;
bool exit = false;
while (!exit)
{
Console.WriteLine("Talk");
string text = recManager.Recognice().Result;
Console.WriteLine($"-{text}");
var response = conversation.NewRequest(text);
Console.WriteLine($"\t-{response.Text}");
Console.WriteLine($"-{text}");
speachManager.Speak(response.Text);
}
}
// Use this for initialization
void Start()
{
eventHandler = GameObject.FindGameObjectWithTag("EventController").GetComponent<EventManagement>();
resourceManager = GameObject.FindGameObjectWithTag("Player").GetComponent<ResourceManager>();
choiceManager = GameObject.Find("Choices").GetComponent<ChoicesManager>();
conManager = defaultConversation.GetComponent<ConversationManager>();
raided = eventHandler.islandEventIsOn.GetComponent<PortIslandEventScript>().raided;
}
public ConversationService(ConversationManager conversationManager)
{
if (conversationManager == null)
throw new ArgumentNullException("conversationManager");
this._conversationManager = conversationManager;
this._conversationManager.ConversationAdded += _conversationManager_ConversationAdded;
}
void Awake()
{
if(master == null){
master = this;
} else if (master != this){
Destroy(gameObject);
}
}
public void Init(ConversationManager conversationManager, LConversation.MessageDelegate messageDelegate)
{
_messageDelegate = messageDelegate;
int count = conversationManager.Conversations.Count;
for (int i = 0; i < count; ++i)
{
Conversation conversation = conversationManager.Conversations[i];
var lconversation = new LConversation(conversation, _messageDelegate);
_mapConversations.Add(conversation, lconversation);
}
conversationManager.ConversationAdded += ConversationAdded;
conversationManager.ConversationRemoved += ConversationRemoved;
}
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
}
converMgr.ConversationAdded -= conversation_ConversationAdded;
converMgr = null;
conversationContent = null;
_disposed = true;
}
}
// Use this for initialization
void Start ()
{
m_ConversationManagerSharePointer = this.gameObject.GetComponent<ConversationManager>() ;
if( null == m_ConversationManagerSharePointer )
{
Debug.LogError( "null == m_ConversationManagerSharePointer" ) ;
}
LoadStoryAndTakes() ;
#if DEBUG
if( null != m_ConversationManagerSharePointer )
{
m_ConversationManagerSharePointer.ActiveConversation( 1 ) ;
}
#endif
}
public ConversationArchiver()
{
if (!System.IO.Directory.Exists(Configuration.FileArchivePath))
{
System.IO.Directory.CreateDirectory(Configuration.FileArchivePath);
}
try
{
var lyncClient = LyncClient.GetClient();
if (lyncClient != null)
{
converMgr = lyncClient.ConversationManager;
converMgr.ConversationAdded += conversation_ConversationAdded;
conversationContent = new Dictionary<string, ConversationContext>();
}
}
catch (System.Exception exp)
{
throw new ApplicationException("Unable to get Lync Client.",exp);
}
}
public void Start_Conversation(ConversationManager conversation)
{
conversation.Start_Conversation();
}
public void StartSession(AccountDC a)
{
Callback = OperationContext.Current.GetCallbackChannel<IBomberCallback>();
using (var db = new BomberDbContext())
{
var query = from ac in db.Accounts
where ac.Login == a.Login
&& ac.Password == a.Password
select ac;
if (query.Count() == 0)
{
Callback.RejectConnection();
ConnexionDenied = true;
}
else
{
var p = query.ToList<Account>().ElementAt(0).Player;
if (Sessions.Keys.Contains(p.PlayerId))
{
p.PlayerStatus = "Offline";
db.SaveChanges();
Sessions[p.PlayerId].Callback.DisconnectPlayer();
Callback.DisconnectPlayer();
return;
}
p.PlayerStatus = "Online";
db.SaveChanges();
Sessions.Add(p.PlayerId, this);
this.Player = p;
var profil = EntityContractTranslator.PlayerToPlayerDC(p);
var friendShipRequests = EntityContractTranslator.PlayersToPlayerDCs(p.PlayersRequestingFriendship);
//notifying connected friends:
var connectedFriends = from f in p.Friends
where Sessions.Keys.Contains(f.PlayerId)
select f;
foreach (var f in connectedFriends)
{
var session = Sessions[f.PlayerId];
session.Callback.NotifyPlayerStatusChange(profil);
}
//retrieving conversations
List<Conversation> convs = new List<Conversation>();
foreach (var c in db.Conversations)
{
if (c.Host.PlayerId == p.PlayerId || (from pl in c.Players select pl.PlayerId).Contains(p.PlayerId))
convs.Add(c);
}
List<ConversationDC> playerConvDCs = new List<ConversationDC>();
if (convs.Count > 0)
{
foreach (var c in convs)
{
ConversationManager cm = null;
if (Conversations.Keys.Contains(c.ConversationId))
{
cm = Conversations[c.ConversationId];
}
else
{
cm = new ConversationManager(new ConversationDC()
{
ConversationId = c.ConversationId,
Host = EntityContractTranslator.PlayerToPlayerDC(c.Host),
ConversationLog = c.ConversationLog,
Participants = EntityContractTranslator.PlayersToPlayerDCs(c.Players),
NewMessage = ""
});
Conversations.Add(cm.Conv.ConversationId, cm);
}
playerConvDCs.Add(cm.Conv);
cm.EndOfConvEvent += EndOfConvEventHandler;
cm.JoinEvent += JoinConvEventHandler;
cm.KickEvent += KickFromConvEventHandler;
cm.LeaveEvent += LeaveConvEventHandler;
cm.MessageEvent += ConvMessageEventHandler;
}
}
Callback.ReceiveProfil(profil, friendShipRequests, playerConvDCs);
}
}
}
void Start()
{
conversationManager = FindObjectOfType<ConversationManager>();
StartCoroutine(EnterRoomCoroutine());
}
public void CreateConversation(ConversationDC newConv)
{
using (var db = new BomberDbContext())
{
var q = (from p in db.Players
where p.PlayerId == newConv.Host.PlayerId
select p).ToList();
var convMembersIds = from i in newConv.Participants
select i.PlayerId;
var convMembers = (from p in db.Players
where convMembersIds.Contains(p.PlayerId)
select p);
if (q.Count > 0)
{
var host = q.ElementAt(0);
Conversation c = new Conversation()
{
Host = host,
ConversationLog = ""
};
// discussion : add the host to c.Players or not? let's say no, for now...
foreach (var p in convMembers)
{
if (!c.Players.Contains(p))
c.Players.Add(p);
}
db.Conversations.AddObject(c);
db.SaveChanges();
var convDC = EntityContractTranslator.ConversationToConversationDC(c);
var cm = new ConversationManager(convDC);
Conversations.Add(convDC.ConversationId, cm);
if (Sessions.Keys.Contains(host.PlayerId))
{
var s = Sessions[host.PlayerId];
cm.EndOfConvEvent += s.EndOfConvEventHandler;
cm.JoinEvent += s.JoinConvEventHandler;
cm.KickEvent += s.KickFromConvEventHandler;
cm.LeaveEvent += s.LeaveConvEventHandler;
cm.MessageEvent += s.ConvMessageEventHandler;
s.Callback.InitializeConversation(convDC);
}
foreach (var p in convMembers)
{
if (Sessions.Keys.Contains(p.PlayerId))
{
var s = Sessions[p.PlayerId];
cm.EndOfConvEvent += s.EndOfConvEventHandler;
cm.JoinEvent += s.JoinConvEventHandler;
cm.KickEvent += s.KickFromConvEventHandler;
cm.LeaveEvent += s.LeaveConvEventHandler;
cm.MessageEvent += s.ConvMessageEventHandler;
s.Callback.InitializeConversation(convDC);
}
}
}
}
}
void Start()
{
cm = GameObject.FindGameObjectWithTag("GameController").GetComponent<ConversationManager> ();
active_speech = false;
sub_switch = 0;
current_sub = 0;
}
void Start()
{
//Checks if Area Event has been deleted. This would have happened if the gameobject can't be reactivated and the user has loaded the scene again.
//Don't want to trigger again. so Remove it before it can be triggered.
DeleteObjects.CheckIfDeleted (this.gameObject.name);
ChoiceCanvas = GameObject.Find ("Choice Canvas").GetComponent<Canvas>() ; //Find the Choice Canvas in the Scene.
if (ChoiceCanvas != null) //If the choice Canvas exists then set Conversation Instance.
ConversationInstance = new ConversationManager (ChoiceCanvas);
else
Destroy (this.gameObject);
}
// Starts the designated conversation, and stops the current conversation
public void Change_Conversation(ConversationManager conversation_to_start)
{
VNSceneManager.current_conversation.Finish_Conversation();
conversation_to_start.Start_Conversation();
}
public static IntPtr Connect(int instanceId, string service, string topic)
{
lock (_Table)
{
// Create string handles for the service name and topic name.
IntPtr serviceHandle = Ddeml.DdeCreateStringHandle(instanceId, service, Ddeml.CP_WINANSI);
IntPtr topicHandle = Ddeml.DdeCreateStringHandle(instanceId, topic, Ddeml.CP_WINANSI);
// Establish a conversation with a server that suppoerts the service name and topic name pair.
IntPtr handle = Ddeml.DdeConnect(instanceId, serviceHandle, topicHandle, IntPtr.Zero);
// Free the string handles that were created earlier.
Ddeml.DdeFreeStringHandle(instanceId, topicHandle);
Ddeml.DdeFreeStringHandle(instanceId, serviceHandle);
if (handle != IntPtr.Zero)
{
// Make sure this thread has an IMessageFilter on it.
LocalDataStoreSlot slot = Thread.GetNamedDataSlot(DataSlot);
if (Thread.GetData(slot) == null)
{
ConversationManager filter = new ConversationManager();
Application.AddMessageFilter(filter);
Thread.SetData(slot, filter);
}
// Add an entry to the table that maps the conversation handle to the current thread.
_Table.Add(handle, Ddeml.GetCurrentThreadId());
}
return handle;
}
}
void Start()
{
audio = GetComponent<AudioSource>();
grayscale = FindObjectOfType<Grayscale>();
convoManager = FindObjectOfType<ConversationManager>();
}
// Use this for initialization
void Start()
{
manager = gameObject.GetComponent<ConversationManager>();
}
/// <summary>
/// Awake this instance.
/// </summary>
private void Awake( )
{
Anchor = GameObject.Find ( "Anchor" );
AnchorTransform = Anchor.transform;
playerController = PlayerObj.GetComponent<PlayerController>();
playerTransform = PlayerObj.transform;
chasePlayer = ChaserCamera.GetComponent<ChasePlayer>();
chasePlayerCameraTransform = ChaserCamera.transform;
uiLabelDistanceScore = DistanceScore.GetComponent<UILabel>();
floorMapManager = this.GetComponent<FloorMapManager>();
bgFever = chasePlayerCameraTransform.FindChild( "BgFever" ).gameObject;
objConversation = AnchorTransform.FindChild( "Conversation" ).gameObject;
conversationManager = objConversation.GetComponent<ConversationManager>();
bgWave = chasePlayerCameraTransform.FindChild( "BgWave" ).gameObject;
waterPlane = chasePlayerCameraTransform.FindChild( "WaterPlane" ).gameObject;
waveXL = chasePlayerCameraTransform.FindChild( "WaveXL" ).gameObject;
}
