public void AddMarker(Player player, Card card, Guid id, string name, ushort count, ushort oldCount, bool isScriptChange)
{
DataNew.Entities.Marker model = Program.GameEngine.GetMarkerModel(id);
DefaultMarkerModel defaultMarkerModel = model as DefaultMarkerModel;
if (defaultMarkerModel != null)
(defaultMarkerModel).SetName(name);
Marker marker = card.FindMarker(id, name);
if (player != Player.LocalPlayer)
{
if (marker == null && oldCount != 0)
{
Program.GameMess.Warning("Inconsistent state. Cannot create a marker when that marker already exists.");
return;
}
if (marker != null && oldCount != marker.Count)
{
Program.GameMess.Warning("Inconsistent state. Marker count invalid.");
return;
}
card.AddMarker(model, count);
}
if (count != 0)
{
int newCount = oldCount + count;
Program.GameMess.PlayerEvent(player, "adds {0} {1} marker(s) on {2}", count, model.Name, card);
if (isScriptChange == false)
{
Program.GameEngine.EventProxy.OnMarkerChanged_3_1_0_0(card, model.ModelString(), oldCount, newCount, isScriptChange);
Program.GameEngine.EventProxy.OnMarkerChanged_3_1_0_1(card, model.ModelString(), oldCount, newCount, isScriptChange);
}
}
}
public RandomRequest(Player player, int id, int min, int max)
{
_player = player;
Id = id;
_min = min;
_max = max;
}
internal Card(Player owner, int id, ulong key, Definitions.CardDef def, Data.CardModel model, bool mySecret)
: base(owner)
{
this.id = id;
this.Type = new CardIdentity(id) { alias = false, key = key, model = model, mySecret = mySecret };
definition = def;
All.Add(id, this);
}
private int _state; // Value of this counter
#endregion Fields
#region Constructors
public Counter(Player player, DataNew.Entities.Counter def)
{
_player = player;
_state = def.Start;
_name = def.Name;
_id = def.Id;
_defintion = def;
}
// Resets the lPlayer list
internal static void Reset()
{
lock (all)
{
all.Clear();
spectators.Clear();
LocalPlayer = GlobalPlayer = null;
}
}
/// <summary>Creates new cards on the table, as well as the corresponding CardIdentities.</summary>
/// <param name="id">An array with the new CardIdentity ids</param>
/// <param name="modelId"> </param>
/// <param name="x">The x position of the cards on the table.</param>
/// <param name="y">The y position of the cards on the table.</param>
/// <param name="faceUp">Whether the cards are face up or not.</param>
/// <param name="key"> </param>
/// <param name="persist"> </param>
public void CreateCardAt(int[] id, Guid[] modelId, int[] x, int[] y, bool faceUp, bool persist)
{
if (id.Length == 0)
{
Program.GameMess.Warning("[CreateCardAt] Empty id parameter.");
return;
}
if (id.Length != x.Length || id.Length != y.Length || id.Length != modelId.Length)
{
Program.GameMess.Warning("[CreateCardAt] Inconsistent parameters length.");
return;
}
var owner = Player.Find((byte)(id[0] >> 16));
if (owner == null)
{
Program.GameMess.Warning("[CreateCardAt] Player not found.");
return;
}
var table = Program.GameEngine.Table;
// Bring cards created by oneself to top, for z-order consistency
if (owner == Player.LocalPlayer)
{
for (var i = id.Length - 1; i >= 0; --i)
{
var card = Card.Find(id[i]);
if (card == null)
{
Program.GameMess.Warning("[CreateCardAt] Card not found.");
return;
}
table.SetCardIndex(card, table.Count + i - id.Length);
}
}
else
{
for (var i = 0; i < id.Length; i++)
{
new CreateCard(owner, id[i], faceUp, Program.GameEngine.Definition.GetCardById(modelId[i]), x[i], y[i], !persist).Do();
}
}
if (modelId.All(m => m == modelId[0]))
{
Program.GameMess.PlayerEvent(owner, "creates {1} '{2}'", owner, modelId.Length, owner == Player.LocalPlayer || faceUp ? Program.GameEngine.Definition.GetCardById(modelId[0]).Name : "card");
}
else
{
foreach (var m in modelId)
{
Program.GameMess.PlayerEvent(owner, "{0} creates a '{1}'", owner, owner == Player.LocalPlayer || faceUp ? Program.GameEngine.Definition.GetCardById(m).Name : "card");
}
}
}
public void MoveCardAt(Player player, int[] cards, int[] x, int[] y, int[] idx, bool[] faceUp, bool isScriptMove)
{
WriteReplayAction(player.Id);
// Get the table control
var table = Program.GameEngine.Table;
var playCards = cards
.Select(cardId => {
var playCard = Card.Find(cardId);
if (playCard == null)
{
Program.GameMess.Warning("Inconsistent state. Player {0} tried to move a card that does not exist.", player);
Program.GameMess.GameDebug("Missing Card ID={0}", cardId);
}
return(playCard);
})
.Where(playCard => playCard != null)
.ToArray();
if (playCards.Length == 0)
{
return;
}
// Because every player may manipulate the table at the same time, the index may be out of bound
if (playCards[0].Group == table)
{
for (var index = 0; index < idx.Length; index++)
{
if (idx[index] >= table.Count)
{
idx[index] = table.Count - 1;
}
}
}
else
{
for (var index = 0; index < idx.Length; index++)
{
if (idx[index] > table.Count)
{
idx[index] = table.Count;
}
}
}
// Ignore cards moved by the local player (already done, for responsiveness)
if (IsLocalPlayer(player))
{
return;
}
// Find the old position on the table, if any
// Do the move
new MoveCards(player, playCards, x, y, idx, faceUp, isScriptMove).Do();
}
public void Peek(Player player, Card card)
{
if (!card.PeekingPlayers.Contains(player))
{
card.PeekingPlayers.Add(player);
}
if (player != Player.LocalPlayer)
{
Program.GameMess.PlayerEvent(player, "peeks at a card ({0}).", card.Group is Table ? "on table" : "in " + card.Group.FullName);
}
}
public void AnchorCard(Card card, Player player, bool anchor)
{
var astring = anchor ? "anchored" : "unanchored";
Program.GameMess.PlayerEvent(player, "{0} {1}", astring, card);
if (Player.LocalPlayer == player)
{
return;
}
card.SetAnchored(true, anchor);
}
public void StopTurn(Player player)
{
if (player == Player.LocalPlayer)
{
Program.GameEngine.StopTurn = false;
}
Program.GameMess.System("{0} wants to play before end of turn.", player);
Program.GameEngine.EventProxy.OnEndTurn_3_1_0_0(player);
Program.GameEngine.EventProxy.OnEndTurn_3_1_0_1(player);
Program.GameEngine.EventProxy.OnTurnPaused_3_1_0_2(player);
}
internal Card(Player owner, int id, ulong key, CardDef def, DataNew.Entities.Card model, bool mySecret)
: base(owner)
{
_id = id;
Type = new CardIdentity(id) {Alias = false, Key = key, Model = model, MySecret = mySecret};
// var _definition = def;
All.Add(id, this);
_alternateOf = null;
numberOfSwitchWithAlternatesNotPerformed = 0;
_isAlternateImage = false;
}
public void Turn(Player player, Card card, bool up)
{
WriteReplayAction(player.Id);
// Ignore the card we turned ourselves
if (IsLocalPlayer(player))
{
card.MayBeConsideredFaceUp = false; // see comment on mayBeConsideredFaceUp
return;
}
new Turn(player, card, up).Do();
}
public void GameState(Player fromPlayer, string strstate)
{
WriteReplayAction(fromPlayer.Id);
Log.DebugFormat("GameState From {0}", fromPlayer);
var state = JsonConvert.DeserializeObject <GameSaveState>(strstate);
state.Load(Program.GameEngine, fromPlayer);
Program.GameMess.System("{0} sent game state ", fromPlayer.Name);
Program.GameEngine.GotGameState(fromPlayer);
}
public void MoveCard(Player player, int[] card, Group to, int[] idx, bool[] faceUp, bool isScriptMove)
{
WriteReplayAction(player.Id);
// Ignore cards moved by the local player (already done, for responsiveness)
var cards = card.Select(Card.Find).Where(x => x != null).ToArray();
if (!IsLocalPlayer(player))
{
new MoveCards(player, cards, to, idx, faceUp, isScriptMove).Do();
}
}
public void StartLimited(Player player, Guid[] packs)
{
WriteReplayAction(player.Id);
Program.GameMess.System("{0} starts a limited game.", player);
if (Player.LocalPlayer.Spectator == false)
{
var wnd = new Play.Dialogs.PickCardsDialog();
WindowManager.PlayWindow.ShowBackstage(wnd);
wnd.OpenPacks(packs);
}
}
public void AddAnswer2(Player player, ulong decrypted)
{
foreach (var v in values)
if (v.player == player)
{
v.decrypted = decrypted;
v.CheckConsistency();
phase2Count++;
return;
}
Program.Trace.TraceEvent(TraceEventType.Warning, EventIds.Event, "[AddAnswer] Protocol inconsistency. One client is buggy or tries to cheat.");
}
public void PassTo(Player who, ControllableObject obj, Player player, bool requested)
{
// Ignore message that we sent in the first place
if (who != Player.LocalPlayer)
{
obj.PassControlTo(player, who, false, requested);
}
if (obj is Card)
{
Program.GameEngine.EventProxy.OnCardControllerChanged_3_1_0_2((Card)obj, who, player);
}
}
public void ExecuteRemoteCall(Player fromPlayer, string func, string args)
{
// Build args
try
{
//var argo = Newtonsoft.Json.JsonConvert.DeserializeObject<object[]>(args);
ScriptEngine.ExecuteFunctionNoFormat(func, args);
}
catch (Exception)
{
}
}
public void GotGameState(Player fromPlayer)
{
Log.DebugFormat("GotGameState {0} {1}", fromPlayer, gameStateCount);
gameStateCount++;
fromPlayer.Ready = true;
if (gameStateCount == Player.Count - 1)
{
Log.DebugFormat("GotGameState Got all states");
WaitForGameState = false;
Ready();
}
}
/// <summary>Loads a player deck.</summary>
/// <param name="id">An array containing the loaded CardIdentity ids.</param>
/// <param name="type">An array containing the corresponding CardModel guids (encrypted).</param>
/// <param name="group">An array indicating the group the cards must be loaded into.</param>
public void LoadDeck(int[] id, Guid[] type, Group[] group, string[] size, string sleeve, bool limited)
{
if (id.Length != type.Length || id.Length != group.Length)
{
Program.GameMess.Warning("[LoadDeck] Protocol violation: inconsistent arrays sizes.");
return;
}
if (id.Length == 0)
{
return; // Loading an empty deck --> do nothing
}
var who = Player.Find((byte)(id[0] >> 16));
if (who == null)
{
Program.GameMess.Warning("[LoadDeck] Player not found.");
return;
}
WriteReplayAction(who.Id);
if (limited)
{
Program.GameMess.System("{0} loads a limited deck.", who);
}
else
{
Program.GameMess.System("{0} loads a deck.", who);
}
if (!IsLocalPlayer(who))
{
try {
var sleeveObj = Sleeve.FromString(sleeve);
who.SetSleeve(sleeveObj);
} catch (SleeveException ex) {
Log.Warn(ex.Message, ex);
Program.GameMess.Warning($"There was an error loading {0}'s deck sleeve: " + ex.Message, who);
} catch (Exception ex) {
Log.Warn(ex.Message, ex);
Program.GameMess.Warning($"There was an unknown error loading {0}'s deck sleeve.", who);
}
}
CreateCard(id, type, group, size);
Log.Info("LoadDeck Starting Task to Fire Event");
Program.GameEngine.EventProxy.OnLoadDeck_3_1_0_0(who, @group.Distinct().ToArray());
Program.GameEngine.EventProxy.OnLoadDeck_3_1_0_1(who, @group.Distinct().ToArray());
Program.GameEngine.EventProxy.OnDeckLoaded_3_1_0_2(who, @group.Distinct().ToArray());
}
public void AddAnswer2(Player lPlayer, ulong decrypted)
{
foreach (RandomValue v in _values.Where(v => v.Player == lPlayer))
{
v.Decrypted = decrypted;
v.CheckConsistency();
_phase2Count++;
return;
}
Program.Trace.TraceEvent(TraceEventType.Warning, EventIds.Event,
"[AddAnswer] Protocol inconsistency. One client is buggy or tries to cheat.");
}
public void Welcome(byte id, Guid gameSessionId, string gameName, bool waitForGameState)
{
WriteReplayAction(id);
Program.InPreGame = true;
Player.LocalPlayer.Id = id;
if (Program.Client is ClientSocket cs)
{
cs.StartPings();
}
Player.FireLocalPlayerWelcomed();
Program.GameEngine.OnWelcomed(gameSessionId, gameName, waitForGameState);
}
public void AnchorCard(Card card, Player player, bool anchor)
{
WriteReplayAction(player.Id);
var astring = anchor ? "anchored" : "unanchored";
Program.GameMess.PlayerEvent(player, "{0} {1}", astring, card);
if (IsLocalPlayer(player))
{
return;
}
card.SetAnchored(true, anchor);
}
public void GroupVis(Player player, Group group, bool defined, bool visible)
{
// Ignore messages sent by myself
if (player != Player.LocalPlayer)
{
group.SetVisibility(defined ? (bool?)visible : null, false);
}
if (defined)
{
Program.GameMess.PlayerEvent(player, visible ? "shows {0} to everybody." : "shows {0} to nobody.", group);
}
}
public void AddMarker(Player player, Card card, Guid id, string name, ushort count)
{
Data.MarkerModel model = Program.Game.GetMarkerModel(id);
if (model is DefaultMarkerModel)
((DefaultMarkerModel)model).SetName(name);
// Ignore markers created by oneself (already created for responsiveness issues)
if (player != Player.LocalPlayer)
card.AddMarker(model, count);
if (count != 0)
Program.Trace.TraceEvent(TraceEventType.Information, EventIds.Event | EventIds.PlayerFlag(player),
"{0} adds {1} {2} marker(s) on {3}", player, count, model, card);
}
public void Reset(Player player, bool isSoft)
{
WriteReplayReset(player.Id);
Program.GameEngine.Reset(isSoft);
if (isSoft)
{
Program.GameMess.System("{0} soft-resets the game.", player);
}
else
{
Program.GameMess.System("{0} resets the game.", player);
}
}
public void OnEndTurn(Player player)
{
var args = new object[1];
args[0] = player;
if(Program.GameEngine.Definition.Events.ContainsKey("OnEndTurn"))
{
foreach(var e in Program.GameEngine.Definition.Events["OnEndTurn"])
{
engine.ExecuteFunction(e.PythonFunction,player);
}
}
}
public void NextTurn(Player player, bool setActive, bool force)
{
var lastPlayer = Program.GameEngine.ActivePlayer;
var lastTurn = Program.GameEngine.TurnNumber;
Program.GameEngine.TurnNumber++;
Program.GameEngine.ActivePlayer = (setActive) ? player : null;
Program.GameEngine.StopTurn = false;
Program.GameEngine.CurrentPhase = null;
Program.GameMess.Turn(Program.GameEngine.ActivePlayer, Program.GameEngine.TurnNumber);
Program.GameEngine.EventProxy.OnTurn_3_1_0_0(player, Program.GameEngine.TurnNumber);
Program.GameEngine.EventProxy.OnTurn_3_1_0_1(player, Program.GameEngine.TurnNumber);
Program.GameEngine.EventProxy.OnTurnPassed_3_1_0_2(lastPlayer, lastTurn, force);
}
public void Leave(Player player)
{
Program.GameMess.System("{0} has closed their game window left the game. They did not crash or lose connection, they left on purpose.", player);
if (!Program.InPreGame)
{
Program.GameEngine.EventProxy.OnPlayerLeaveGame_3_1_0_1(player);
Program.GameEngine.EventProxy.OnPlayerQuit_3_1_0_2(player);
}
player.Delete();
if (Program.IsHost && Program.InPreGame)
{
Sounds.PlaySound(Properties.Resources.doorclose);
}
}
public void End()
{
Program.GameMess.OnMessage -= GameMess_OnMessage;
SaveHistory();
ReplayWriter?.Dispose();
ReplayEngine?.Dispose();
_logStream?.Dispose();
Program.GameEngine = null;
Player.Reset();
Card.Reset();
CardIdentity.Reset();
Selection.Clear();
}
public string PlayerGetGlobalVariable(int id, string name)
{
Player p = Player.Find((byte)id);
if (p == null)
{
return("");
}
if (p.GlobalVariables.ContainsKey(name) == false)
{
Program.GameMess.Warning("Global variable '{0}' isn't defined for player '{1}'", name, p.Name);
return("");
}
return(p.GlobalVariables[name]);
}
public void OnChangeCounter(Player player, Counter counter, int oldValue)
{
var args = new object[3];
args[0] = player;
args[1] = counter;
args[2] = oldValue;
if(Program.GameEngine.Definition.Events.ContainsKey("OnChangeCounter"))
{
foreach(var e in Program.GameEngine.Definition.Events["OnChangeCounter"])
{
engine.ExecuteFunction(e.PythonFunction,player, counter, oldValue);
}
}
}
public void OnEndTurn(Player player)
{
Log.Info("Firing event OnEndTurn");
var args = new object[1];
args[0] = player;
if(Program.GameEngine.Definition.Events.ContainsKey("OnEndTurn"))
{
foreach(var e in Program.GameEngine.Definition.Events["OnEndTurn"])
{
Log.InfoFormat("Firing event OnEndTurn -> {0}",e.Name);
engine.ExecuteFunction(e.PythonFunction,player);
}
}
}
public void GameStateReq(Player fromPlayer)
{
Log.DebugFormat("GameStateReq From {0}", fromPlayer);
try
{
var ps = new GameSaveState().Create(Program.GameEngine, fromPlayer);
var str = JsonConvert.SerializeObject(ps, Formatting.None);
Program.Client.Rpc.GameState(fromPlayer, str);
}
catch (Exception e)
{
Log.Error("GameStateReq Error", e);
}
}
public void RemoveMarker(Player player, Card card, string id, string name, ushort count, ushort oldCount, bool isScriptChange)
{
WriteReplayAction(player.Id);
var marker = card.FindMarker(id, name);
if (!IsLocalPlayer(player))
{
if (marker == null)
{
Program.GameMess.Warning("Inconsistent state. Marker not found on card.");
return;
}
if (marker.Count != oldCount)
{
Program.GameMess.Warning("Inconsistent state. Missing markers to remove");
}
}
if (count != 0)
{
var newCount = oldCount - count;
if (!IsLocalPlayer(player))
{
card.RemoveMarker(marker, count);
}
Program.GameMess.PlayerEvent(player, "removes {0} {1} marker(s) from {2}", count, name, card);
if (IsLocalPlayer(player) && marker == null)
{
var markerString = new StringBuilder();
markerString.AppendFormat("('{0}','{1}')", name, id);
if (isScriptChange == false)
{
Program.GameEngine.EventProxy.OnMarkerChanged_3_1_0_0(card, markerString.ToString(), oldCount, newCount, isScriptChange);
Program.GameEngine.EventProxy.OnMarkerChanged_3_1_0_1(card, markerString.ToString(), oldCount, newCount, isScriptChange);
}
Program.GameEngine.EventProxy.OnMarkerChanged_3_1_0_2(card, name, id.ToString(), oldCount, isScriptChange);
}
else
{
if (isScriptChange == false)
{
Program.GameEngine.EventProxy.OnMarkerChanged_3_1_0_0(card, marker.Model.ModelString(), oldCount, newCount, isScriptChange);
Program.GameEngine.EventProxy.OnMarkerChanged_3_1_0_1(card, marker.Model.ModelString(), oldCount, newCount, isScriptChange);
}
Program.GameEngine.EventProxy.OnMarkerChanged_3_1_0_2(card, name, id.ToString(), oldCount, isScriptChange);
}
}
}
internal static Tuple <string, object[]> Parse(Player player, string text)
{
string finalText = text;
int i = 0;
var args = new List <object>(2);
Match match = Regex.Match(text, "{([^}]*)}");
while (match.Success)
{
string token = match.Groups[1].Value;
finalText = finalText.Replace(match.Groups[0].Value, "##$$%%^^LEFTBRACKET^^%%$$##" + i + "##$$%%^^RIGHTBRACKET^^%%$$##");
i++;
object tokenValue = token;
switch (token)
{
case "me":
tokenValue = player;
break;
default:
if (token.StartsWith("#"))
{
int id;
if (!int.TryParse(token.Substring(1), out id))
{
break;
}
ControllableObject obj = ControllableObject.Find(id);
if (obj == null)
{
break;
}
tokenValue = obj;
break;
}
break;
}
args.Add(tokenValue);
match = match.NextMatch();
}
args.Add(player);
finalText = finalText.Replace("{", "").Replace("}", "");
finalText = finalText.Replace("##$$%%^^LEFTBRACKET^^%%$$##", "{").Replace(
"##$$%%^^RIGHTBRACKET^^%%$$##", "}");
return(new Tuple <string, object[]>(finalText, args.ToArray()));
}
public void PlayerSetGlobalVariable(Player p, string name, string oldValue, string value)
{
if (p.GlobalVariables.ContainsKey(name))
{
p.GlobalVariables[name] = value;
}
else
{
p.GlobalVariables.Add(name, value);
}
if (p != Player.LocalPlayer)
{
Program.GameEngine.EventProxy.OnPlayerGlobalVariableChanged_3_1_0_0(p, name, oldValue, value);
Program.GameEngine.EventProxy.OnPlayerGlobalVariableChanged_3_1_0_1(p, name, oldValue, value);
}
Program.GameEngine.EventProxy.OnPlayerGlobalVariableChanged_3_1_0_2(p, name, oldValue, value);
}
public void CardSwitchTo(Player player, Card card, string alternate)
{
MemoryStream stream = new MemoryStream(512);
stream.Seek(4, SeekOrigin.Begin);
BinaryWriter writer = new BinaryWriter(stream);
if (Program.Client.Muted != 0)
writer.Write(Program.Client.Muted);
else
writer.Write(0);
writer.Write((byte)87);
writer.Write(player.Id);
writer.Write(card.Id);
writer.Write(alternate);
writer.Flush(); writer.Seek(0, SeekOrigin.Begin);
writer.Write((int)stream.Length);
writer.Close();
Send(stream.ToArray());
}
public void GroupRemoveViewer(int id, int pid)
{
Group group = Group.Find(id);
Player player = Player.Find((byte)pid);
if (group.Controller != Player.LocalPlayer)
{
Program.GameMess.Warning("{0} can't set visibility on {0} because they don't control it.", Player.LocalPlayer.Name, group.Name);
return;
}
if (!group.Viewers.Contains(player))
{
return;
}
else
{
QueueAction(() => group.RemoveViewer(player, true));
}
}
public void Boot(Player player, string reason)
{
//Log.Info("[ProtOut] Boot");
if(Program.Client == null)return;
MemoryStream stream = new MemoryStream(512);
stream.Seek(4, SeekOrigin.Begin);
BinaryWriter writer = new BinaryWriter(stream);
if (Program.Client.Muted != 0)
writer.Write(Program.Client.Muted);
else
writer.Write(0);
writer.Write((byte)2);
writer.Write(player.Id);
writer.Write(reason);
writer.Flush(); writer.Seek(0, SeekOrigin.Begin);
writer.Write((int)stream.Length);
writer.Close();
Send(stream.ToArray());
}
/// <summary>Creates new Cards as well as the corresponding CardIdentities. The cards may be in different groups.</summary>
/// <param name="id">An array with the new CardIdentity ids.</param>
/// <param name="type">An array containing the corresponding CardModel guids (encrypted)</param>
/// <param name="groups">An array indicating the group the cards must be loaded into.</param>
/// <seealso cref="CreateCard(int[], ulong[], Group)"> for a more efficient way to insert cards inside one group.</seealso>
private static void CreateCard(IList <int> id, IList <Guid> type, IList <Group> groups, IList <string> sizes, string sleeveUrl = "")
{
// Ignore cards created by oneself
if (Player.Find((byte)(id[0] >> 16)) == Player.LocalPlayer)
{
return;
}
for (var i = 0; i < id.Count; i++)
{
var group = groups[i];
var owner = group.Owner;
if (owner == null)
{
Program.GameMess.Warning("[CreateCard] Player not found.");
continue;
}
var c = new Card(owner, id[i], Program.GameEngine.Definition.GetCardById(type[i]), false, sizes[i]); c.SetSleeve(sleeveUrl); group.AddAt(c, group.Count);
}
}
public void AddPacks(Player player, Guid[] packs, bool selfOnly)
{
var wnd = (Play.Dialogs.PickCardsDialog)WindowManager.PlayWindow.backstage.Child;
string packNames = wnd.PackNames(packs);
if (packNames == "") return;
if (selfOnly && player != Player.LocalPlayer)
{
Program.TracePlayerEvent(player, "{0} added {1} to their pool.", player, packNames);
}
else if (selfOnly && player == Player.LocalPlayer)
{
Program.TracePlayerEvent(player, "{0} added {1} to their pool.", player, packNames);
wnd.OpenPacks(packs);
}
else
{
Program.TracePlayerEvent(player, "{0} added {1} to the limited game for all players.", player, packNames);
wnd.OpenPacks(packs);
}
}
public void AnchorCard(Card id, Player player, bool anchor)
{
//Log.Info("[ProtOut] AnchorCard");
if(Program.Client == null)return;
MemoryStream stream = new MemoryStream(512);
stream.Seek(4, SeekOrigin.Begin);
BinaryWriter writer = new BinaryWriter(stream);
if (Program.Client.Muted != 0)
writer.Write(Program.Client.Muted);
else
writer.Write(0);
writer.Write((byte)97);
writer.Write(id.Id);
writer.Write(player.Id);
writer.Write(anchor);
writer.Flush(); writer.Seek(0, SeekOrigin.Begin);
writer.Write((int)stream.Length);
writer.Close();
Send(stream.ToArray());
}
public void NewPlayer(byte id, string nick, string userId, ulong pkey, bool invertedTable, bool spectator)
{
WriteReplayAction(id);
var p = Player.FindIncludingSpectators(id);
if (p == null)
{
var player = new Player(Program.GameEngine.Definition, nick, userId, id, pkey, spectator, false, Program.GameEngine.IsReplay);
Program.GameMess.System("{0} has joined the game", player);
player.UpdateSettings(invertedTable, spectator, false);
if (Program.InPreGame == false)
{
GameStateReq(player);
if (player.Spectator == false)
{
Program.GameEngine.EventProxy.OnPlayerConnect_3_1_0_1(player);
Program.GameEngine.EventProxy.OnPlayerConnected_3_1_0_2(player);
}
}
else
{
if (Octgn.Core.Prefs.SoundOption == Core.Prefs.SoundType.DingDong)
{
Sounds.PlaySound(Properties.Resources.userjoinsroom, false);
}
else if (Octgn.Core.Prefs.SoundOption == Core.Prefs.SoundType.KnockKnock)
{
Sounds.PlaySound(Properties.Resources.knockknock, false);
}
}
}
else
{
if (p.Spectator == false && Program.InPreGame == false)
{
Program.GameEngine.EventProxy.OnPlayerConnect_3_1_0_1(p);
Program.GameEngine.EventProxy.OnPlayerConnected_3_1_0_2(p);
}
}
}
public void GroupSetController(int id, int player)
{
var g = Group.Find(id);
var p = Player.Find((byte)player);
if (p == Player.LocalPlayer)
{
if (g.Controller == Player.LocalPlayer)
{
return;
}
QueueAction(() => g.TakeControl());
}
else
{
if (g.Controller != Player.LocalPlayer)
{
return;
}
QueueAction(() => g.PassControlTo(p));
}
}
/// <summary>Creates new Cards as well as the corresponding CardIdentities. All cards are created in the same group.</summary>
/// <param name="id">An array with the new CardIdentity ids.</param>
/// <param name="type">An array containing the corresponding CardModel guids (encrypted)</param>
/// <param name="group">The group, in which the cards are added.</param>
/// <seealso cref="CreateCard(int[], ulong[], Group[])"> to add cards to several groups</seealso>
public void CreateCard(int[] id, Guid[] type, string[] size, Group group)
{
if (Player.Find((byte)(id[0] >> 16)) == Player.LocalPlayer)
{
return;
}
for (var i = 0; i < id.Length; i++)
{
var owner = group.Owner;
if (owner == null)
{
Program.GameMess.Warning("[CreateCard] Player not found.");
return;
}
var c = Card.Find(id[0]);
Program.GameMess.PlayerEvent(owner, "{0} creates {1} {2} in {3}'s {4}", owner.Name, id.Length, c == null ? "card" : (object)c, group.Owner.Name, group.Name);
// Ignore cards created by oneself
var card = new Card(owner, id[i], Program.GameEngine.Definition.GetCardById(type[i]), false, size[i]); group.AddAt(card, group.Count);
}
}
internal static void TracePlayerEvent(Player player, string message, params object[] args)
{
var args1 = new List<object>(args) {player};
Trace.TraceEvent(TraceEventType.Information, EventIds.Event | EventIds.PlayerFlag(player), message,
args1.ToArray());
}
public void StartLimited(Player player, Guid[] packs)
{
Program.TracePlayerEvent(player, "{0} starts a limited game.", player);
var wnd = new Play.Dialogs.PickCardsDialog();
WindowManager.PlayWindow.ShowBackstage(wnd);
wnd.OpenPacks(packs);
}
public void StopTurn(Player player)
{
if (player == Player.LocalPlayer)
Program.GameEngine.StopTurn = false;
Program.Trace.TraceEvent(TraceEventType.Information, EventIds.Event | EventIds.PlayerFlag(player), "{0} wants to play before end of turn.", player);
}
public void TakeFrom(ControllableObject obj, Player to)
{
obj.TakingControl(to);
}
public void TargetArrow(Player player, Card card, Card otherCard)
{
// Ignore the card we targeted ourselves
if (player == Player.LocalPlayer) return;
new Target(player, card, otherCard, true).Do();
}
/// <summary>Reveal a card's identity to one player only.</summary>
/// <param name="players"> </param>
/// <param name="card">The card, whose identity is revealed.</param>
/// <param name="encrypted">Either a ulong[2] containing an encrypted aliased CardIdentity id. Or a ulong[5] containing an encrypted CardModel guid.</param>
public void RevealTo(Player[] players, Card card, ulong[] encrypted)
{
var oldType = card.Type;
ulong alias = 0;
Guid id = Guid.Empty;
players = players.Where(x => x != null).ToArray();
switch (encrypted.Length)
{
case 2:
alias = Crypto.Decrypt(encrypted);
break;
case 5:
id = Crypto.DecryptGuid(encrypted);
break;
default:
Program.TraceWarning("[RevealTo] Invalid data received.");
return;
}
if (!players.All(p => (card.Group.Visibility == DataNew.Entities.GroupVisibility.Custom && card.Group.Viewers.Contains(p)) ||
card.PlayersLooking.Contains(p) || card.PeekingPlayers.Contains(p)))
Program.TraceWarning("[RevealTo] Revealing a card to a player, who isn't allowed to see it. This indicates a bug or cheating.");
// If it's an alias, we must revealed it to the final recipient
bool sendToMyself = true;
if (alias != 0)
{
sendToMyself = false;
CardIdentity ci = CardIdentity.Find((int)alias);
if (ci == null)
{ Program.TraceWarning("[RevealTo] Identity not found."); return; }
// If the revealed type is an alias, pass it to the one who owns it to continue the RevealTo chain.
if (ci.Alias)
{
Player p = Player.Find((byte)(ci.Key >> 16));
Program.Client.Rpc.RevealToReq(p, players, card, Crypto.Encrypt(ci.Key, p.PublicKey));
}
// Else revealed the card model to the ones, who must see it
else
{
Player[] pArray = new Player[1];
foreach (Player p in players)
if (p != Player.LocalPlayer)
{
pArray[0] = p;
Program.Client.Rpc.RevealToReq(p, pArray, card, Crypto.Encrypt(ci.Model.Id, p.PublicKey));
}
else
{
sendToMyself = true;
id = ci.Model.Id;
}
}
}
// Else it's a type and we are the final recipients
if (!sendToMyself) return;
if (card.Type.Model == null)
card.SetModel(Program.GameEngine.Definition.GetCardById(id));
// Raise a notification
oldType.OnRevealed(card.Type);
}
public void TransferMarker(Player player, Card from, Card to, Guid id, string name, ushort count)
{
// Ignore markers moved by oneself (already moved for responsiveness issues)
if (player != Player.LocalPlayer)
{
Marker marker = from.FindMarker(id, name);
if (marker == null)
{
Program.Trace.TraceEvent(TraceEventType.Warning, EventIds.NonGame, "Inconsistent state. Marker not found on card.");
return;
}
if (marker.Count < count)
Program.Trace.TraceEvent(TraceEventType.Warning, EventIds.NonGame, "Inconsistent state. Missing markers to remove");
from.RemoveMarker(marker, count);
to.AddMarker(marker.Model, count);
}
Program.Trace.TraceEvent(TraceEventType.Information, EventIds.Event | EventIds.PlayerFlag(player), "{0} moves {1} {2} marker(s) from {3} to {4}", player, count, name, from, to);
}
public void Chat(Player player, string text)
{
Program.Trace.TraceEvent(TraceEventType.Information, EventIds.Chat | EventIds.PlayerFlag(player), "<{0}> {1}", player, text);
}
public void Counter(Player player, Counter counter, int value)
{
counter.SetValue(value, player, false);
}
public void Turn(Player player, Card card, bool up)
{
// Ignore the card we turned ourselves
if (player == Player.LocalPlayer)
{
card.MayBeConsideredFaceUp = false; // see comment on mayBeConsideredFaceUp
return;
}
new Turn(player, card, up).Do();
}
internal static void Print(Player player, string text)
{
string finalText = text;
int i = 0;
var args = new List<object>(2);
Match match = Regex.Match(text, "{([^}]*)}");
while (match.Success)
{
string token = match.Groups[1].Value;
finalText = finalText.Replace(match.Groups[0].Value, "##$$%%^^LEFTBRACKET^^%%$$##" + i + "##$$%%^^RIGHTBRACKET^^%%$$##");
i++;
object tokenValue = token;
switch (token)
{
case "me":
tokenValue = player;
break;
default:
if (token.StartsWith("#"))
{
int id;
if (!int.TryParse(token.Substring(1), out id)) break;
ControllableObject obj = ControllableObject.Find(id);
if (obj == null) break;
tokenValue = obj;
break;
}
break;
}
args.Add(tokenValue);
match = match.NextMatch();
}
args.Add(player);
finalText = finalText.Replace("{", "").Replace("}", "");
finalText = finalText.Replace("##$$%%^^LEFTBRACKET^^%%$$##", "{").Replace(
"##$$%%^^RIGHTBRACKET^^%%$$##", "}");
Trace.TraceEvent(TraceEventType.Information,
EventIds.Event | EventIds.PlayerFlag(player) | EventIds.Explicit, finalText, args.ToArray());
}
public void Untarget(Player player, Card card)
{
// Ignore the card we targeted ourselves
if (player == Player.LocalPlayer) return;
new Target(player, card, null, false).Do();
}
public void Rotate(Player player, Card card, CardOrientation rot)
{
// Ignore the moves we made ourselves
if (player == Player.LocalPlayer)
return;
new Rotate(player, card, rot).Do();
}
public void SetMarker(Player player, Card card, Guid id, string name, ushort count)
{
// Always perform this call (even if player == LocalPlayer) for consistency as markers aren't an exclusive resource
card.SetMarker(player, id, name, count);
}
