static void Main(string[] args)
{
Console.WriteLine("Welcome to Splendor");
var playerControls = new IPlayerControl[]
{
new RandomPlayer("Random 1"),
// new GreedyPlayer("Greedy 1"),
// new GreedyPlayer("Greedy 2"),
// new GreedyPlayer("Greedy 3"),
// new GreedyPlayer("Greedy 4"),
new RandomPlayer("Random 2"),
new RandomPlayer("Random 3"),
};
var statelmates = 0;
for (int i = 0; i < 10000; i++)
{
if (i % 1000 == 0)
{
Console.WriteLine("Game: " + i);
}
PlayGame(playerControls, ref statelmates);
}
Console.WriteLine($"Stalemates: {statelmates}");
Console.WriteLine("Wins:");
foreach (var player in playerControls)
{
Console.WriteLine($"{player.Name}: {player.Wins}");
}
}
// private bool bJumping = false;
public StateManager(IPlayerControl _player)
{
player = _player;
defaultIdle = new IdleState(player);
currentState = defaultIdle;
nextState = defaultIdle;
}
private void Awake()
{
transform.GetChild(0).TryGetComponent(out animator);
switch (playerNumber)
{
case PlayerEnum.Player1:
inputs = new Player1Control();
if (Gamepad.all.Count > 0)
{
Debug.Log("Hey");
var user = InputUser.PerformPairingWithDevice(Gamepad.all[0]);
user.AssociateActionsWithUser(inputs.InputAction);
user.ActivateControlScheme("Gamepad");
}
break;
case PlayerEnum.Player2:
inputs = new Player2Control();
if (Gamepad.all.Count > 1)
{
var user = InputUser.PerformPairingWithDevice(Gamepad.all[1]);
user.AssociateActionsWithUser(inputs.InputAction);
user.ActivateControlScheme("Gamepad");
}
break;
default:
break;
}
inputs.Enable();
inputs.Move += OnMove;
inputs.Attack += OnAttack;
animEvent.OnAttackStart += OnAttackStart;
animEvent.OnAttackEnd += OnAttackEnd;
}
public ThreePlayersPlayerHelper(IPlayerControl control)
: base(control)
{
Role myRole = control.PrivatePlayerView.Role;
Role enemyRole, allyRole;
switch(myRole)
{
case Role.Deputy:
enemyRole = Role.Renegade;
allyRole = Role.Outlaw;
break;
case Role.Renegade:
enemyRole = Role.Outlaw;
allyRole = Role.Deputy;
break;
case Role.Outlaw:
enemyRole = Role.Deputy;
allyRole = Role.Renegade;
break;
default:
Console.Error.WriteLine("FATAL: Invalid role for a three-player game!");
throw new InvalidOperationException();
}
enemyId = control.Game.Players.First(p => p.Role == enemyRole).ID;
allyId = control.Game.Players.First(p => p.Role == allyRole).ID;
}
public StandardPlayerHelper(IPlayerControl control)
: base(control)
{
int playerCount = Game.Players.Count;
switch(playerCount)
{
case 4:
unknownRoles = new List<Role> { Role.Outlaw, Role.Outlaw, Role.Renegade };
break;
case 5:
unknownRoles = new List<Role> { Role.Deputy, Role.Outlaw, Role.Outlaw, Role.Renegade };
break;
case 6:
unknownRoles = new List<Role> { Role.Deputy, Role.Outlaw, Role.Outlaw, Role.Outlaw, Role.Renegade };
break;
case 7:
unknownRoles = new List<Role> { Role.Deputy, Role.Deputy, Role.Outlaw, Role.Outlaw, Role.Outlaw, Role.Renegade };
break;
case 8:
unknownRoles = new List<Role> { Role.Deputy, Role.Deputy, Role.Outlaw, Role.Outlaw, Role.Outlaw, Role.Renegade, Role.Renegade };
break;
default:
throw new InvalidOperationException();
}
entries = new Dictionary<int, PlayerEntry>(playerCount);
foreach(IPublicPlayerView p in Game.Players)
{
entries.Add(p.ID, new PlayerEntry(this, p));
unknownRoles.Remove(entries[p.ID].EstimatedRole);
}
IPrivatePlayerView thisPlayer = ThisPlayer;
if(entries[thisPlayer.ID].EstimatedRole == Role.Unknown)
unknownRoles.Remove(entries[thisPlayer.ID].EstimatedRole = thisPlayer.Role);
}
public EntityLabel(
IPlayerControl playerControl,
string interactAction,
Label titleLabel,
Option <Label> shortcutLabel,
Option <Label> actionLabel,
Option <Godot.Control> actionPanel,
ITimeSource timeSource,
Godot.Control node,
ILoggerFactory loggerFactory) : base(node, loggerFactory)
{
Ensure.That(playerControl, nameof(playerControl)).IsNotNull();
Ensure.That(interactAction, nameof(interactAction)).IsNotNull();
Ensure.That(titleLabel, nameof(titleLabel)).IsNotNull();
Ensure.That(timeSource, nameof(timeSource)).IsNotNull();
PlayerControl = playerControl;
InteractAction = interactAction;
TitleLabel = titleLabel;
ShortcutLabel = shortcutLabel;
ActionLabel = actionLabel;
ActionPanel = actionPanel;
TimeSource = timeSource;
InteractAction = interactAction;
}
//unity
private void Start()
{
//set init values
difficulty = 1;
#if UNITY_WEBGL && !UNITY_EDITOR
float sensitivity = 0.55f;
#else
float sensitivity = 0.5f;
#endif
bool sound = false;
//setup control
#if UNITY_ANDROID && !UNITY_EDITOR
control = gameObject.AddComponent <GyroControl>();
uiManager = new UIWithTaps(UIManagerFactory.getInstance().CreateBig());
#else
control = gameObject.AddComponent <SliderControl>();
// uiManager = new UIWithKeyHandler(UIManagerFactory.getInstance().Create());
uiManager = new UIWithTaps(UIManagerFactory.getInstance().CreateBig());
#endif
control.SetSensitivity(sensitivity);
//setup physics
physics = new GamePhysics();
physics.SetDifficulty(difficulty);
//setup score
score = new GameScore();
score.SetDifficulty(difficulty);
uiManager.onMenuCommand += OnMenuCommand;
uiManager.Initialize(difficulty, sound, sensitivity);
//uiManager.MakeFlexible(true);
soundManager.Play(sound);
PauseGame(true);
}
protected override Validation <string, GameMenu> CreateService(
Option <string> closeAction,
IPlayerControl playerControl,
Godot.Control node,
ILoggerFactory loggerFactory)
{
return(new GameMenu(PauseWhenVisible, closeAction, playerControl, node, loggerFactory));
}
public GameMenu(
bool pauseWhenVisible,
Option <string> closeAction,
IPlayerControl playerControl,
Godot.Control node,
ILoggerFactory loggerFactory) : base(pauseWhenVisible, closeAction, playerControl, node, loggerFactory)
{
}
public PlayerPresenter(IPlayerControl ctrl)
{
view = ctrl;
usersRepository = new PlayerRepository();
usersList = new List <PlayerDTO>();
usersList = usersRepository.GetAll().ToList();
showingCount = usersList.Count;
view.DrawUsersTable(usersList);
}
public PlayerPresenter(IPlayerControl ctrl)
{
view = ctrl;
usersRepository = new PlayerRepository();
usersList = new List<PlayerDTO>();
usersList = usersRepository.GetAll().ToList();
showingCount = usersList.Count;
view.DrawUsersTable(usersList);
}
protected FullScreenModalPanel(
bool pauseWhenVisible,
Option <string> closeAction,
IPlayerControl playerControl,
Godot.Control node,
ILoggerFactory loggerFactory) : base(node, loggerFactory)
{
Ensure.That(playerControl, nameof(playerControl)).IsNotNull();
PauseWhenVisible = pauseWhenVisible;
CloseAction = closeAction;
PlayerControl = playerControl;
}
public static T SwitchPerspective <T>([NotNull] this IPlayerControl control) where T : IPerspectiveView
{
Ensure.Any.IsNotNull(control, nameof(control));
var perspective = control.Perspectives.OfType <T>().FirstOrDefault(p => p.Valid && !p.Active);
if (perspective != null)
{
control.Perspective = perspective;
}
return(perspective);
}
public InventoryView(
IPlayerControl playerControl,
InspectingView viewControl,
MeshInstance itemStand,
bool pauseWhenVisible,
Option <string> closeAction,
Godot.Control node,
Tree tree,
Container buttonContainer,
Panel infoPanel,
Label titleLabel,
Option <Label> typeLabel,
Option <RichTextLabel> descriptionLabel,
PackedScene actionButton,
ILoggerFactory loggerFactory) : base(pauseWhenVisible, closeAction, playerControl, node, loggerFactory)
{
Ensure.That(viewControl, nameof(viewControl)).IsNotNull();
Ensure.That(tree, nameof(tree)).IsNotNull();
Ensure.That(itemStand, nameof(itemStand)).IsNotNull();
Ensure.That(buttonContainer, nameof(buttonContainer)).IsNotNull();
Ensure.That(infoPanel, nameof(infoPanel)).IsNotNull();
Ensure.That(titleLabel, nameof(titleLabel)).IsNotNull();
Ensure.That(actionButton, nameof(actionButton)).IsNotNull();
ViewControl = viewControl;
Tree = tree;
ButtonContainer = buttonContainer;
ItemStand = itemStand;
InfoPanel = infoPanel;
TitleLabel = titleLabel;
TypeLabel = typeLabel;
DescriptionLabel = descriptionLabel;
ActionButton = actionButton;
_buttonListeners = new CompositeDisposable();
OnEquipmentContainerChange = PlayerControl.OnCharacterChange
.Select(c => c.Select(v => v.Equipments).ToObservable())
.Switch();
OnItemsChange = OnEquipmentContainerChange
.Select(c => c.OnItemsChange)
.Switch();
OnSelectionChange = Tree.OnItemSelect()
.Select(v => v.Bind(i => Optional(i.GetMeta(SlotKey) as string)))
.Merge(OnItemsChange.Select(_ => Option <string> .None))
.CombineLatest(OnEquipmentContainerChange, (slot, slots) => (slot, slots))
.Select(t => t.slot.Bind(s => t.slots.FindItemInSlot(s)).HeadOrNone())
.Do(current => Selected = current);
}
protected override Validation <string, InventoryView> CreateService(
Option <string> closeAction,
IPlayerControl playerControl,
Godot.Control node,
ILoggerFactory loggerFactory)
{
return
(from viewControl in ViewControl
.ToValidation("Failed to find the view control.")
from itemStand in ItemStand
.ToValidation("Failed to find the item stand.")
from tree in Tree
.ToValidation("Failed to find the tree view.")
from buttonContainer in Buttons
.ToValidation("Failed to find the button container.")
from infoPanel in InfoPanel
.ToValidation("Failed to find the information panel.")
from titleLabel in Title
.ToValidation("Failed to find the title label.")
from actionButton in Optional(ActionButton)
.ToValidation("Failed to find action button template.")
select new InventoryView(
playerControl,
viewControl,
itemStand,
PauseWhenVisible,
closeAction,
node,
tree,
buttonContainer,
infoPanel,
titleLabel,
Type,
Description,
actionButton,
loggerFactory));
}
void Attack(UnitController[] targets, IPlayerControl owner)
{
List <Transform> trn = new List <Transform>();
for (int i = 0; i < targets.Length; i++)
{
owner.Damage(targets[i], order[index].damage / targets.Length);
trn.Add(targets[i].transform);
Debug.Log(order[index].name + " aims at " + targets[i].name);
}
if (trn.Count > 0)
{
FireWeapon fire = order[index].GetComponent <FireWeapon>();
//fire.onDone = ()=>NextCombatant();
fire.Shoot(trn.ToArray(), 3);
LeanTween.delayedCall(gameObject, 3, () => NextCombatant());
}
else
{
NextCombatant();
Debug.Log(order[index].name + " has no targets in range");
}
}
public override void OnJoinedGame(IPlayerControl control)
{
Gdk.Threads.Enter();
parent.Update();
Gdk.Threads.Leave();
Animation anim = new Animation(parent);
IPrivatePlayerView privateView = control.PrivatePlayerView;
IGame game = control.Game;
int thisPlayerId = control.PrivatePlayerView.ID;
foreach(IPublicPlayerView player in game.Players)
{
int playerId = player.ID;
if(playerId == thisPlayerId)
{
anim.EndAllocManager.SetPlayerLifepoints(playerId, privateView.LifePoints);
anim.GetPlayerCharacterAnimator(playerId).EndState.Type = privateView.CharacterType;
anim.GetPlayerRoleAnimator(playerId).EndState.Role = privateView.Role;
foreach(ICard card in privateView.Hand)
{
int cardId = card.ID;
anim.EndAllocManager.AddPlayerHandCard(playerId, cardId);
PlayingCardAnimator a = anim.GetPlayingCardAnimator(cardId);
a.EndState.Type = card.Type;
a.EndState.Rank = card.Rank;
a.EndState.Suit = card.Suit;
}
foreach(ICard card in privateView.Table)
{
int cardId = card.ID;
anim.EndAllocManager.AddPlayerTableCard(playerId, cardId);
PlayingCardAnimator a = anim.GetPlayingCardAnimator(cardId);
a.EndState.Type = card.Type;
a.EndState.Rank = card.Rank;
a.EndState.Suit = card.Suit;
}
foreach(ICard card in privateView.Selection)
{
int cardId = card.ID;
anim.EndAllocManager.AddSelectionCard(cardId);
PlayingCardAnimator a = anim.GetPlayingCardAnimator(cardId);
a.EndState.Type = card.Type;
a.EndState.Rank = card.Rank;
a.EndState.Suit = card.Suit;
}
}
else
{
anim.EndAllocManager.SetPlayerLifepoints(playerId, player.LifePoints);
anim.GetPlayerCharacterAnimator(playerId).EndState.Type = player.CharacterType;
anim.GetPlayerRoleAnimator(playerId).EndState.Role = player.Role;
foreach(ICard card in player.Hand)
{
int cardId = card.ID;
anim.EndAllocManager.AddPlayerHandCard(playerId, cardId);
PlayingCardAnimator a = anim.GetPlayingCardAnimator(cardId);
a.EndState.Type = card.Type;
a.EndState.Rank = card.Rank;
a.EndState.Suit = card.Suit;
}
foreach(ICard card in player.Table)
{
int cardId = card.ID;
anim.EndAllocManager.AddPlayerTableCard(playerId, cardId);
PlayingCardAnimator a = anim.GetPlayingCardAnimator(cardId);
a.EndState.Type = card.Type;
a.EndState.Rank = card.Rank;
a.EndState.Suit = card.Suit;
}
}
}
ICard graveyardTop = game.GraveyardTop;
if(graveyardTop != null)
{
int cardId = graveyardTop.ID;
anim.EndAllocManager.AddGraveyardCard(cardId);
PlayingCardAnimator a = anim.GetPlayingCardAnimator(cardId);
a.EndState.Type = graveyardTop.Type;
a.EndState.Rank = graveyardTop.Rank;
a.EndState.Suit = graveyardTop.Suit;
}
parent.EnqueueAnimation(anim);
}
public CardHelper(IPlayerControl control)
{
this.control = control;
}
void ISessionEventListener.OnGameEnded()
{
control = null;
playerHelper = null;
cardHelper = null;
}
void IPlayerSessionEventListener.OnJoinedGame(IPlayerControl control)
{
this.gameControl = control;
ConsoleHelper.GameEvent("Acquired game controller!");
}
public MeleeToolConfiguration(
string key,
string slot,
Set <string> additionalSlots,
Set <string> tags,
Option <IInputBindings> armInput,
Option <IInputBindings> swingInput,
Godot.Animation swingAnimation,
string statesPath,
string seekerPath,
string idleState,
string swingState,
Range <float> animationRange,
IPlayerControl playerControl,
bool active,
ILoggerFactory loggerFactory) : base(key, slot, additionalSlots, tags, active, loggerFactory)
{
Ensure.That(swingAnimation, nameof(swingAnimation)).IsNotNull();
Ensure.That(statesPath, nameof(statesPath)).IsNotNullOrEmpty();
Ensure.That(seekerPath, nameof(seekerPath)).IsNotNullOrEmpty();
Ensure.That(idleState, nameof(idleState)).IsNotNullOrEmpty();
Ensure.That(swingState, nameof(swingState)).IsNotNullOrEmpty();
Ensure.That(playerControl, nameof(playerControl)).IsNotNull();
SwingAnimation = swingAnimation;
StatesPath = statesPath;
SeekerPath = seekerPath;
IdleState = idleState;
SwingState = swingState;
AnimationRange = animationRange;
PlayerControl = playerControl;
OnPlayerChange = OnHolderChange
.CombineLatest(PlayerControl.OnCharacterChange, (h, p) => h.Filter(v => p.Contains(v)))
.Select(p => p.ToObservable())
.Switch();
SwingInput = swingInput
.Bind(i => i.AsVector2Input())
.MatchObservable(identity, Empty <Vector2>)
.Where(_ => Valid)
.Select(v => v * 2f);
ArmInput = armInput.Bind(i => i.FindTrigger().HeadOrNone())
.MatchObservable(identity, Empty <bool>)
.Where(_ => Valid);
var manager = OnPlayerChange
.Select(p => p.AnimationManager)
.OfType <IAnimationStateManager>();
var states = manager
.Select(m => m.FindStates(StatesPath).ToObservable())
.Switch();
var seeker = manager
.Select(m => m.FindSeekableAnimator(SeekerPath).ToObservable())
.Switch();
var blender = manager
.Select(m => AnimationBlend.Bind(m.FindBlender).ToObservable())
.Switch();
OnArm = OnPlayerChange
.Select(_ => ArmInput.Where(identity))
.Switch()
.AsUnitObservable()
.WithLatestFrom(states, (a, s) => s.State == IdleState ? Return(a) : Empty <Unit>())
.Switch();
OnDisarm = Merge(
ArmInput.Where(v => !v).AsUnitObservable(),
OnHolderChange.Where(v => v.IsNone).AsUnitObservable(),
Disposed.Where(identity).AsUnitObservable())
.WithLatestFrom(states, (a, s) => s.State == SwingState ? Return(a) : Empty <Unit>())
.Switch();
OnSwing = OnArm
.Select(_ => SwingInput.TakeUntil(OnDisarm).Select(v => v.y).DistinctUntilChanged())
.Switch()
.Scan(0f, (s, v) => Mathf.Clamp(s + v, 0f, 600f))
.Select(v => v / 600f);
bool Conflicts(IInput input) => swingInput.Bind(i => i.Inputs.Values).Exists(input.ConflictsWith);
ConflictingInputs = playerControl.Inputs.Filter(i => i.Active).Filter(Conflicts);
}
public void OnJoinedGame(IPlayerControl control)
{
foreach(IPlayerSessionEventListener listener in playerListeners.ToArray())
listener.OnJoinedGame(control);
}
public static IThirdPersonView SwitchToThirdPerson([NotNull] this IPlayerControl control) => SwitchPerspective <IThirdPersonView>(control);
//private int prit = (int)Priority.RUN;
public RunState(IPlayerControl iplayer)
{
_player = iplayer;
}
protected PlayerHelper(IPlayerControl control)
{
this.control = control;
}
//private int prit = (int)Priority.JUMP;
public JumpState(IPlayerControl player)
{
_player = player;
}
void IPlayerSessionEventListener.OnJoinedGame(IPlayerControl control)
{
this.control = control;
cardHelper = new CardHelper(control);
switch(control.Game.Players.Count)
{
case 2:
playerHelper = new TwoPlayersPlayerHelper(control);
break;
case 3:
playerHelper = new ThreePlayersPlayerHelper(control);
break;
default:
playerHelper = new StandardPlayerHelper(control);
break;
}
triedCards = new List<int>();
triedAbilities = new List<CharacterType>();
}
void ISessionEventListener.OnSessionEnded()
{
sessionControl = null;
control = null;
playerHelper = null;
cardHelper = null;
}
public static IFirstPersonView SwitchToFirstPerson([NotNull] this IPlayerControl control) => SwitchPerspective <IFirstPersonView>(control);
// private int prit = (int)Priority.IDLE;
public IdleState(IPlayerControl iplayer)
{
_player = iplayer;
}
public virtual void OnJoinedGame(IPlayerControl control)
{
}
protected abstract Validation <string, TObj> CreateService(
Option <string> closeAction,
IPlayerControl playerControl,
TDel node,
ILoggerFactory loggerFactory);
public PlayerMovementController(IPlayerControl playerControl, WalkAngleRestrictionArgs args)
{
_playerControl = playerControl;
_angleContraintForForwardWalking = args.angleContraintForForwardWalking;
_angleConstraintForBackwardWalking = args.angleConstraintForBackwardWalking;
}
public override void OnJoinedGame(IPlayerControl control)
{
lock(ConnectionManager.Lock)
{
ConnectionManager.playerGameControl = control;
ConnectionManager.game = control.Game;
if(OnGameConnected != null)
OnGameConnected();
}
}
//unity
public void SetControl(IPlayerControl control)
{
this.control = control;
}
public TwoPlayersPlayerHelper(IPlayerControl control)
: base(control)
{
int myID = control.PrivatePlayerView.ID;
enemyId = control.Game.Players.First(p => p.ID != myID).ID;
}
void ISessionEventListener.OnSessionEnded()
{
ConsoleHelper.SessionEvent("Session ended!");
gameControl = null;
sessionControl = null;
UnsetAI();
if(aiTest)
aiTest = false;
}
/// <summary>
/// Disconnects from the currently connected session.
/// </summary>
public static void DisconnectFromSession()
{
lock(Lock)
{
if(!SessionConnected)
return;
try
{
if(playerSessionControl != null)
playerSessionControl.Disconnect();
if(spectatorSessionControl != null)
spectatorSessionControl.Disconnect();
}
catch
{
}
playerGameControl = null;
spectatorGameControl = null;
game = null;
playerSessionControl = null;
spectatorSessionControl = null;
session = null;
if(OnSessionDisconnected != null)
OnSessionDisconnected();
}
}
