Example #1
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            CloseButtonOn = false;

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var valueField = builder.AddIntegerField("Value: ");

            valueField.Value = Result;

            builder.AddVerticalMargin(5);

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                Result = (byte)valueField.Value;

                Close();
            }, FieldBuilder.ResizableButtonOrientation.Left);

            builder.BuildSessionEnd();

            CanResizeFormVertically = false;

            X = (Parent.Width / 2) - (Width / 2);
            Y = (Parent.Height / 2) - (Height / 2);
        }
Example #2
0
        public override Func <bool> GUI_Edit(SingleSlotBox container)
        {
            var builder = new FieldBuilder();

            builder.BuildSessionStart(container);

            builder.AddResizableButtonField("Edit Input-Neurons", delegate(object sender)
            {
                EditNeuronListForm <RMP_InputNeuron> .ShowDialogue(container.Parent, InputNeurons);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddResizableButtonField("Edit Hidden-Neurons", delegate(object sender)
            {
                EditNeuronListForm <RMP_Neuron> .ShowDialogue(container.Parent, HiddenNeurons);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddResizableButtonField("Edit Output-Neurons", delegate(object sender)
            {
                EditNeuronListForm <RMP_OutputNeuron> .ShowDialogue(container.Parent, OutputNeurons);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddVerticalMargin(5);

            builder.BuildSessionEnd();

            return(delegate()
            {
                return true;
            });
        }
Example #3
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            CloseButtonOn = false;

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var gName    = builder.AddTextField("Name: ");
            var gMin     = builder.AddDoubleField("Min: ");
            var gMax     = builder.AddDoubleField("Max: ");
            var gVal     = builder.AddDoubleField("Value: ");
            var gMutable = builder.AddCheckBoxField("IsMutable: ");

            gName.Text       = Result.Name;
            gMin.Value       = Result.Min;
            gMax.Value       = Result.Max;
            gVal.Value       = Result.Value;
            gMutable.Checked = Result.IsMutable;

            builder.AddVerticalMargin(5);

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                Result.Name = gName.Text;
                Result.SetMinMaxValue(gMin.Value, gMax.Value, gVal.Value);
                Result.IsMutable = gMutable.Checked;

                Close();
            }, FieldBuilder.ResizableButtonOrientation.Left);

            builder.BuildSessionEnd();

            CanResizeFormVertically = false;

            X = (Parent.Width / 2) - (Width / 2);
            Y = (Parent.Height / 2) - (Height / 2);
        }
Example #4
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            CloseButtonOn = false;

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var eye    = builder.AddIntegerField("Eye Neurons: ");
            var input  = builder.AddIntegerField("Input Neurons: ");
            var output = builder.AddIntegerField("Output Neurons: ");
            var hidden = builder.AddIntegerField("Hidden Neurons: ");

            builder.AddVerticalMargin(5);

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                chromosome.CreateRandom((int)eye.Value, (int)input.Value, (int)output.Value, (int)hidden.Value);
                Close();
            }, FieldBuilder.ResizableButtonOrientation.Right);

            builder.MoveUpOneField();

            builder.AddResizableButtonField("Abort", delegate(object sender)
            {
                Close();
            }, FieldBuilder.ResizableButtonOrientation.Left);

            builder.BuildSessionEnd();

            X = (Parent.Width / 2) - (Width / 2);
            Y = (Parent.Height / 2) - (Height / 2);

            CanResizeFormVertically = false;
        }
Example #5
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            EditNeuronGeneListForm.GenerateNeuronsEvent addNeuronsDelegate = delegate(int neuronsToAdd, List <RMP_NeuronGene> neuronList)
            {
                AddRandomNeurons(neuronList, neuronsToAdd);
            };

            builder.AddResizableButtonField("Edit Red Eye-Neurons", delegate(object sender)
            {
                EditNeuronGeneListForm.ShowDialogue(Parent, chromosome.EyeRNeuronGenes, addNeuronsDelegate);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddResizableButtonField("Edit Green Eye-Neurons", delegate(object sender)
            {
                EditNeuronGeneListForm.ShowDialogue(Parent, chromosome.EyeGNeuronGenes, addNeuronsDelegate);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddResizableButtonField("Edit Blue Eye-Neurons", delegate(object sender)
            {
                EditNeuronGeneListForm.ShowDialogue(Parent, chromosome.EyeBNeuronGenes, addNeuronsDelegate);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddResizableButtonField("Edit Distance Eye-Neurons", delegate(object sender)
            {
                EditNeuronGeneListForm.ShowDialogue(Parent, chromosome.DistanceNeuronGenes, addNeuronsDelegate);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddVerticalMargin(4);

            builder.AddResizableButtonField("Edit Input-Neurons", delegate(object sender)
            {
                EditNeuronGeneListForm.ShowDialogue(Parent, chromosome.InputNeuronGenes, addNeuronsDelegate);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddResizableButtonField("Edit Hidden-Neurons", delegate(object sender)
            {
                EditNeuronGeneListForm.ShowDialogue(Parent, chromosome.HiddenNeuronGenes, addNeuronsDelegate);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddResizableButtonField("Edit Output-Neurons", delegate(object sender)
            {
                EditNeuronGeneListForm.ShowDialogue(Parent, chromosome.OutputNeuronGenes, delegate(int neuronsToAdd, List <RMP_NeuronGene> neuronList)
                {
                    AddRandomOutputNeurons(neuronList, neuronsToAdd);
                });
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddVerticalMargin(5);

            builder.AddResizableButtonField("Connect Randomly", delegate(object sender)
            {
                chromosome.AllNeuronsConnectRandomly();
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.BuildSessionEnd();

            X = (Parent.Width / 2) - (Width / 2);
            Y = (Parent.Height / 2) - (Height / 2);

            CanResizeFormVertically = false;
        }
Example #6
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var nameField = builder.AddTextField("Name: ");

            nameField.Text = spawnPoint.Name;

            var posX = builder.AddDoubleField("Position X: ");

            posX.Value = spawnPoint.SpawnArea.X;

            var posY = builder.AddDoubleField("Position Y: ");

            posY.Value = spawnPoint.SpawnArea.Y;

            var width = builder.AddIntegerField("Width: ");

            width.Value = spawnPoint.SpawnArea.Width;

            var height = builder.AddIntegerField("Height: ");

            height.Value = spawnPoint.SpawnArea.Height;

            var timeInterval = builder.AddDoubleField("Time Interval: ");

            timeInterval.Value = spawnPoint.TimeInterval;

            reloadValues = delegate()
            {
                nameField.Text     = spawnPoint.Name;
                posX.Value         = spawnPoint.SpawnArea.X;
                posY.Value         = spawnPoint.SpawnArea.Y;
                width.Value        = spawnPoint.SpawnArea.Width;
                height.Value       = spawnPoint.SpawnArea.Height;
                timeInterval.Value = spawnPoint.TimeInterval;
            };

            reloadValues();

            Action setValues = delegate()
            {
                spawnPoint.Name = nameField.Text;

                spawnPoint.SpawnArea.X      = (int)posX.Value;
                spawnPoint.SpawnArea.Y      = (int)posY.Value;
                spawnPoint.SpawnArea.Width  = (int)width.Value;
                spawnPoint.SpawnArea.Height = (int)height.Value;

                spawnPoint.SetTimeInterval(timeInterval.Value);
            };

            builder.AddVerticalMargin(5);

            builder.AddResizableButtonField("Set Spawn-Area with mouse", delegate(object sender)
            {
                setValues();

                Parent.DialoguesAreHidden = true;

                Globals.Editor.Mode = Editor.Modes.SetPeremiter;
                Globals.Editor.Set_SendPeremiterFunction(sendPeremiter);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AlignTop    = true;
            builder.AlignBottom = true;

            spawnEntitiesList = builder.AddColumnListBox("Spawn-entities", 300, 2);
            spawnEntitiesList.SetIntOrStringSort(false, true);
            spawnEntitiesList.SetColumnName(0, "Entity-Type");
            spawnEntitiesList.SetColumnName(1, "Amount");

            builder.AlignTop    = false;
            builder.AlignBottom = true;

            builder.AddResizableButtonField("Add Entity", delegate(object sender)
            {
                AddSpawnEntityForm.ShowDialogue(Parent, spawnPoint, delegate(object _sender)
                {
                    reloadList();
                });
            }, FieldBuilder.ResizableButtonOrientation.Right);

            builder.AddResizableButtonField("Remove Entity", delegate(object sender)
            {
                if (spawnEntitiesList.SelectedRowIndex == -1)
                {
                    return;
                }

                spawnPoint.SpawnClones.Remove((IEntity)spawnEntitiesList.Values[spawnEntitiesList.SelectedRowIndex].ExtraValues[0]);
                reloadValues();
            }, FieldBuilder.ResizableButtonOrientation.Right);

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                setValues();
                Close();
            }, FieldBuilder.ResizableButtonOrientation.Right);

            builder.BuildSessionEnd();

            X = (Parent.Width / 2) - (Width / 2);
            Y = (Parent.Height / 2) - (Height / 2);

            CanResizeFormVertically = false;
        }
Example #7
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            CloseButtonOn = false;

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var symmetricalBordersCheckBox = builder.AddCheckBoxField("Symmetrical Borders: ");

            symmetricalBordersCheckBox.Checked = sigmoid.SymmetricalBorders;

            builder.AddLabelField("P: ");
            var pMin     = builder.AddDoubleField("Min: ");
            var pMax     = builder.AddDoubleField("Max: ");
            var pVal     = builder.AddDoubleField("Value: ");
            var pMutable = builder.AddCheckBoxField("IsMutable: ");

            builder.AddVerticalMargin(4);

            builder.AddLabelField("Output-Border: ");
            var o1Min     = builder.AddDoubleField("Min: ");
            var o1Max     = builder.AddDoubleField("Max: ");
            var o1Val     = builder.AddDoubleField("Value: ");
            var o1Mutable = builder.AddCheckBoxField("IsMutable: ");

            var switchBox = new SwitchBox();

            switchBox.Initialize();
            builder.AddDrawBoxAsField(switchBox, DrawBoxAlignment.GetLeftRight());

            var emptyPanel = new Panel();

            emptyPanel.Initialize();

            switchBox.AddDrawBox(emptyPanel, "symmetrical");

            var panel = new Panel();

            panel.Initialize();

            var builder2 = new FieldBuilder();

            builder2.BuildSessionStart(panel);
            builder2.AddLabelField("Output-Border 2: ");
            var o2Min     = builder2.AddDoubleField("Min: ");
            var o2Max     = builder2.AddDoubleField("Max: ");
            var o2Val     = builder2.AddDoubleField("Value: ");
            var o2Mutable = builder2.AddCheckBoxField("IsMutable: ");

            builder2.BuildSessionEnd();

            switchBox.AddDrawBox(panel, "non-symmetrical");

            int largestHeight = 0;

            foreach (var p in switchBox.DrawBoxList)
            {
                if (p.Height > largestHeight)
                {
                    largestHeight = panel.Height;
                }
            }

            switchBox.Width  = builder.FieldWidth;
            switchBox.Height = largestHeight;

            if (sigmoid.GeneList.Count != 0)
            {
                var o1Gene = (DoubleGene)sigmoid.GeneList[0];
                o1Min.Value       = o1Gene.Min;
                o1Max.Value       = o1Gene.Max;
                o1Val.Value       = o1Gene.Value;
                o1Mutable.Checked = o1Gene.IsMutable;

                int n = 1;

                if (!sigmoid.SymmetricalBorders)
                {
                    var o2Gene = (DoubleGene)sigmoid.GeneList[n++];
                    o2Min.Value       = o2Gene.Min;
                    o2Max.Value       = o2Gene.Max;
                    o2Val.Value       = o2Gene.Value;
                    o2Mutable.Checked = o2Gene.IsMutable;
                }

                var pGene = (DoubleGene)sigmoid.GeneList[n++];
                pMin.Value       = pGene.Min;
                pMax.Value       = pGene.Max;
                pVal.Value       = pGene.Value;
                pMutable.Checked = pGene.IsMutable;
            }

            if (sigmoid.SymmetricalBorders)
            {
                switchBox.SelectDrawBoxWithKey("symmetrical");
            }
            else
            {
                switchBox.SelectDrawBoxWithKey("non-symmetrical");
            }

            symmetricalBordersCheckBox.CheckedChanged += delegate(object sender, bool newValue)
            {
                if (newValue)
                {
                    switchBox.SelectDrawBoxWithKey("symmetrical");
                }
                else
                {
                    switchBox.SelectDrawBoxWithKey("non-symmetrical");
                }
            };

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                Close();
            }, FieldBuilder.ResizableButtonOrientation.Left);

            builder.BuildSessionEnd();

            IsClosing += delegate(object sender)
            {
                geneList.Clear();

                var _o1Gene = new DoubleGene();
                _o1Gene.SetMinMaxValue(o1Min.Value, o1Max.Value, o1Val.Value);
                _o1Gene.IsMutable = o1Mutable.Checked;
                geneList.Add(_o1Gene);

                if (!symmetricalBordersCheckBox.Checked)
                {
                    var _o2Gene = new DoubleGene();
                    _o2Gene.SetMinMaxValue(o2Min.Value, o2Max.Value, o2Val.Value);
                    _o2Gene.IsMutable = pMutable.Checked;
                    geneList.Add(_o2Gene);
                }

                var _pGene = new DoubleGene();
                _pGene.SetMinMaxValue(pMin.Value, pMax.Value, pVal.Value);
                _pGene.IsMutable = pMutable.Checked;
                geneList.Add(_pGene);
            };

            CanResizeFormVertically = false;

            X = (Parent.Width / 2) - (Width / 2);
            Y = (Parent.Height / 2) - (Height / 2);
        }