public void RemoveObject(IServerDistributedObject obj)
{
base.RemoveObject(obj);
DistributedObjectId doId = obj.DistributedObjectId;
// Remove from object zones dict
ZoneId zone = null;
mDistributedObjectIdToObjectZones.TryGetValue(doId, out zone);
mDistributedObjectIdToObjectZones.Remove(doId);
// Remove from zone dict
List <IServerDistributedObject> objList = null;
if (zone != null && mZoneDict.TryGetValue(zone, out objList))
{
objList.Remove(obj);
}
//remove from mSessionIdsToDistributedObjectIds
foreach (KeyValuePair <Guid, List <DistributedObjectId> > sessionIdToDistributedObjectIds in mSessionIdsToDistributedObjectIds)
{
sessionIdToDistributedObjectIds.Value.Remove(doId);
}
}
public void BroadcastDistributedObjectUpdateMessageToZone(Message message, DistributedObjectId serverDistributedObjectId)
{
ZoneId zoneId = this.GetZone(serverDistributedObjectId);
List <Guid> sessionIdsToSendMessage = mServerStateMachine.SessionManager.GetSessionIdsInterestedInZoneId(zoneId);
mServerStateMachine.SendMessageToReflector(message, sessionIdsToSendMessage);
}
public void AddAndRemoveObject()
{
ObjectRepository objRepo = new ObjectRepository();
// Create a distributed object to play with
DistributedObjectId doId = new DistributedObjectId(100);
DistributedTestObject obj = new DistributedTestObject(doId);
// Object should not be present
Assert.IsFalse(objRepo.ContainsObject(obj));
Assert.IsFalse(objRepo.ContainsObject(doId));
Assert.IsTrue(objRepo.GetObject(doId) == null);
// Add obj
objRepo.AddObject(obj);
Assert.IsTrue(objRepo.ContainsObject(obj));
Assert.IsTrue(objRepo.ContainsObject(doId));
Assert.AreEqual((IDistributedObject)objRepo.GetObject(doId), (IDistributedObject)obj);
// Remove obj
objRepo.RemoveObject(obj);
Assert.IsFalse(objRepo.ContainsObject(obj));
// Try to remove an object already removed
objRepo.RemoveObject(obj);
}
private AvatarDistributedObject BuildLocalAvatarDistributedObject(DistributedObjectId id, List <object> messageData)
{
AvatarDistributedObject av = new LocalAvatarDistributedObject(mSendMessage, id, messageData);
GameFacade.Instance.RegisterProxy(new LocalAvatarProxy((LocalAvatarDistributedObject)av));
return(av);
}
public IClientDistributedObject CreateDistributedObject(DistributedObjectId distributedObjectId, List <object> messageData)
{
DistributedObjectTypes type = CheckType.TryAssignType <DistributedObjectTypes>(messageData[0]);
IClientDistributedObject clientDistributedObject = null;
switch (type)
{
case DistributedObjectTypes.Avatar:
Guid localSessionId = CheckType.TryAssignType <Guid>(messageData[2]);
if (mLocalSessionId == localSessionId)
{
clientDistributedObject = BuildLocalAvatarDistributedObject(distributedObjectId, messageData);
}
else
{
clientDistributedObject = BuildForeignAvatarDistributedObject(distributedObjectId, messageData);
}
break;
case DistributedObjectTypes.Room:
clientDistributedObject = BuildRoomDistributedObject(distributedObjectId, messageData);
break;
case DistributedObjectTypes.MockObject:
clientDistributedObject = BuildMockDistributedObject(distributedObjectId, messageData);
break;
default:
throw new NotImplementedException(type.ToString());
}
return(clientDistributedObject);
}
// Returns the zone that this object is currently in.
public ZoneId GetZone(DistributedObjectId doId)
{
ZoneId zoneId = null;
mDistributedObjectIdToObjectZones.TryGetValue(doId, out zoneId);
return(zoneId);
}
public void RegisterForeignAvatar(AvatarEntity foreignAvatar, DistributedObjectId doId)
{
mForeignAvatarEntities.Add(new KeyValuePair <DistributedObjectId, AvatarEntity>(doId, foreignAvatar));
if (mHideForeignAvatars)
{
HideForeignAvatars();
}
}
private void BeginRoomLoading(Message receivedMessage)
{
RoomId currentRoomId = CheckType.TryAssignType <RoomId>(receivedMessage.Data[0]);
mCurrentRoomDistributedObjectId = CheckType.TryAssignType <DistributedObjectId>(receivedMessage.Data[1]);
GameFacade.Instance.SendNotification(GameFacade.ROOM_LOADING_STARTED, currentRoomId);
}
/*******************************/
// IMessageRouter Functions
/*******************************/
public void ReceiveMessage(Message message)
{
switch (message.MessageType)
{
case MessageType.Create:
IClientDistributedObject distributedObject = mDistributedObjectFactory.CreateDistributedObject(message.DistributedObjectId, message.Data);
if (distributedObject != null)
{
this.AddObject(distributedObject);
List <System.Action <IClientDistributedObject> > requestedObjectCallbacks = null;
if (mAnticipatedDistributedObjectIdsToCallbacks.TryGetValue(distributedObject.DistributedObjectId, out requestedObjectCallbacks))
{
foreach (System.Action <IClientDistributedObject> requestedObjectCallback in requestedObjectCallbacks)
{
requestedObjectCallback(distributedObject);
}
mAnticipatedDistributedObjectIdsToCallbacks.Remove(distributedObject.DistributedObjectId);
}
}
break;
case MessageType.Update:
DistributedObjectId doId = message.DistributedObjectId;
IDistributedObject updateObject = null;
if (mObjectIds.TryGetValue(doId, out updateObject))
{
updateObject.ProcessMessage(message);
}
else
{
Console.LogError("Message update but objectId " + doId + " not found in repository");
}
break;
case MessageType.Delete:
DistributedObjectId deletedoId = message.DistributedObjectId;
IDistributedObject deleteObject;
if (mObjectIds.TryGetValue(deletedoId, out deleteObject))
{
if (deleteObject is ClientDistributedObject)
{
ClientDistributedObject deleteClientObject = deleteObject as ClientDistributedObject;
if (deleteClientObject != null)
{
deleteClientObject.Dispose();
}
}
this.RemoveObject(deleteObject);
}
else
{
Console.LogError("Message delete but objectId " + deletedoId.ToString() + " not found in repository");
}
break;
}
}
public bool GetRoomDistributedObjectId(RoomId roomId, out DistributedObjectId distributedObjectId)
{
distributedObjectId = null;
IServerDistributedRoom serverDistributedRoom = null;
if (mRoomIdToRoomDistributedObject.TryGetValue(roomId, out serverDistributedRoom))
{
distributedObjectId = serverDistributedRoom.DistributedObjectId;
return(true);
}
return(false);
}
public void RemoveLocalAvatarEntity(DistributedObjectId localAvatarDistributedObjectId)
{
if (mLocalAvatarEntity.First == localAvatarDistributedObjectId)
{
mLocalAvatarEntity.Second.Dispose();
mLocalAvatarEntity = null;
}
else
{
throw new System.Exception("Error: trying to remove an avatar that is not our current local avatar.");
}
}
// Add this DistributedObject to the repository.
public void AddObjectToSessionId(Guid sessionId, IServerDistributedObject obj)
{
if (!mSessionIdsToDistributedObjectIds.ContainsKey(sessionId))
{
mSessionIdsToDistributedObjectIds[sessionId] = new List <DistributedObjectId>();
}
DistributedObjectId doId = obj.DistributedObjectId;
mSessionIdsToDistributedObjectIds[sessionId].Add(doId);
// Store in the dictionary of objects
mObjectIds[doId] = obj;
}
public ClientDistributedGreenScreenRoom(SendMessageCallback sendMessage, DistributedObjectId doId, List <object> messageData)
: base(sendMessage, doId)
{
mRoomName = CheckType.TryAssignType <string>(messageData[5]);
mRoomId = CheckType.TryAssignType <RoomId>(messageData[7]);
mRoomOwnerAccountId = CheckType.TryAssignType <AccountId>(messageData[8]);
BuildEntity();
string roomItemsXmlString = CheckType.TryAssignType <string>(messageData[3]);
SetupAssetsFromItemsXml(roomItemsXmlString);
}
// Get an object update but the object is not in the repository
public void ReceiveMessageForMissingObject()
{
ServerStateMachine serverStateMachine = new TestServerStateMachine();
ServerObjectRepository objectRepo = new ServerObjectRepository(serverStateMachine);
DistributedObjectId doId = new DistributedObjectId(100);
Message updateMessage = new Message();
List <object> data = new List <object>();
data.Add("Test");
updateMessage.UpdateObjectMessage(true, false, doId, (int)MessageSubType.Chat, data);
objectRepo.ReceiveRequest(updateMessage, Guid.Empty);
}
public void RemoveForeignAvatarEntity(DistributedObjectId foreignAvatarDistributedObjectId)
{
AvatarEntity foreignAvatarEntity = null;
List <AvatarEntity> foreignAvatarsToRemove = new List <AvatarEntity>();
if (mForeignAvatarEntities.TryGetValue(foreignAvatarDistributedObjectId, out foreignAvatarEntity))
{
foreignAvatarsToRemove.Add(foreignAvatarEntity);
foreignAvatarEntity.Dispose();
}
mForeignAvatarEntities.Remove(foreignAvatarDistributedObjectId);
foreignAvatarsToRemove.Clear();
}
public void ZoneHandling()
{
ServerStateMachine serverStateMachine = new TestServerStateMachine();
ServerObjectRepository objRepo = new ServerObjectRepository(serverStateMachine);
// Create a distributed object to play with
DistributedObjectId doId = new DistributedObjectId(100);
DistributedTestObject obj = new DistributedTestObject(doId);
ZoneId zoneId1 = new ZoneId(100);
ZoneId zoneId2 = new ZoneId(200);
objRepo.AddObject(obj);
// No zone set yet
Assert.IsTrue(objRepo.GetZone(obj) == null);
Assert.IsTrue(objRepo.GetZone(doId) == null);
Assert.IsTrue(objRepo.GetObjectsInZone(zoneId1).Count == 0);
// Set the first zone
objRepo.SetObjectZone(obj, zoneId1);
Assert.IsTrue(objRepo.GetZone(obj) == zoneId1);
Assert.IsTrue(objRepo.GetZone(doId) == zoneId1);
Assert.IsTrue(objRepo.GetObjectsInZone(zoneId1).Count == 1);
// Now change to the second zone
objRepo.SetObjectZone(obj, zoneId2);
Assert.IsTrue(objRepo.GetZone(obj) == zoneId2);
Assert.IsTrue(objRepo.GetZone(doId) == zoneId2);
// Should no longer be in the first zone
Assert.IsTrue(objRepo.GetObjectsInZone(zoneId1).Count == 0);
// Should be in the second zone
Assert.IsTrue(objRepo.GetObjectsInZone(zoneId2).Count == 1);
// Try setting the same zone again
objRepo.SetObjectZone(obj, zoneId2);
Assert.IsTrue(objRepo.GetZone(obj) == zoneId2);
Assert.IsTrue(objRepo.GetZone(doId) == zoneId2);
// Should be in the second zone, only once
Assert.IsTrue(objRepo.GetObjectsInZone(zoneId2).Count == 1);
// Remove obj
objRepo.RemoveObject(obj);
Assert.IsFalse(objRepo.ContainsObject(obj));
// Should not be in either zone
Assert.IsTrue(objRepo.GetObjectsInZone(zoneId1).Count == 0);
Assert.IsTrue(objRepo.GetObjectsInZone(zoneId2).Count == 0);
}
public void AddLocalAvatarEntity(LocalAvatarEntity localAvatar, DistributedObjectId doId)
{
if (mLocalAvatarEntity != null)
{
Console.LogError("The local avatar should only be built once. if we are seeing this message then this function be being used incorrectly. this system is flimsy and the assumption that mLocalAvatarEntity has to be null might be incorrect. if you see this message and it's still not crunch month look into this.");
}
if (localAvatar == null)
{
throw new ArgumentNullException("localAvatar");
}
if (doId == null)
{
throw new ArgumentNullException("doId");
}
mLocalAvatarEntity = new Pair <DistributedObjectId, LocalAvatarEntity>(doId, localAvatar);
}
private void GetDistributedObjectReference(DistributedObjectId requestedDistributedObjectId, System.Action <IClientDistributedObject> retrieveDistributedObjectCallback)
{
IClientDistributedObject clientDistributedObject = this.GetObject(requestedDistributedObjectId) as IClientDistributedObject;
//if the resulting object is null, we need to cache this request for when the object is eventually downloaded
if (clientDistributedObject == null)
{
if (!mAnticipatedDistributedObjectIdsToCallbacks.ContainsKey(requestedDistributedObjectId))
{
mAnticipatedDistributedObjectIdsToCallbacks.Add(requestedDistributedObjectId, new List <System.Action <IClientDistributedObject> >());
}
mAnticipatedDistributedObjectIdsToCallbacks[requestedDistributedObjectId].Add(retrieveDistributedObjectCallback);
}
else
{
retrieveDistributedObjectCallback(clientDistributedObject);
}
}
public ServerDistributedAvatar(DistributedObjectId doId, AvatarId avatarId, Guid localSessionId, string nickname, XmlDocument itemIdXml, ServerAccount serverAccount, ServerObjectRepository serverObjectRepository, ServerAssetRepository serverAssetRepository)
: base(serverObjectRepository, doId)
{
mCurrentTelemetryData = new List <object>();
mObjectType = DistributedObjectTypes.Avatar;
mAvatarId = avatarId;
mAvatarName = nickname;
mServerAccount = serverAccount;
mServerAssetRepository = serverAssetRepository;
mObjectData.Add(mObjectType);
mObjectData.Add("Avatar/Avatar Rig");
//UNCOMMENT THIS TO SEE WHICH SESSION THIS AVATAR BELONGS TO
//Console.Write("creating server distributed avatar data with session id: " + localSessionId);
mObjectData.Add(localSessionId);
mObjectData.Add(itemIdXml.InnerXml);
mObjectData.Add(mAvatarName);
}
private void GetAvatarServiceResponse(XmlNode avatarXmlNode, string nickname, Guid sessionId, ZoneId zoneId, Action <bool> gotAvatarServiceResponse)
{
List <ItemId> itemIds = null;
AvatarId avatarId;
try
{
if (AvatarXmlUtil.GetAvatarInfoFromAvatarXmlNode(avatarXmlNode, out avatarId, out itemIds))
{
Dna savedDna = mServerAssetRepository.GetDna(itemIds);
// Create an updated dna by starting with the reference dna and updating it with the savedDna
GetReferenceAvatar(delegate(Dna referenceAvatarDna)
{
Dna avatarDna = new Dna(mReferenceAvatarDna);
avatarDna.UpdateDna(savedDna);
// TODO? If UpdateDna overwrites something or fills in missing data we should save the dna back to the db
// Get xml from updated avatar dna
XmlDocument dnaXml = mServerAssetRepository.GetXmlDna(avatarDna.GetItemIdList());
DistributedObjectId distributedObjectId = mDistributedObjectIdManager.GetNewId();
ServerAccount serverAccount = mServerStateMachine.SessionManager.GetServerAccountFromSessionId(sessionId);
ServerDistributedAvatar serverDistributedAvatar = new ServerDistributedAvatar(distributedObjectId, avatarId, sessionId, nickname, dnaXml, serverAccount, mServerObjectRepository, mServerAssetRepository);
//register object with object repository
mServerObjectRepository.AddObjectToSessionId(sessionId, serverDistributedAvatar);
//register object with session manager
mServerEngine.ProcessZoneChange(serverDistributedAvatar, zoneId);
gotAvatarServiceResponse(true);
});
}
else
{
gotAvatarServiceResponse(false);
}
}
catch (System.Exception ex)
{
StateServerAssert.Assert(ex);
gotAvatarServiceResponse(false);
}
}
public AvatarDistributedObject(SendMessageCallback sendMessage, DistributedObjectId doId, List <object> messageData)
: base(sendMessage, doId)
{
mScheduler = GameFacade.Instance.RetrieveMediator <SchedulerMediator>().Scheduler;
mPath = (string)messageData[1];
string xmlString = (string)messageData[3];
mAvatarDna.LoadXml(xmlString);
mAvatarName = (string)messageData[4];
if (this.AvatarDna == null)
{
throw new Exception("this.AvatarDna is null when trying to Build Local Avatar Entity.");
}
BuildEntity();
}
// This object is changing zones, so record the new zone
public void SetObjectZone(IServerDistributedObject obj, ZoneId zone)
{
// Record this object as moving into this new zone.
// Cleanup any references to the old zone it was in.
DistributedObjectId doId = obj.DistributedObjectId;
// First grab the old zone
ZoneId oldZone = null;
mDistributedObjectIdToObjectZones.TryGetValue(doId, out oldZone);
// Now store the new zone
mDistributedObjectIdToObjectZones[doId] = zone;
// If it had a zone before, remove it from the ZoneDict's list
if (oldZone != null)
{
// Remove obj from the old zone list
List <IServerDistributedObject> objList = null;
if (mZoneDict.TryGetValue(oldZone, out objList))
{
objList.Remove(obj);
// We don't remove an empty list here because the assumption
// is that it will be used again in the near future...
}
}
// Now add this object to the ZoneDict's list in the new zone
if (zone != null)
{
// Create an object list for this zone if it is not there already...
List <IServerDistributedObject> objList = null;
if (!mZoneDict.TryGetValue(zone, out objList))
{
// New zone being used, create a new list
objList = new List <IServerDistributedObject>();
mZoneDict.Add(zone, objList);
}
objList.Add(obj);
}
}
private IClientDistributedRoom BuildRoomDistributedObject(DistributedObjectId id, List <object> messageData)
{
RoomType roomType = CheckType.TryAssignType <RoomType>(messageData[2]);
IClientDistributedRoom clientDistributedRoom = null;
switch (roomType)
{
case RoomType.GreenScreenRoom:
clientDistributedRoom = new ClientDistributedGreenScreenRoom(mSendMessage, id, messageData);
break;
case RoomType.MiniGameRoom:
throw new System.Exception("we shouldn't be creating these anymore in this way!! talk to matt!");
}
RoomManagerProxy roomManagerProxy = GameFacade.Instance.RetrieveProxy <RoomManagerProxy>();
roomManagerProxy.UpdateCurrentRoomReference(clientDistributedRoom);
return(clientDistributedRoom);
}
public void ObjectZoneChangingWithNobodyListening()
{
// Setup the server engine and its required dependencies
ServerStateMachine serverStateMachine = new TestServerStateMachine();
SessionManager sessionManager = new SessionManager();
ServerObjectRepository objectRepo = new ServerObjectRepository(serverStateMachine);
ServerEngine serverEngine = new ServerEngine(sessionManager, objectRepo, MockSendMessageToReflector);
// Create a distributed object to play with
DistributedObjectId doId = new DistributedObjectId(100);
DistributedTestObject obj = new DistributedTestObject(doId);
ZoneId zoneId1 = new ZoneId(100);
ZoneId zoneId2 = new ZoneId(200);
// Start by putting the object in the first zone
serverEngine.ProcessZoneChange(obj, zoneId1);
Assert.IsTrue(objectRepo.GetZone(obj) == zoneId1);
// Test changing to the zone the object is already in
serverEngine.ProcessZoneChange(obj, zoneId1);
Assert.IsTrue(objectRepo.GetZone(obj) == zoneId1);
// Now change to a new zone
serverEngine.ProcessZoneChange(obj, zoneId2);
Assert.IsTrue(objectRepo.GetZone(obj) == zoneId2);
// Now remove the object from the zone
Assert.IsTrue(serverEngine.RemoveObjectFromZone(obj) == zoneId2);
Assert.IsTrue(objectRepo.GetZone(obj) == null);
// Try a duplicate removal - should be safe to do
Assert.IsTrue(serverEngine.RemoveObjectFromZone(obj) == null);
Assert.IsTrue(objectRepo.GetZone(obj) == null);
// Now put the object back in the first zone
serverEngine.ProcessZoneChange(obj, zoneId1);
Assert.IsTrue(objectRepo.GetZone(obj) == zoneId1);
}
public void DisconnectSession()
{
// Setup the server engine and its required dependencies
ServerStateMachine serverStateMachine = new TestServerStateMachine();
SessionManager sessionManager = new SessionManager();
ServerObjectRepository objectRepo = new ServerObjectRepository(serverStateMachine);
ServerEngine serverEngine = new ServerEngine(sessionManager, objectRepo, MockSendMessageToReflector);
// Create a distributed object to play with
DistributedObjectId doId = new DistributedObjectId(100);
DistributedTestObject obj = new DistributedTestObject(doId);
ZoneId zoneId = new ZoneId(200);
Guid sessionId = new Guid();
Assert.IsTrue(sessionManager.AddSession(sessionId, new ServerAccount(new AccountId(0), 0, "0", "0", "schmear", "mein", "schmeer", null)));
objectRepo.AddObjectToSessionId(sessionId, obj);
serverEngine.ProcessOpenZoneInterest(sessionId, zoneId);
serverEngine.ProcessZoneChange(obj, zoneId);
serverEngine.ProcessDisconnectSession(sessionId);
// See if the object repo got cleaned up
// Object repo should no longer have the object
Assert.IsFalse(objectRepo.ContainsObject(obj));
Assert.IsTrue(objectRepo.GetObject(doId) == null);
// Object should not be in the zone
Assert.IsFalse(objectRepo.GetObjectsInZone(zoneId).Contains(obj));
Assert.IsTrue(objectRepo.GetDistributedObjectIdsOwnedBySessionId(sessionId).Count == 0);
// See if the session manager got cleaned up
// Session manager should no longer have the session
Assert.IsFalse(sessionManager.ContainsSession(sessionId));
// Zone interest should be cleaned up
Assert.IsFalse(sessionManager.SessionIdHasInterest(sessionId, zoneId));
Assert.IsFalse(sessionManager.GetSessionIdsInterestedInZoneId(zoneId).Contains(sessionId));
Assert.IsFalse(sessionManager.GetZoneIdsFromInterestedSessionId(sessionId).Contains(zoneId));
}
public ClientMockDistributedObject(SendMessageCallback sendMessage, DistributedObjectId doId) : base(sendMessage, doId)
{
}
public DistributedTestObject(DistributedObjectId doId) : base(null, doId)
{
}
public ForeignAvatarDistributedObject(SendMessageCallback sendMessage, DistributedObjectId doId, List <object> messageData)
: base(sendMessage, doId, messageData)
{
}
public ClientDistributedMiniGameRoom(SendMessageCallback sendMessage, DistributedObjectId doId, List <object> messageData)
: base(sendMessage, doId)
{
BuildEntity();
}
public ServerDistributedObject(ServerObjectRepository serverObjectRepository, DistributedObjectId doId)
: base(doId)
{
mServerObjectRepository = serverObjectRepository;
}
