Пример #1
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            CloseButtonOn = false;

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            builder.AddLabelField("Name: " + connection.Name);
            builder.AddLabelField("Source: " + connection.Source.GeneID);
            builder.AddLabelField("Target: " + connection.Target.GeneID);

            var weightField = builder.AddDoubleField("Weight:");

            weightField.Value = connection.Weight;

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                connection.Weight = weightField.Value;

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

            builder.BuildSessionEnd();

            X = (Parent.Width / 2) - (Width / 2);
            Y = (Parent.Height / 2) - (Height / 2);
        }
Пример #2
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            CloseButtonOn = false;

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

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

            nameField.Text = template.TemplateName;

            var genomeEditPanel = new GenomeEditPanel();

            genomeEditPanel.Initialize(template.Genome);
            builder.AddDrawBoxAsField(genomeEditPanel, DrawBoxAlignment.GetFull());

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                template.TemplateName = nameField.Text;

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

            builder.BuildSessionEnd();

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

            CanResizeFormVertically = false;
        }
Пример #3
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

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

            annTypesComboBox = builder.AddComboBoxField("ANN Type: ");
            var annTypeList = Globals.GetAllTypesDeriving(typeof(INeuralNetChromosome), Assembly.GetExecutingAssembly());

            annTypesComboBox.Items.AddRange(annTypeList.Select(s => s.Name));
            annTypesComboBox.Index = 0;

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                Result = new ANNTemplate();
                Result.TemplateName = nameField.Text;
                Result.ANN          = (INeuralNetChromosome)Activator.CreateInstance(annTypeList[annTypesComboBox.Index]);

                Close();

                EditAnnTemplateForm.ShowDialogue(Parent, Result);
            }, FieldBuilder.ResizableButtonOrientation.Right);

            builder.BuildSessionEnd();

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

            CanResizeFormVertically = false;
        }
Пример #4
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;
            });
        }
Пример #5
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);
        }
Пример #6
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            builder.AddResizableButtonField("Edit ANN", delegate(object sender)
            {
                EditANNForm.ShowDialogue(Parent, creature.Brain);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);
            builder.AddResizableButtonField("Edit ANN-Chromosome", delegate(object sender)
            {
                EditANNChromosomeForm.ShowDialogue(Parent, creature.CreatureGenome.NetChromosome);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);
            builder.AddResizableButtonField("Edit Genome", delegate(object sender)
            {
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);
            builder.AddResizableButtonField("Edit Body", delegate(object sender)
            {
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.BuildSessionEnd();

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

            CanResizeFormVertically = false;
        }
Пример #7
0
        public static Func <bool> GUI_Edit(SingleSlotBox container, FitnessWorld world)
        {
            var builder = new FieldBuilder();

            builder.BuildSessionStart(container);

            Panel panel = new Panel();

            panel.Initialize();
            builder.AddDrawBoxAsField(panel, DrawBoxAlignment.GetFull());

            Func <bool> isReadyFunc = World.GUI_Edit(panel, world);

            var minFood      = builder.AddIntegerField("Minimum Food: ");
            var minCreatures = builder.AddIntegerField("Minimum Creatures: ");

            builder.BuildSessionEnd();

            container.IsClosing += delegate(object sender)
            {
                world.MinimumFood      = (int)minFood.Value;
                world.MinimumCreatures = (int)minCreatures.Value;
            };

            return(delegate()
            {
                return isReadyFunc();
            });
        }
Пример #8
0
        public static Func <bool> GUI_Edit(SingleSlotBox container, World world)
        {
            var builder = new FieldBuilder();

            builder.BuildSessionStart(container);

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

            width.MinValue = 1;
            width.Value    = world.Width;

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

            height.MinValue = 1;
            height.Value    = world.Height;

            var worldHasEdges = builder.AddCheckBoxField("World Edges");

            worldHasEdges.Checked = world.WorldHasEdges;

            var regionSize = builder.AddIntegerField("Region Size: ");

            regionSize.MinValue = 1;
            regionSize.Value    = world.RegionSize;

            var gaussianMin = builder.AddIntegerField("Gassian Generator Min: ");

            gaussianMin.Value = 0;

            var gaussianMax = builder.AddIntegerField("Gassian Generator Max: ");

            gaussianMax.Value = 1000;

            container.IsClosing += delegate(object sender)
            {
                world.Width         = (int)width.Value;
                world.Height        = (int)height.Value;
                world.WorldHasEdges = worldHasEdges.Checked;
                world.RegionSize    = (int)regionSize.Value;

                world.Random         = new UniformRandomGenerator();
                world.GaussianRandom = new NormalRandomGenerator((int)gaussianMin.Value, (int)gaussianMax.Value, world.Random);

                foreach (var e in world.EntityList)
                {
                    e.Position = new EntityPosition(Math.Min(e.Position.X, world.Width - 1), Math.Min(e.Position.Y, world.Height - 1));
                }

                world.ReloadRegions();
            };

            builder.BuildSessionEnd();

            return(delegate()
            {
                return true;
            });
        }
Пример #9
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var templateNameTextField = builder.AddTextField("Template Name: ");

            templateNameTextField.Text = template.TemplateName;

            var panel = new Panel();

            panel.Initialize();
            builder.AddDrawBoxAsField(panel, DrawBoxAlignment.GetFull());

            var guiMethod   = template.Creature.GetType().GetMethod("GUI_Edit");
            var isReadyFunc = (Func <bool>)guiMethod.Invoke(template.Creature, new object[] { panel });

            panel.Width = builder.FieldWidth;

            Wrap();

            var okButton = new ResizableButton();

            okButton.Initialize();
            AddDrawBox(okButton);
            okButton.Title = "OK";
            okButton.FitToText();
            okButton.X      = builder.FieldWidth - okButton.Width;
            okButton.Y      = Height + 5;
            okButton.Click += delegate(object sender)
            {
                if (isReadyFunc())
                {
                    template.TemplateName = templateNameTextField.Text;
                    Close();
                }
                else
                {
                    AlertForm.ShowDialogue(Parent, null, "All fields have not been filled out.");
                }
            };

            builder.BuildSessionEnd();

            okButton.Alignment = DrawBoxAlignment.GetRightBottom();

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

            CanResizeFormVertically = true;
        }
Пример #10
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var templateNameTextField = builder.AddTextField("Template Name: ");

            var entityTypesComboBox = builder.AddComboBoxField("Entity Type: ");
            var entityTypeList      = Globals.GetAllTypesDeriving(typeof(IEntity), Assembly.GetExecutingAssembly());

            //Remove all creature-types
            var creatureType = typeof(ICreature);

            foreach (var t in new List <Type>(entityTypeList))
            {
                if (creatureType.IsAssignableFrom(t))
                {
                    entityTypeList.Remove(t);
                }
            }

            entityTypesComboBox.Items.AddRange(entityTypeList.Select(s => s.Name));
            entityTypesComboBox.Index = 0;

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                if (entityTypesComboBox.Index == -1)
                {
                    AlertForm.ShowDialogue(Parent, null, "Select a entity type.");
                }
                else
                {
                    Result = new EntityTemplate();
                    Result.TemplateName = templateNameTextField.Text;
                    Result.Entity       = (IEntity)Activator.CreateInstance(entityTypeList[entityTypesComboBox.Index]);

                    EditEntityTemplateForm.ShowDialogue(Parent, Result);

                    Close();
                }
            });

            builder.BuildSessionEnd();

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

            CanResizeFormVertically = false;
        }
Пример #11
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            CloseButtonOn = false;

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            nameField      = builder.AddTextField("Name: ");
            nameField.Text = neuronGene.Name;

            isMutableCheckBox         = builder.AddCheckBoxField("Gene Mutability: ");
            isMutableCheckBox.Checked = neuronGene.IsMutable;

            builder.AddLabelField("Bias:");
            biasMin = builder.AddDoubleField("Min: ");
            biasMax = builder.AddDoubleField("Max: ");
            biasVal = builder.AddDoubleField("Value: ");


            biasMin.Value = neuronGene.Bias.Min;
            biasMax.Value = neuronGene.Bias.Max;
            biasVal.Value = neuronGene.Bias.Value;

            builder.AddResizableButtonField("Edit Sigmoid Function", delegate(object sender)
            {
                neuronGene.SigmoidFunction.GetType().InvokeMember("GUI_Edit", BindingFlags.Default | BindingFlags.InvokeMethod, null, null, new object[] { Parent, neuronGene.SigmoidFunction });
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddResizableButtonField("Edit Connections", delegate(object sender)
            {
                EditConnectionGeneListForm.ShowDialogue(Parent, neuronGene.Connections);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

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

            builder.BuildSessionEnd();

            X = (Parent.Width / 2) - (Width / 2);
            Y = (Parent.Height / 2) - (Height / 2);
        }
Пример #12
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            CloseButtonOn = false;

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            builder.AddLabelField("Name: " + neuron.Name);
            builder.AddLabelField("GeneID: " + neuron.GeneID);

            var activation = builder.AddDoubleField("Activation: ");

            activation.Value = neuron.Activation;

            var bias = builder.AddDoubleField("Bias: ");

            bias.Value = neuron.Bias;

            builder.AddResizableButtonField("Edit Sigmoid Function", delegate(object sender)
            {
                neuron.SigmoidFunction.GetType().InvokeMember("GUI_Edit", BindingFlags.Default | BindingFlags.InvokeMethod, null, null, new object[] { Parent, neuron.SigmoidFunction });
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddResizableButtonField("Edit Connections", delegate(object sender)
            {
                EditConnectionListForm.ShowDialogue(Parent, neuron.Connections);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                neuron.Activation = activation.Value;
                neuron.Bias       = bias.Value;

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

            builder.BuildSessionEnd();

            X = (Parent.Width / 2) - (Width / 2);
            Y = (Parent.Height / 2) - (Height / 2);
        }
Пример #13
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var templateNameTextField = builder.AddTextField("Template Name: ");

            var worldTypesComboBox = builder.AddComboBoxField("World Type: ");
            var worldTypeList      = Globals.GetAllTypesDeriving(typeof(IWorld), Assembly.GetExecutingAssembly());

            worldTypesComboBox.Items.AddRange(worldTypeList.Select(s => s.Name));
            worldTypesComboBox.Index = 0;

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                if (worldTypesComboBox.Index == -1)
                {
                    AlertForm.ShowDialogue(Parent, null, "Select a world type.");
                }
                else
                {
                    Result = new WorldTemplate();
                    Result.TemplateName = templateNameTextField.Text;
                    Result.World        = (IWorld)Activator.CreateInstance(worldTypeList[worldTypesComboBox.Index]);

                    EditWorldTemplateForm.ShowDialogue(Parent, Result);

                    Close();
                }
            });

            builder.BuildSessionEnd();

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

            CanResizeFormVertically = false;
        }
Пример #14
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            CloseButtonOn = false;

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var templateNameTextField = builder.AddTextField("Template Name: ");

            templateNameTextField.Text = template.TemplateName;

            Panel panel = new Panel();

            panel.Initialize();
            builder.AddDrawBoxAsField(panel, DrawBoxAlignment.GetFull());

            var isReadyFunc = (Func <bool>)template.World.GetType().InvokeMember("GUI_Edit", BindingFlags.Default | BindingFlags.InvokeMethod, null, null, new object[] { panel, template.World });

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                if (isReadyFunc())
                {
                    template.TemplateName = templateNameTextField.Text;
                    Close();
                }
                else
                {
                    AlertForm.ShowDialogue(Parent, null, "All fields have not been filled out.");
                }
            }, FieldBuilder.ResizableButtonOrientation.Left);

            builder.BuildSessionEnd();

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

            CanResizeFormVertically = false;
        }
Пример #15
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var fileNameTextField = builder.AddBrowseField(FileForm.FileFormTypes.File, FileForm.OperationTypes.Save, "File Directory: ").DrawBox1;

            var worldTemplatesComboBox = builder.AddComboBoxField("World: ");

            worldTemplatesComboBox.Items.AddRange(EditorData.WorldTemplates.Select(s => s.TemplateName));
            worldTemplatesComboBox.Index = 0;

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                if (worldTemplatesComboBox.Index == -1)
                {
                    AlertForm.ShowDialogue(Parent, null, "Choose a world-template");
                }
                else
                {
                    Result          = new Simulation();
                    Result.World    = EditorData.WorldTemplates[worldTemplatesComboBox.Index].World.Clone();
                    Result.FileName = fileNameTextField.Text;

                    AddDefaultEntityPainters(Result);

                    Close();
                }
            });

            builder.BuildSessionEnd();

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

            CanResizeFormVertically = false;
        }
Пример #16
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);
        }
Пример #17
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var allEntities = new List <IEntity>();

            allEntities.AddRange(EditorData.EntityTemplates.Select(e => e.Entity));
            allEntities.AddRange(EditorData.CreatureTemplates.Select(e => e.Creature));

            var entityTypesComboBox = builder.AddComboBoxField("Entity-Templates: ");

            entityTypesComboBox.Items.AddRange(EditorData.EntityTemplates.Select(e => e.TemplateName));
            entityTypesComboBox.Items.AddRange(EditorData.CreatureTemplates.Select(e => e.TemplateName));

            var amountField = builder.AddIntegerField("Amount: ");

            var okButton = builder.AddResizableButtonField("OK", delegate(object sender)
            {
                if (entityTypesComboBox.Index == -1)
                {
                    return;
                }

                spawnPoint.SpawnClones.Add(allEntities[entityTypesComboBox.Index]);
                Close();
            }, FieldBuilder.ResizableButtonOrientation.Right);

            builder.BuildSessionEnd();

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

            CanResizeFormVertically = false;
        }
Пример #18
0
        public static Func <bool> GUI_Edit(SingleSlotBox container, FoodWorld world)
        {
            var builder = new FieldBuilder();

            builder.BuildSessionStart(container);

            Panel panel = new Panel();

            panel.Initialize();
            builder.AddDrawBoxAsField(panel, DrawBoxAlignment.GetFull());

            Func <bool> isReadyFunc = World.GUI_Edit(panel, world);

            var minFood = builder.AddIntegerField("Minimum Food: ");

            minFood.Value = world.MinimumFood;
            var foodSpawnRate = builder.AddIntegerField("Food Spawn-rate: ");

            foodSpawnRate.Value = world.FoodSpawnRate;

            builder.AddResizableButtonField("Edit Food", delegate(object sender)
            {
                EditEntityForm.ShowDialogue(container.Parent, world.FoodToClone);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            container.IsClosing += delegate(object sender)
            {
                world.MinimumFood   = (int)minFood.Value;
                world.FoodSpawnRate = (int)foodSpawnRate.Value;
            };

            builder.BuildSessionEnd();

            return(delegate()
            {
                return isReadyFunc();
            });
        }
Пример #19
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            CloseButtonOn = false;

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            targetIntegerField       = builder.AddIntegerField("Target: ");
            targetIntegerField.Value = connection.Target;

            isOutputConnectionCheckBox         = builder.AddCheckBoxField("Is Output-Connection: ");
            isOutputConnectionCheckBox.Checked = connection.IsOutputConnection;

            isMutableCheckBox         = builder.AddCheckBoxField("Connection Mutability: ");
            isMutableCheckBox.Checked = connection.IsMutable;

            builder.AddLabelField("Weight:");
            weightMin = builder.AddDoubleField("Min: ");
            weightMax = builder.AddDoubleField("Max: ");
            weightVal = builder.AddDoubleField("Value: ");

            weightMin.Value = connection.Weight.Min;
            weightMax.Value = connection.Weight.Max;
            weightVal.Value = connection.Weight.Value;

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

            builder.BuildSessionEnd();

            X = (Parent.Width / 2) - (Width / 2);
            Y = (Parent.Height / 2) - (Height / 2);
        }
Пример #20
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            CloseButtonOn = false;

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            Panel panel = new Panel();

            panel.Initialize();
            builder.AddDrawBoxAsField(panel, DrawBoxAlignment.GetFull());

            var guiMethod   = ann.GetType().GetMethod("GUI_Edit");
            var isReadyFunc = (Func <bool>)guiMethod.Invoke(ann, new object[] { panel });

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                if (isReadyFunc())
                {
                    Close();
                }
                else
                {
                    AlertForm.ShowDialogue(Parent, null, "All fields have not been filled out.");
                }
            }, FieldBuilder.ResizableButtonOrientation.Left);

            builder.BuildSessionEnd();

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

            CanResizeFormVertically = false;
        }
Пример #21
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;
        }
Пример #22
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var painterTypesComboBox = builder.AddComboBoxField("Painter-type: ");
            var painterTypes         = Globals.GetAllTypesDeriving(typeof(IEntityPainter), Assembly.GetExecutingAssembly());

            painterTypesComboBox.Items.AddRange(painterTypes.Select(s => s.Name));

            painterTypesComboBox.SelectedItemChanged += delegate(object sender, int newItemIndex, int oldItemIndex)
            {
                if (painterTypesComboBox.Index == -1)
                {
                    return;
                }

                Result = (IEntityPainter)Activator.CreateInstance(painterTypes[painterTypesComboBox.Index]);

                //loadControls();
            };

            builder.AlignTop    = true;
            builder.AlignBottom = true;
            entitiesToDraw      = builder.AddColumnListBox("Entity-types to draw:", 200, 2);
            entitiesToDraw.SetColumnName(0, "Type-name");
            entitiesToDraw.SetColumnName(1, "State");
            entitiesToDraw.SetIntOrStringSort(false, false);

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

            var entityTypesComboBox = builder.AddComboBoxField("Entity-type: ");
            var entityTypes         = Globals.GetAllTypesDeriving(typeof(IEntity), Assembly.GetExecutingAssembly(), true);

            entityTypesComboBox.Items.AddRange(entityTypes.Select(s => s.Name));

            var addEntityButton = builder.AddResizableButtonField("Add Entity", delegate(object sender)
            {
                if (entityTypesComboBox.Index == -1)
                {
                    return;
                }

                Result.EntityTypeList.Add(entityTypes[entityTypesComboBox.Index]);
                reloadList();
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

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

            builder.BuildSessionEnd();

            startY = Height;

            painterTypesComboBox.Index = 0;

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

            CanResizeFormVertically = true;
        }
Пример #23
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);
        }
Пример #24
0
        public static Func <bool> GUI_Edit(SingleSlotBox container, RMP_Chromosome chromosome)
        {
            var builder = new FieldBuilder();

            builder.BuildSessionStart(container);

            Dictionary <string, object> valueHolder = new Dictionary <string, object>();

            valueHolder.Add("RMP_Chromosome", chromosome);

            var inhibitoryConnectionChance = builder.AddDoubleField("Inhibitory Connection-Chance: ");

            inhibitoryConnectionChance.Value = chromosome.InhibitoryConnectionChance;
            var connectionChance = builder.AddDoubleField("Connection-Chance: ");

            connectionChance.Value = chromosome.ConnectionChance;

            var newConnectionsCanForm = builder.AddCheckBoxField("NewConnectionsCanForm: ");

            newConnectionsCanForm.Checked = chromosome.NewConnectionsCanForm;
            var connectionsCanDie = builder.AddCheckBoxField("ConnectionsCanDie: ");

            connectionsCanDie.Checked = chromosome.ConnectionsCanDie;
            var newNeuronsCanForm = builder.AddCheckBoxField("NewNeuronsCanForm: ");

            newNeuronsCanForm.Checked = chromosome.NewNeuronsCanForm;
            var neuronsCanDie = builder.AddCheckBoxField("NeuronsCanDie: ");

            neuronsCanDie.Checked = chromosome.NeuronsCanDie;

            Action reloadChromosome = delegate()
            {
                chromosome.InhibitoryConnectionChance = inhibitoryConnectionChance.Value;
                chromosome.ConnectionChance           = connectionChance.Value;

                chromosome.NewConnectionsCanForm = newConnectionsCanForm.Checked;
                chromosome.ConnectionsCanDie     = connectionsCanDie.Checked;
                chromosome.NewNeuronsCanForm     = newNeuronsCanForm.Checked;
                chromosome.NeuronsCanDie         = neuronsCanDie.Checked;
            };

            if (chromosome.MutationGenes.Count == 0)
            {
                //Mutation Genes
                chromosome.MutationGenes.Add(new DoubleGene("NeuronAddChance", 0, 1, 0.1));
                chromosome.MutationGenes.Add(new DoubleGene("NeuronRemoveChance", 0, 1, 0.1));
                chromosome.MutationGenes.Add(new DoubleGene("MaxNeuronRemoving", 0, 1, 0.1));
                chromosome.MutationGenes.Add(new DoubleGene("MaxNeuronAdding", 0, 1, 0.1));
                chromosome.MutationGenes.Add(new DoubleGene("ConnectionAddChance", 0, 1, 0.05));
                chromosome.MutationGenes.Add(new DoubleGene("ConnectionRemoveChance", 0, 1, 0.05));
            }
            builder.AddResizableButtonField("Edit Mutation Genes", delegate(object sender)
            {
                EditDoubleGeneListForm.ShowDialogue(container.Parent, chromosome.MutationGenes);
            });

            var sigmoidTypes = Globals.GetAllTypesDeriving(typeof(SigmoidFunction), Assembly.GetExecutingAssembly());
            var sigmoidNames = new List <string>(sigmoidTypes.Select(s => s.Name));

            var globalSigmoidComboBox = builder.AddComboBoxField("GlobalSigmoid: ", sigmoidNames);

            if (chromosome.GlobalSigmoidFunction != null)
            {
                var globalSigmoidType = chromosome.GlobalSigmoidFunction.GetType();
                foreach (var type in sigmoidTypes)
                {
                    if (type.IsEquivalentTo(globalSigmoidType))
                    {
                        globalSigmoidComboBox.Index = sigmoidTypes.IndexOf(type);
                    }
                }
            }

            globalSigmoidComboBox.SelectedItemChanged += delegate(object sender, int newItemIndex, int oldItemIndex)
            {
                chromosome.GlobalSigmoidFunction = (SigmoidFunction)Activator.CreateInstance(sigmoidTypes[newItemIndex]);
            };
            var globalSigmoidEditButton = builder.AddResizableButtonField("Edit GlobalSigmoid", delegate(object sender)
            {
                if (chromosome.GlobalSigmoidFunction == null)
                {
                    return;
                }

                var sigmoid = chromosome.GlobalSigmoidFunction;
                sigmoidTypes[globalSigmoidComboBox.Index].InvokeMember("GUI_Edit", BindingFlags.Default | BindingFlags.InvokeMethod, null, null, new object[] { container.Parent, sigmoid });
            });

            var globalOutputSigmoidComboBox = builder.AddComboBoxField("GlobalOutputSigmoid: ", sigmoidNames);

            if (chromosome.GlobalOutputSigmoidFunction != null)
            {
                var globalOutputSigmoidType = chromosome.GlobalOutputSigmoidFunction.GetType();
                foreach (var type in sigmoidTypes)
                {
                    if (type.IsEquivalentTo(globalOutputSigmoidType))
                    {
                        globalOutputSigmoidComboBox.Index = sigmoidTypes.IndexOf(type);
                    }
                }
            }

            globalOutputSigmoidComboBox.SelectedItemChanged += delegate(object sender, int newItemIndex, int oldItemIndex)
            {
                chromosome.GlobalOutputSigmoidFunction = (SigmoidFunction)Activator.CreateInstance(sigmoidTypes[newItemIndex]);
            };
            var globalOutputSigmoidEditButton = builder.AddResizableButtonField("Edit GlobalOutputSigmoid", delegate(object sender)
            {
                if (chromosome.GlobalOutputSigmoidFunction == null)
                {
                    return;
                }

                var sigmoid = chromosome.GlobalOutputSigmoidFunction;
                sigmoidTypes[globalOutputSigmoidComboBox.Index].InvokeMember("GUI_Edit", BindingFlags.Default | BindingFlags.InvokeMethod, null, null, new object[] { container.Parent, sigmoid });
            });

            builder.AddResizableButtonField("Randomize", delegate(object sender)
            {
                reloadChromosome();

                if (chromosome.GlobalSigmoidFunction == null ||
                    chromosome.GlobalOutputSigmoidFunction == null)
                {
                    AlertForm.ShowDialogue(container.Parent, null, "Can't randomize before choosing a sigmoid function.");
                }
                else
                {
                    RandomizeForm.ShowDialogue(container.Parent, chromosome);
                }
            });

            builder.AddResizableButtonField("Edit Neuron-genes", delegate(object sender)
            {
                reloadChromosome();

                EditChromosomeNeuronsForm.ShowDialogue(container.Parent, valueHolder);
            });

            container.IsClosing += delegate(object sender)
            {
                reloadChromosome();
            };

            builder.BuildSessionEnd();

            return(delegate()
            {
                return chromosome.GlobalSigmoidFunction != null && chromosome.GlobalOutputSigmoidFunction != null;
            });
        }
Пример #25
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var isFirstGeneration = builder.AddCheckBoxField("IsFirstGeneration: ");

            isFirstGeneration.Checked        = genome.IsFirstGeneration;
            isFirstGeneration.CanChangeValue = false;

            var parent1 = builder.AddIntegerField("Parent1: ");

            parent1.Value          = genome.Parent1;
            parent1.CanChangeValue = false;

            var parent2 = builder.AddIntegerField("Parent2: ");

            parent2.Value          = genome.Parent2;
            parent2.CanChangeValue = false;

            builder.AddResizableButtonField("Edit Body-genes", delegate(object sender)
            {
                EditDoubleGeneListForm.ShowDialogue(Parent, genome.BodyGenes);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddResizableButtonField("Edit Mutation-genes", delegate(object sender)
            {
                EditDoubleGeneListForm.ShowDialogue(Parent, genome.MutationGenes);
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            var crossoverTypes = Globals.GetAllTypesDeriving(typeof(CrossoverFunction), Assembly.GetExecutingAssembly());
            var crossoverNames = new List <string>(crossoverTypes.Select(s => s.Name));

            var crossoverComboBox = builder.AddComboBoxField("Crossover Function: ", crossoverNames);

            if (genome.CrossoverFunction != null)
            {
                var crossoverType = genome.CrossoverFunction.GetType();
                foreach (var type in crossoverTypes)
                {
                    if (type.IsEquivalentTo(crossoverType))
                    {
                        crossoverComboBox.Index = crossoverTypes.IndexOf(type);
                    }
                }
            }

            crossoverComboBox.SelectedItemChanged += delegate(object sender, int newItemIndex, int oldItemIndex)
            {
                genome.CrossoverFunction = (CrossoverFunction)Activator.CreateInstance(crossoverTypes[newItemIndex]);
            };
            var globalSigmoidEditButton = builder.AddResizableButtonField("Edit Crossover Function", delegate(object sender)
            {
                if (genome.CrossoverFunction == null)
                {
                    return;
                }

                var crossoverFunc = genome.CrossoverFunction;
                crossoverTypes[crossoverComboBox.Index].InvokeMember("GUI_Edit", BindingFlags.Default | BindingFlags.InvokeMethod, null, null, new object[] { Parent, crossoverFunc });
            });

            builder.BuildSessionEnd();
        }
Пример #26
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;
        }
Пример #27
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var entityTemplatesComboBox = builder.AddComboBoxField("Templates: ");

            entityTemplatesComboBox.Items.AddRange(EditorData.EntityTemplates.Select(s => s.TemplateName));

            entityTemplatesComboBox.SelectedItemChanged += delegate(object sender, int newItemIndex, int oldItemIndex)
            {
                if (entityTemplatesComboBox.Index == -1)
                {
                    return;
                }

                string name = entityTemplatesComboBox.Items[entityTemplatesComboBox.Index];
                foreach (var c in EditorData.EntityTemplates)
                {
                    if (c.TemplateName == name)
                    {
                        entity = c.Entity.Clone();
                        break;
                    }
                }
            };

            entityTemplatesComboBox.Index = 0;

            var editButton = builder.AddResizableButtonField("Edit Entity", delegate(object sender)
            {
                if (entity != null)
                {
                    EditEntityForm.ShowDialogue(Parent, entity);
                }
            });

            var addByClicksCheckBox = builder.AddCheckBoxField("Add by clicks: ");

            var amountField = builder.AddIntegerField("Amount to add: ");

            amountField.MinValue = 1;

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                Editor.GetEntityFunctionDelegate getEntityFunc = delegate()
                {
                    var clone = (IEntity)entity.Clone();

                    return(clone);
                };

                if (!addByClicksCheckBox.Checked)
                {
                    for (int i = 0; i < amountField.Value; i++)
                    {
                        var clone = getEntityFunc();

                        world.AddEntity(clone);

                        clone.Position = new EntityPosition(Globals.Random.Next(world.Width), Globals.Random.Next(world.Height));
                    }
                }
                else
                {
                    Globals.Editor.Mode = Editor.Modes.AddEntity;
                    Globals.Editor.Set_GetEntityFunction(getEntityFunc);
                }

                Close();
            });

            builder.BuildSessionEnd();

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

            CanResizeFormVertically = false;
        }
Пример #28
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;
        }
Пример #29
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            var builder = new FieldBuilder();

            builder.BuildSessionStart(this);

            var genomeTemplatesComboBox = builder.AddComboBoxField("Genome: ");

            genomeTemplatesComboBox.Items.AddRange(EditorData.GenomeTemplates.Select(s => s.TemplateName));
            genomeTemplatesComboBox.Index = 0;

            var annTemplatesComboBox = builder.AddComboBoxField("ANN: ");

            annTemplatesComboBox.Items.AddRange(EditorData.ANNTemplates.Select(s => s.TemplateName));
            annTemplatesComboBox.Index = 0;

            var creatureTemplatesComboBox = builder.AddComboBoxField("Creature: ");

            creatureTemplatesComboBox.Items.AddRange(EditorData.CreatureTemplates.Select(s => s.TemplateName));
            creatureTemplatesComboBox.Index = 0;

            var mutateCheckBox = builder.AddCheckBoxField("Mutate the genome: ");

            var amountField = builder.AddIntegerField("Amount to add: ");

            amountField.MinValue = 1;

            builder.AddResizableButtonField("OK", delegate(object sender)
            {
                string name   = genomeTemplatesComboBox.Items[genomeTemplatesComboBox.Index];
                Genome genome = null;
                foreach (var g in EditorData.GenomeTemplates)
                {
                    if (g.TemplateName == name)
                    {
                        genome = g.Genome;
                    }
                }

                name = annTemplatesComboBox.Items[annTemplatesComboBox.Index];
                INeuralNetChromosome ann = null;
                foreach (var a in EditorData.ANNTemplates)
                {
                    if (a.TemplateName == name)
                    {
                        ann = a.ANN;
                    }
                }

                name = creatureTemplatesComboBox.Items[creatureTemplatesComboBox.Index];
                ICreature creature = null;
                foreach (var c in EditorData.CreatureTemplates)
                {
                    if (c.TemplateName == name)
                    {
                        creature = c.Creature;
                    }
                }

                for (int i = 0; i < amountField.Value; i++)
                {
                    var clone       = (ICreature)creature.Clone();
                    var cloneGenome = genome.Clone();
                    cloneGenome.SetNetChromosome(ann.Clone());

                    if (mutateCheckBox.Checked)
                    {
                        cloneGenome.Mutate();
                    }

                    clone.ImprintGenome(cloneGenome);

                    world.AddEntity(clone);

                    clone.Position = new EntityPosition(Globals.Random.Next(world.Width), Globals.Random.Next(world.Height));
                }
            });

            builder.BuildSessionEnd();

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

            CanResizeFormVertically = false;
        }
Пример #30
0
        public override void AddedToContainer()
        {
            base.AddedToContainer();

            leftPanel = new Panel();
            leftPanel.Initialize();
            AddDrawBox(leftPanel);

            rightPanel = new Panel();
            rightPanel.Initialize();
            AddDrawBox(rightPanel);

            var builder = new FieldBuilder();

            builder.BuildSessionStart(leftPanel);

            entitiesWithPainters = builder.AddColumnListBox("Entities being drawn:", 400, 2);
            entitiesWithPainters.SetColumnName(0, "Entity-Type");
            entitiesWithPainters.SetColumnName(1, "Painter-Type");

            builder.BuildSessionEnd();

            builder.BuildSessionStart(rightPanel);

            entityPainters = builder.AddColumnListBox("Entity-painters:", 400, 1);
            entityPainters.SetColumnName(0, "Painter-Type");

            builder.AddResizableButtonField("Add Painter", delegate(object sender)
            {
                AddEntityPainterForm.ShowDialogue(Parent, simulation, delegate(object _sender)
                {
                    var form = (AddEntityPainterForm)_sender;

                    form.Result.Initialize(DrawBox.DefaultSkinFile);
                    simulation.EntityPainters.Add(form.Result);

                    reloadEntitiesWithPaintersList();
                    reloadPainterList();
                });
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.AddResizableButtonField("Remove Painter", delegate(object sender)
            {
                if (entityPainters.SelectedRow != null)
                {
                    simulation.EntityPainters.Remove((IEntityPainter)entityPainters.SelectedRow.ExtraValues[0]);
                    reloadEntitiesWithPaintersList();
                    reloadPainterList();
                }
            }, FieldBuilder.ResizableButtonOrientation.FillWidth);

            builder.BuildSessionEnd();

            leftPanel.Width  = Math.Max(leftPanel.Width, rightPanel.Width);
            leftPanel.Height = Math.Max(leftPanel.Height, rightPanel.Height);

            rightPanel.X      = leftPanel.Width + panelMargin;
            rightPanel.Width  = Math.Max(leftPanel.Width, rightPanel.Width);
            rightPanel.Height = Math.Max(leftPanel.Height, rightPanel.Height);

            Wrap();

            reloadEntitiesWithPaintersList();
            reloadPainterList();

            leftPanel.Alignment  = DrawBoxAlignment.GetTopBottom();
            rightPanel.Alignment = DrawBoxAlignment.GetTopBottom();

            SizeChanged += new SizeChangedEvent(EntityDrawingOptionsForm_SizeChanged);

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