Exemple #1
0
        protected void SetModel(object sender, DependencyPropertyChangedEventArgs e)
        {
            _model = this.DataContext as BetTreeNodeModel;
            if (_model == null) return;

            MetaList.DataContext = _model.Tree.GetPartials(_model);
        }
Exemple #2
0
        public BetTreeNodeModel AddChild(BetTreeModel tree, BetTreeNodeModel parent)
        {
            HoldemHandRound round = parent.Snapshot.NextPlayer == null ?
                (HoldemHandRound)((int)parent.Snapshot.Round) + 1 : parent.Snapshot.Round;
            int? player = parent.Snapshot.NextPlayer == null ?
                parent.Snapshot.GetNextRoundStart() : parent.Snapshot.NextPlayer;

            BetTreeNodeModel model;
            switch (round)
            {
                case HoldemHandRound.PreFlop:
                    model = AddPreflopStandard(parent, round, (int)player);
                    break;
                case HoldemHandRound.Flop:
                case HoldemHandRound.Turn:
                case HoldemHandRound.River:
                    model = AddPostflopStandard(parent, round, (int)player);
                    break;
                default:
                    model = AddShowdownStandard(parent);
                    break;
            }

            parent.AddChild(model);
            model.AddNode += tree.OnAddNode;
            model.EditNode += tree.OnEditNode;
            model.DeleteNode += tree.OnDeleteNode;
            model.ShowWizard += tree.OnShowWizard;
            return model;
        }
Exemple #3
0
 public BetTreeNodeInfoModel(BetTreeNodeModel model, bool manual)
 {
     Parent = model;
     Parent.MetaUpdated += UpdateDisplay;
     DisplayResultsIndex = model.Tree.Hero;
     Manual = manual;
 }
Exemple #4
0
        public TreeGridItem()
        {
            InitializeComponent();
            this.DataContextChanged += SetModel;
            Model = DataContext as BetTreeNodeModel;

            _children = new List<TreeGridItem>();
            NodeDisplay.OnLayoutUpdated += OnFixLayout;
        }
Exemple #5
0
        public PartialGenerator(TreePartialMeta meta, BetTreeModel tree, BetTreeNodeModel node, BetTreeNodeService service)
        {
            this.Meta = meta;
            this.Wizard = tree.GeneratePartialWizard(meta);
            this.Tree = tree;
            this.Node = node;
            this.Service = service;

            SetContainer();
        }
Exemple #6
0
        public BetTreeNodeModel(BetTreeModel tree, BetTreeNodeDisplay display, BetTreeNodeStyle style, HandSnapshotModel snapshot, BetTreeNodeModel parent, bool isDynamic)
        {
            this.Tree = tree;
            this.DisplayModel = display;
            this.StyleModel = style;
            this._parentSnapshot = snapshot;
            this.Snapshot = snapshot;
            this.Parent = parent;
            this.IsDynamic = isDynamic;
            this.Result = new BetTreeNodeResults(snapshot.Stacks.Length);

            this.Children = new ObservableCollection<BetTreeNodeModel>();
            this.CanRemove = IsFixed() ? Visibility.Collapsed : Visibility.Visible;

            this.Info = new BetTreeNodeInfoModel(this, this.Data is ManualResultsModel);
        }
Exemple #7
0
        public void EditNode(BetTreeNodeModel model)
        {
            _activeModel = model;
            if (_activeModel == null) return;

            switch (_activeModel.Meta)
            {
                case BetTreeNodeService.PREFLOP_NODE_META:
                case BetTreeNodeService.POSTFLOP_NODE_META:
                    ShowBetRangeEditor();
                    break;
                case BetTreeNodeService.RESULT_NODE_META:
                    ShowResultEditor();
                    break;
                case BetTreeNodeService.SHOWDOWN_NODE_META:
                    break;
            }
        }
Exemple #8
0
        public void GetPartialTree(BetTreeNodeModel parent)
        {
            if (Meta.Type == TreePartialMetaType.Xml)
            {
                TreePartialContainer container = Tree.LoadPartial(Node, Meta);

                if (container.Root == null) return;

                List<BetTreeNodeModel> ret = new List<BetTreeNodeModel>();

                foreach (BetTreeNodeXml child in container.Root.Children)
                    ret.Add(LoadNode(parent, child));
            }
            else
            {
                Wizard.GenerateTree(parent);
            }
        }
Exemple #9
0
        public PartialVariableListModel LoadVariables(BetTreeNodeModel Node)
        {
            int numPlayers = Node.Snapshot.Active.Count(x => x);
            Variables = new PartialVariableListModel();
            ObservableCollection<PartialVariableModel> defs = new ObservableCollection<PartialVariableModel>();
            foreach (TreePartialVariableDefinition[] defSet in _variables)
            {
                foreach (TreePartialVariableDefinition defSingle in defSet)
                {
                    PartialVariableModel var = new PartialVariableModel() { Name = defSingle.ID, Variable = defSingle.Variable, Default = defSingle.Default };
                    ObservableCollection<PartialPlayerValueModel> players = new ObservableCollection<PartialPlayerValueModel>();
                    for (int i = 0; i < numPlayers; i++)
                        players.Add(new PartialPlayerValueModel() { Index = i });
                    var.Players = players;
                    defs.Add(var);
                }
            }

            Variables.Definitions = defs;
            return Variables;
        }
Exemple #10
0
 public void OnShowWizard(BetTreeNodeModel model)
 {
     if (ShowWizard != null) ShowWizard(model);
 }
Exemple #11
0
 public void OnDeleteNode(BetTreeNodeModel node)
 {
     node.Parent.RemoveChild(node);
     node.Parent.InvalidateProperty(BetTreeNodeModel.ChildrenProperty);
     if (this.NodeDeleted != null) NodeDeleted(node);
 }
Exemple #12
0
 public PartialVariableListModel LoadVariables(BetTreeNodeModel node, TreePartialMeta meta)
 {
     TreePartialContainer container = LoadPartial(node, meta);
     PartialVariableListModel variables = container.Variables.GetVariableListModel();
     return variables;
 }
Exemple #13
0
 public List<TreePartialMeta> GetPartials(BetTreeNodeModel node)
 {
     return Service.GetPartialMeta(node);
 }
Exemple #14
0
        protected void NodeDeleted(BetTreeNodeModel node)
        {
            TreeGridItem childDisplay = _items.Find(x => x.DataContext == node);
            TreeGridItem parentDisplay = _items.Find(x => x.DataContext == node.Parent);

            bool found = (parentDisplay == null) ? false : RemoveItem(parentDisplay.Children, childDisplay);

            if (!found)
            {
                TreeGridStart start = GetGrid(parentDisplay, StartGrid);
                RemoveItem(start.MainGrid, childDisplay);
            }

            foreach (BetTreeNodeModel child in node.Children)
                RemoveFromChildCanvases(child, childDisplay);

            UpdateDimensions(parentDisplay, true);
            UpdateCanvas(childDisplay.Model.Snapshot.Round);
        }
Exemple #15
0
        /// <summary>
        /// Updates the visual layout of the tree after a node has been added to the tree model
        /// </summary>
        /// <param name="node">The node which has been added</param>
        /// <returns>The node which has been added</returns>
        protected BetTreeNodeModel NodeAdded(BetTreeNodeModel node)
        {
            //-------------------------------------------------------------------------------------
            // If there is already a display for this node, then no need to continue here
            //-------------------------------------------------------------------------------------
            TreeGridItem nodeDisplay = GetDisplay(node);
            if (nodeDisplay != null) return node;

            TreeGridItem parentDisplay = GetDisplay(node.Parent);

            //-------------------------------------------------------------------------------------
            // If there is no parent node or the parent node is a different round, then we need
            // to add the visual component to a round root. Otherwise, we just add the visual
            // component to it's parent
            //-------------------------------------------------------------------------------------
            if (parentDisplay == null || node.Parent.Snapshot.Round != node.Snapshot.Round)
            {
                AddRootNode(node, parentDisplay);
            }
            else
            {
                AddStandardNode(node, parentDisplay);
            }

            return node;
        }
Exemple #16
0
 protected void InitialiseNode(BetTreeNodeModel node)
 {
     foreach (BetTreeNodeModel child in node.Children)
     {
         NodeAdded(child);
         InitialiseNode(child);
     }
 }
Exemple #17
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="node"></param>
 /// <param name="parentDisplay"></param>
 /// <returns></returns>
 protected TreeGridStart GetNewGridStart(BetTreeNodeModel node, TreeGridItem parentDisplay)
 {
     TreeGridStart start = new TreeGridStart();
     start.LinkedItem = parentDisplay;
     start.LayoutUpdated += this.RefreshCanvas;
     Canvas canvas = _canvases[node.Snapshot.Round];
     canvas.Children.Add(start);
     _grids[parentDisplay] = start;
     return start;
 }
Exemple #18
0
 protected void SetModel(object sender, DependencyPropertyChangedEventArgs e)
 {
     Model = DataContext as BetTreeNodeModel;
     if (Model == null) return;
 }
Exemple #19
0
        protected void SetExpanded(BetTreeNodeModel model, bool parentExpanded)
        {
            TreeGridItem display = GetDisplay(model);
            Visibility visibility = parentExpanded ? Visibility.Visible : Visibility.Collapsed  ;
            if (visibility != display.Visibility)
            {
                display.Visibility = visibility;
                UpdateDimensions(display, true);
            }

            foreach (BetTreeNodeModel child in model.Children)
                SetExpanded(child, parentExpanded && model.IsExpanded);
        }
Exemple #20
0
 public TreePartialContainer LoadPartial(BetTreeNodeModel parent, TreePartialMeta meta)
 {
     return Service.GetPartialTree(meta);
 }
Exemple #21
0
 public bool HasPartials(BetTreeNodeModel node)
 {
     return GetPartials(node).Count > 0;
 }
Exemple #22
0
        private void RemoveFromChildCanvases(BetTreeNodeModel node, TreeGridItem parentDisplay)
        {
            TreeGridItem nodeDisplay = _items.Find(x => x.DataContext == node);

            foreach (BetTreeNodeModel child in node.Children)
                RemoveFromChildCanvases(child, nodeDisplay);

            TreeGridStart start = GetGrid(parentDisplay, null);
            if (start != null)
                RemoveItem(start.MainGrid, nodeDisplay);
        }
Exemple #23
0
        public void LoadPlayerValues(BetTreeNodeModel node, PartialVariableListModel variables)
        {
            List<PlayerModel> activePlayers = new List<PlayerModel>();
            int nextPlayer = (int)node.Snapshot.NextPlayer;
            for (int i = 0; i < node.Snapshot.Active.Length; i++)
            {
                int playerIndex = (i + nextPlayer) % node.Snapshot.Active.Length;
                if (node.Snapshot.Active[playerIndex])
                {
                    activePlayers.Add(Table.Seats[playerIndex].Player);
                }
            }

            foreach (PartialVariableModel model in variables.Definitions)
            {
                foreach (PartialPlayerValueModel player in model.Players)
                {
                    player.Player = activePlayers[player.Index];
                    VariableGroup group = player.Player.Container.Groups.First(x => x.Name == node.Snapshot.Round.ToString());
                    player.Value = new ValueModel();
                    player.Value.Value = model.Default;
                    player.Value.Variable = group.Variables.FirstOrDefault(x => x.Name == model.Variable);
                    if (player.Value.Variable == null)
                        player.Value.Value = model.Default;
                }
            }
        }
Exemple #24
0
        private void UpdateGridDimensions(BetTreeNodeModel node, TreeGridItem itemDisplay, TreeGridItem parentDisplay)
        {
            TreeGridStart grid = GetGrid(parentDisplay, StartGrid);
            double height = 0, width = 0;

            for (int i = 0; i < grid.MainGrid.Children.Count; i++)
            {
                TreeGridItem child = grid.MainGrid.Children[i] as TreeGridItem;
                if (child.Visibility == Visibility.Visible)
                {
                    if (child.Width > width) width = child.Width;
                    height += child.Height;
                }
                if (child == itemDisplay)
                {
                    grid.MainGrid.RowDefinitions[i].Height = new GridLength(child.Height);
                }
            }

            grid.MainGrid.ColumnDefinitions[0].Width = new GridLength(width);
            grid.Width = width;
            grid.Height = height;
        }
Exemple #25
0
        public BetTreeNodeModel OnAddNode(BetTreeNodeModel parent)
        {
            BetTreeNodeModel child = Service.AddChild(this, parent);

            parent.InvalidateProperty(BetTreeNodeModel.ChildrenProperty);
            if (this.NodeAdded != null) NodeAdded(child);

            return child;
        }
 protected void SetModel(object sender, DependencyPropertyChangedEventArgs e)
 {
     Model = this.DataContext as BetTreeNodeModel;
 }
Exemple #27
0
 public void OnEditNode(BetTreeNodeModel node)
 {
     if (this.EditNode != null) EditNode(node);
 }
Exemple #28
0
 public void RemoveChild(BetTreeNodeModel model)
 {
     this.IsExpanded = true;
     Children.Remove(model);
     CanCollapse = this.Children.Count > 0 ? Visibility.Visible : Visibility.Hidden;
 }
Exemple #29
0
        protected BetTreeNodeModel LoadNode(BetTreeNodeModel parent, BetTreeNodeXml node, bool relative)
        {
            BetTreeNodeModel ret = Service.AddChild(this, parent);
            ret.LoadFromXml(node, relative);

            if (!ret.Snapshot.IsHandEnd)
                foreach (BetTreeNodeXml child in node.Children)
                    LoadNode(ret, child, relative);
            return ret;
        }
Exemple #30
0
 public BetTreeNodeModel(BetTreeModel tree, BetTreeNodeDisplay display, BetTreeNodeStyle style, HandSnapshotModel snapshot, BetTreeNodeModel parent)
     : this(tree, display, style, snapshot, parent, false)
 {
 }