public void AddChild(int childNodeId, int position, KgsGame game)
{
var newNode = new KgsSgfNode(childNodeId, this.Layer + 1, this);
Children.Insert(position, newNode);
game.Controller.Nodes[childNodeId] = newNode;
}
private void Events_GameJoined(object sender, KgsGame e)
{
InGameForm ingameForm = new FormsPrototype.InGameForm(e.Info, e.Controller, this.kgs);
ingameForm.LoadGame(e);
ingameForm.Show();
}
public void RemoveProperty(KgsSgfProperty prop, KgsGame ongame)
{
var existing = Properties.FirstOrDefault(p => p.Name == prop.Name && (p.Loc?.SameAs(prop.Loc) ?? true));
if (existing != null)
{
Properties.Remove(existing);
}
ExecutePropertyRemoval(prop, ongame);
}
private static void Kgs_GameJoined(object sender, KgsGame e)
{
Mvx.RegisterSingleton <IGame>(e);
var tabProvider = Mvx.Resolve <ITabProvider>();
if (e.Controller.Players.Any(pl => pl.IsLocal))
{
CreateTab <OnlineGameViewModel>(TabNavigationType.NewForegroundTab);
}
else
{
CreateTab <ObserverGameViewModel>(TabNavigationType.NewForegroundTab);
}
}
private void ExecutePropertyRemoval(KgsSgfProperty prop, KgsGame ongame)
{
switch (prop.Name)
{
case "DEAD":
if (ongame.Controller.Phase.Type != Modes.LiveGame.Phases.GamePhaseType.LifeDeathDetermination)
{
ongame.Controller.SetPhase(Modes.LiveGame.Phases.GamePhaseType.LifeDeathDetermination);
}
ongame.Controller.BlackDoneReceived = false;
ongame.Controller.WhiteDoneReceived = false;
ongame.Controller.KgsConnector.ForceRevivifyGroup(
new Position(prop.Loc.X, KgsCoordinates.TheirsToOurs(prop.Loc.Y, ongame.Info.BoardSize)));
break;
default:
break;
}
}
public override void Process(KgsConnection connection)
{
KgsGame game = connection.Data.GetGame(ChannelId);
if (game != null)
{
if (this.Clocks != null)
{
if (this.Clocks[Role.White] != null)
{
game.Controller.Players.White.Clock.UpdateFromClock(this.Clocks[Role.White]);
}
if (this.Clocks[Role.Black] != null)
{
game.Controller.Players.Black.Clock.UpdateFromClock(this.Clocks[Role.Black]);
}
}
game.Controller.DoneId = DoneId;
if (this.Actions != null)
{
if (this.Actions.Any(action => action.Action == "SCORE"))
{
if (game.Controller.Phase.Type != Modes.LiveGame.Phases.GamePhaseType.LifeDeathDetermination)
{
game.Controller.SetPhase(Modes.LiveGame.Phases.GamePhaseType.LifeDeathDetermination);
}
}
}
if (this.BlackDoneSent && !game.Controller.BlackDoneReceived)
{
game.Controller.BlackDoneReceived = true;
game.Controller.KgsConnector.RaiseDoneReceived(game.Controller.Players.Black);
}
if (this.WhiteDoneSent && !game.Controller.WhiteDoneReceived)
{
game.Controller.WhiteDoneReceived = true;
game.Controller.KgsConnector.RaiseDoneReceived(game.Controller.Players.White);
}
}
}
internal void RaiseGameJoined(KgsGame ongame)
{
GameJoined?.Invoke(this, ongame);
}
internal void RaiseUndoRequestReceived(KgsGame kgsGame)
{
UndoRequestReceived?.Invoke(this, kgsGame.Info);
}
/// <summary>
/// Joins the game channel and opens the given game so it can be referenced by other messages.
/// </summary>
/// <param name="ongame">The KGS game that will be referenced later.</param>
/// <param name="kgsTrueGameChannel">The game channel that we are joining.</param>
public void JoinGame(KgsGame ongame, KgsTrueGameChannel kgsTrueGameChannel)
{
_joinedGames[ongame.Info.ChannelId] = ongame;
JoinChannel(kgsTrueGameChannel);
}
private void ExecuteProperty(KgsSgfProperty prop, KgsGame ongame)
{
switch (prop.Name)
{
case "RULES":
RulesDescription rules = prop;
ongame.Info.BoardSize = new GameBoardSize(rules.Size);
foreach (var player in ongame.Controller.Players)
{
player.Clock = rules.CreateTimeControl();
}
ongame.Info.NumberOfHandicapStones = rules.Handicap;
ongame.Info.Komi = rules.Komi;
ongame.Info.RulesetType = KgsHelpers.ConvertRuleset(rules.Rules);
// (future work) TODO (Petr) ensure that even written late, these values are respected
break;
case "PLAYERNAME":
case "PLAYERRANK":
case "DATE":
case "PLACE":
// We do not need this information - we already have some and don't need the trest.
break;
case "PHANTOMCLEAR":
// I don't know what to do with this yet.
break;
case "ADDSTONE":
ongame.Controller.AddHandicapStonePosition(new Position(prop.Loc.X,
KgsCoordinates.TheirsToOurs(prop.Loc.Y, ongame.Info.BoardSize)));
break;
case "COMMENT":
// "Putti [2k]: hi\n
string[] splitByNewlines =
prop.Text.Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
foreach (var s in splitByNewlines)
{
var tuple = KgsRegex.ParseCommentAsChat(s);
if (tuple != null)
{
var chatMessage = new ChatMessage(tuple.Item1, tuple.Item2,
DateTimeOffset.Now, tuple.Item1 == ongame.Controller.Server.Username ? ChatMessageKind.Outgoing : ChatMessageKind.Incoming);
ongame.Controller.KgsConnector.ChatMessageFromServer(chatMessage);
}
}
break;
case "DEAD":
if (ongame.Controller.Phase.Type != Modes.LiveGame.Phases.GamePhaseType.LifeDeathDetermination)
{
ongame.Controller.SetPhase(Modes.LiveGame.Phases.GamePhaseType.LifeDeathDetermination);
}
ongame.Controller.BlackDoneReceived = false;
ongame.Controller.WhiteDoneReceived = false;
ongame.Controller.KgsConnector.ForceKillGroup(new Position(prop.Loc.X, KgsCoordinates.TheirsToOurs(prop.Loc.Y, ongame.Info.BoardSize)));
break;
case "TIMELEFT":
StoneColor colorTimeLeft = (prop.Color == "black" ? StoneColor.Black : StoneColor.White);
ongame.Controller.Players[colorTimeLeft].Clock.UpdateFromKgsFloat(prop.Float);
break;
case "MOVE":
Move move;
string propColor = prop.Color;
StoneColor color = propColor == "white" ? StoneColor.White : StoneColor.Black;
if (!prop.Loc.IsPass)
{
XY whereTo = prop.Loc;
Position position = new Game.Position(whereTo.X, KgsCoordinates.TheirsToOurs(whereTo.Y, ongame.Info.BoardSize));
move = Move.PlaceStone(color, position);
}
else
{
move = Move.Pass(color);
}
foreach (var player in ongame.Controller.Players)
{
if (player.Agent is KgsAgent)
{
((KgsAgent)player.Agent).StoreMove(this.Layer, color, move);
}
}
break;
default:
break;
}
}
public void AddProperty(KgsSgfProperty prop, KgsGame ongame)
{
Properties.Add(prop);
ExecuteProperty(prop, ongame);
}
// Some useless properties are missing
public void ExecuteAsIncoming(KgsConnection connection, KgsGame ongame)
{
switch (Type)
{
case "PROP_REMOVED":
ongame.Controller.Nodes[NodeId].RemoveProperty(Prop, ongame);
break;
case "PROP_GROUP_REMOVED":
foreach (var prop in Props)
{
ongame.Controller.Nodes[NodeId].RemoveProperty(prop, ongame);
}
break;
case "PROP_GROUP_ADDED":
foreach (var prop in Props)
{
ongame.Controller.Nodes[NodeId].AddProperty(prop, ongame);
}
break;
case "CHILD_ADDED":
ongame.Controller.Nodes[NodeId].AddChild(ChildNodeId, Position, ongame);
break;
case "PROP_ADDED":
ongame.Controller.Nodes[NodeId].AddProperty(Prop, ongame);
break;
case "PROP_CHANGED":
if (Prop.Name == "COMMENT")
{
ongame.Controller.Nodes[NodeId].AddProperty(Prop, ongame);
}
break;
case "ACTIVATED":
var whatWasActivated = ongame.Controller.Nodes[NodeId];
var currentActiveNode = ongame.Controller.ActivatedNode;
ongame.Controller.ActivatedNode = whatWasActivated;
if (whatWasActivated.Children.Count > 0)
{
// It is an undo.
int howManyUndos = 0;
var passNode = currentActiveNode;
while (passNode != whatWasActivated)
{
if (passNode == null)
{
// This should not happen.
// Let's nope out.
break;
}
passNode = passNode.Parent;
howManyUndos++;
}
ongame.Controller.KgsConnector.CauseUndo(howManyUndos);
}
break;
default:
ongame.Controller.Server.Events.RaiseErrorNotification("Unknown event: " + Type);
break;
}
}
