public void RemoveObserver(IPlayerObserver observer)
{
if (observers.Contains(observer))
{
observers.Remove(observer);
}
}
public Task <string> UpdatePlayer(string playerSessionID, IPlayerObserver playerObserver, Vec3 position)
{
int idx = mActivePlayers.FindIndex(item => (item.mID == playerSessionID));
if (idx >= 0)
{
if ((position.x < mMinLocation.x) || (position.y < mMinLocation.y) || (position.z < mMinLocation.z) ||
(position.x > mMaxLocation.x) || (position.y > mMaxLocation.y) || (position.z > mMaxLocation.z))
{
IChunkGrain transfer = TransferPlayerTo(playerSessionID, playerObserver, ref position, mActivePlayers[idx].mPosition);
if (transfer != null)
{
LeavePlayer(playerSessionID);
return(Task.FromResult <string>(transfer.GetPrimaryKeyString()));
}
}
mActivePlayers[idx].mPosition = position;
mActivePlayers[idx].mVersion = MinecraftVersion.GetNext();
return(Task.FromResult <string>(this.GetPrimaryKeyString()));
}
return(Task.FromResult <string>(null));
}
/* Methods moved from deleted Observable<IObserver> class */
public void AddObserver(IPlayerObserver observer)
{
if (!observers.Contains(observer))
{
observers.Add(observer);
}
}
public Task <FeedbackMessage> StartPlayer(string playerSessionID, IPlayerObserver playerObserver, Vec3 position, string[] fromGrain)
{
//Is player already here?
int idx = mActivePlayers.FindIndex(item => (item.mID == playerSessionID));
if (idx >= 0)
{
return(Task.FromResult <FeedbackMessage>(new FeedbackMessage(FeedbackMessage.Responces.Error, "Already Exist")));
}
//Add this player to the active list for other to monitors
PlayerInfo update = new PlayerInfo();
update.mPosition = position;
update.mVersion = MinecraftVersion.GetNext();
update.mID = playerSessionID;
mActivePlayers.Add(update);
//this player want to listen to all associated blocks
mNeedsInitObservers.Add(playerObserver);
//each associated grain needs to update this one
foreach (var pair in mAssociatedGrains)
{
bool bFound = false;
if (fromGrain != null)
{
foreach (var id in fromGrain)
{
if (id == pair.Key)
{
bFound = true;
break;
}
}
}
if (bFound == false)
{
var tracking = pair.Value;
tracking.mNeedInitObservers.Add(playerObserver);
}
}
//if no updates are occuring, now we have a player to update
if (mTimer == null)
{
mTimer = RegisterTimer((_) => Fetch(), null, TimeSpan.FromMilliseconds(0), TimeSpan.FromMilliseconds(mUpdateRateinMilliSeconds));
}
return(Task.FromResult <FeedbackMessage>(new FeedbackMessage(FeedbackMessage.Responces.None)));
}
async Task IPlayerRegistrationGrain.Register(IPlayerObserver playerObserver)
{
var playerId = this.GetPrimaryKey();
// first have someone else to wait for future notifications from the GameServerGrain
IPlayerGrain playerInGame = PlayerGrainFactory.GetGrain(playerId);
// Forward subscription to the corresponding PlayerInGameGrain and trigger lobby service.
var playerInfo = await playerInGame.Subscribe(playerObserver);
// *then* ask to start a GameServerGrain via lobby
await _lobby.RegisterPlayer(playerInGame, playerInfo);
}
Task <PlayerInfo> IPlayerGrain.Subscribe(IPlayerObserver playerObserver)
{
var playerId = this.GetPrimaryKey().ToString();
if (this.subscribers.Count != 0)
{
throw new NotSupportedException("Only one subscription allowed");
}
this.subscribers.Subscribe(playerObserver);
return(Task.FromResult <PlayerInfo>(this.State.PlayerInfo));
}
public async Task <FeedbackMessage> Initialize(MinecraftOrleansWorldClient world, string playerID, IPlayerObserver observer, Vec3 spawnPoint)
{
mWorld = world;
mPlayerID = playerID;
mObserver = await GrainClient.GrainFactory.CreateObjectReference <IPlayerObserver>(observer);
var grainID = mWorld.GetChunk(spawnPoint);
if (grainID != "")
{
mCurGrain = GrainClient.GrainFactory.GetGrain <IChunkGrain>(grainID);
return(await mCurGrain.StartPlayer(mPlayerID, mObserver, spawnPoint, null));
}
return(await Task.FromResult(new FeedbackMessage(FeedbackMessage.Responces.Error, "Spawn point not in available Chunk")));
}
private IChunkGrain TransferPlayerTo(string playerSessionID, IPlayerObserver playerObserver, ref Vec3 position, Vec3 oldPosition)
{
foreach (var pair in mAssociatedGrains)
{
var tracking = pair.Value;
var lowerCorner = tracking.mMinLocation;
var upperCorner = tracking.mMaxLocation;
if ((lowerCorner.x <= position.x) && (lowerCorner.y <= position.y) && (lowerCorner.z <= position.z) &&
(upperCorner.x > position.x) && (upperCorner.y > position.y) && (upperCorner.z > position.z))
{
tracking.mGrain.StartPlayer(playerSessionID, playerObserver, position, GetAssociatedGrainIDs());
return(tracking.mGrain);
}
}
position.Set(oldPosition);
return(null);
}
public void AddObserver(IPlayerObserver player)
{
playerList.Add(player);
scoreboard.AddPlayer((Player)player);
}
/// <summary> Set up scenario observer for feedback about status and events </summary>
public void SetScenarioObserver(IPlayerObserver observer)
{
scenarioObserver = observer;
}
public async Task Detach(IPlayerObserver obs)
{
ObserverListe.Remove(obs);
}
public async Task Attach(IPlayerObserver obs)
{
ObserverListe.Add(obs);
}
public void AddObserver(IPlayerObserver observer)
{
m_dealer.AttachObserver(observer);
m_player.AttachObserver(observer);
}
public void Remove(IPlayerObserver o)
{
list.Remove(o);
UnityEngine.Debug.Log("Remove!");
}
public void Add(IPlayerObserver o)
{
list.Add(o);
UnityEngine.Debug.Log("Add!");
}
public async static System.Threading.Tasks.Task <IPlayerObserver> CreateObjectReference(IPlayerObserver obj)
{
if (methodInvoker == null)
{
methodInvoker = new PlayerObserverMethodInvoker();
}
return(PlayerObserverFactory.Cast(await GrainReference.CreateObjectReference(obj, methodInvoker)));
}
public static void DeleteObjectReference(IPlayerObserver reference)
{
GrainReference.DeleteObjectReference(reference);
}
// Set player observer
public void setObs(IPlayerObserver obs)
{
this.obs = obs;
}
