Example #1
0
        public void Test_Descendents()
        {
            var e1 = new Entity();

            var c1 = new Entity();

            var d1 = new Entity();

            c1.AddChild(d1);

            var d2 = new Entity();

            c1.AddChild(d2);

            e1.AddChild(c1);

            Assert.True(d2.Info.IsDescendantOf(ref c1.Info));
            Assert.True(d2.Info.IsDescendantOf(ref e1.Info));
            Assert.True(d1.Info.IsDescendantOf(ref c1.Info));
            Assert.True(d1.Info.IsDescendantOf(ref e1.Info));
            Assert.True(c1.Info.IsDescendantOf(ref e1.Info));

            Assert.False(d2.Info.IsDescendantOf(ref d1.Info));
            Assert.False(d1.Info.IsDescendantOf(ref d2.Info));
            Assert.False(c1.Info.IsDescendantOf(ref d1.Info));
            Assert.False(c1.Info.IsDescendantOf(ref d2.Info));
            Assert.False(e1.Info.IsDescendantOf(ref c1.Info));
        }
Example #2
0
        protected virtual void SetupLighting(Entity camera)
        {
            // Depending on RenderingMode, use HDR or LDR settings for the lights
            var factor = 1.0f;

            if (RenderingMode == RenderingMode.HDR)
            {
                factor = 2.0f / 0.9f;
            }

            var ambientLight = new Entity("Preview Ambient Light1")
            {
                new LightComponent {
                    Type = new LightAmbient(), Intensity = 0.02f * factor
                }
            };
            var frontDirectionalLight = new Entity("Preview Directional Front")
            {
                new LightComponent {
                    Intensity = 0.07f * factor
                }
            };
            var topDirectionalLight = new Entity("Preview Directional Top")
            {
                new LightComponent {
                    Intensity = 0.8f * factor
                }
            };

            topDirectionalLight.Transform.Rotation = Quaternion.RotationX(MathUtil.DegreesToRadians(-80));
            camera.AddChild(ambientLight);
            camera.AddChild(frontDirectionalLight);
            camera.AddChild(topDirectionalLight);
        }
Example #3
0
        public PipeSet(Entity referencePipeEntity, float scrollSpeed, float startScrollPos, float screenWidth)
        {
            this.scrollSpeed    = scrollSpeed;
            this.startScrollPos = startScrollPos;
            halfScrollWidth     = screenWidth / 2f;

            // Store Entity and create another one for two rendering:
            // top and bottom sprite of pipe.
            var spriteComp = referencePipeEntity.Get <SpriteComponent>();

            bottomPipe = referencePipeEntity.Clone();
            topPipe    = referencePipeEntity.Clone();
            Entity.AddChild(bottomPipe);
            Entity.AddChild(topPipe);

            var sprite = spriteComp.CurrentSprite;

            pipeWidth     = sprite.SizeInPixels.X;
            pipeHeight    = sprite.SizeInPixels.Y;
            halfPipeWidth = pipeWidth / 2f;

            // Setup pipeCollider
            pipeCollider = new RectangleF(0, 0, pipeWidth, pipeHeight);

            // Place the top/bottom pipes relatively to the root.
            topPipe.Transform.Position.Y    = -(VerticalDistanceBetweenPipe + pipeHeight) * 0.5f;
            bottomPipe.Transform.Position.Y = (VerticalDistanceBetweenPipe + pipeHeight) * 0.5f;
            bottomPipe.Transform.Rotation   = Quaternion.RotationZ(MathUtil.Pi);

            ResetPipe();
        }
Example #4
0
        protected override Entity Create()
        {
            base.Create();

            overlaySphereDefaultMaterial = CreateUniformColorMaterial(new Color(0.3f, 0.3f, 0.3f, 0.025f));
            overlaySphereSelectedMaterial = CreateUniformColorMaterial(new Color(0.4f, 0.4f, 0.4f, 0.025f));

            var entity = new Entity("Rotation Gizmo");
            var rotations = new[] { new Vector3(0, 0, -MathUtil.Pi / 2), new Vector3(), new Vector3(MathUtil.Pi / 2, 0, 0) };
            var bodyMesh = GeometricPrimitive.Torus.New(GraphicsDevice, RotationGizmoRadius, RotationGizmoThickness, GizmoTessellation).ToMeshDraw();

            for (int axis = 0; axis < 3; ++axis)
            {
                var axisMaterial = GetAxisDefaultMaterial(axis);
                rotationAxes[axis] = new Entity("RotationGizmo" + axis) { new ModelComponent { Model = new Model { axisMaterial, new Mesh { Draw = bodyMesh } }, RenderGroup = RenderGroup } };
                rotationAxes[axis].Transform.RotationEulerXYZ = rotations[axis];
                entity.AddChild(rotationAxes[axis]);
            }

            // Add overlay sphere
            var overlayMeshDraw = GeometricPrimitive.Sphere.New(GraphicsDevice, RotationGizmoRadius, GizmoTessellation).ToMeshDraw();
            overlaySphere = new Entity("OverlaySphere") { new ModelComponent { Model = new Model { overlaySphereDefaultMaterial, new Mesh { Draw = overlayMeshDraw } }, RenderGroup = RenderGroup } };
            entity.AddChild(overlaySphere);

            // Add middle sphere
            var sphereMeshDraw = GeometricPrimitive.Sphere.New(GraphicsDevice, OriginRadius, GizmoTessellation).ToMeshDraw();
            var rotationOrigin = new Entity("OriginSphere") { new ModelComponent { Model = new Model { DefaultOriginMaterial, new Mesh { Draw = sphereMeshDraw } }, RenderGroup = RenderGroup } };
            entity.Transform.Children.Add(rotationOrigin.Transform);

            return entity;
        }
Example #5
0
        public void Test_AddMultiple()
        {
            var e1 = new Entity();

            e1.AddChild(new Entity());
            e1.AddChild(new Entity());
            e1.AddChild(new Entity());
            e1.AddChild(new Entity());
            e1.AddChild(new Entity());
        }
Example #6
0
        private void addToken(Entity entity, string parentName, string name, JToken token)
        {
            string fullName = parentName + "." + name;

            if (token.Type == JTokenType.Object)
            {
                Entity newEntity = new Entity(name, Entity.Types.PARENT);
                entity.AddChild(parentName, newEntity);
                addObject(newEntity, fullName, token as JObject);
            }
            else if (token.Type == JTokenType.Array)
            {
                Entity newEntity = new Entity(name, Entity.Types.ARRAY);
                entity.AddChild(parentName, newEntity);

                JArray array = token as JArray;
                int    id    = 0;
                foreach (var entry in array.Children())
                {
                    addToken(newEntity, parentName, "~" + (++id), entry);
                }
            }
            else if (token.Type != JTokenType.Comment)
            {
                Entity.Types type;
                string       value = token.ToString();

                if (token.Type == JTokenType.Integer || token.Type == JTokenType.Float)
                {
                    type = Entity.Types.NUM;
                }
                else if (token.Type == JTokenType.Date)
                {
                    type = Entity.Types.DATE;
                }
                else if (token.Type == JTokenType.Boolean)
                {
                    type  = Entity.Types.BOOL;
                    value = value.ToLower();
                }
                else if (token.Type == JTokenType.Null)
                {
                    type  = Entity.Types.STR;
                    value = Entity.NULL;
                }
                else
                {
                    type = Entity.Types.STR;
                }

                Entity newEntity = new Entity(name, type, value);
                entity.AddChild(parentName, newEntity);
            }
        }
Example #7
0
        private Entity CreateEntityWithChildren()
        {
            var e1 = new Entity();

            e1.AddChild(new Entity());
            e1.AddChild(new Entity());
            e1.AddChild(new Entity());
            e1.AddChild(new Entity());
            e1.AddChild(new Entity());
            return(e1);
        }
Example #8
0
        private void Create_Layout()
        {
            // Creating layout bitmaps(money, lives).
            int x      = WaveServices.Platform.ScreenWidth - 32;
            var y      = (WaveServices.Platform.ScreenHeight / 2) - (WaveServices.Platform.ScreenHeight / 2) + 32;
            var sprite = "Content/Layout/Lives.wpk";

            Entity lives = Static.Functions.Create_entity("Lives", x, y, sprite);

            ScreenLayout.AddChild(lives);

            x      = WaveServices.Platform.ScreenWidth - (64 + 75);
            y      = (WaveServices.Platform.ScreenHeight / 2) - (WaveServices.Platform.ScreenHeight / 2) + 32;
            sprite = "Content/Layout/Money.wpk";

            Entity money = Static.Functions.Create_entity("Money", x, y, sprite);

            ScreenLayout.AddChild(money);

            // Creating text for money and lives.
            MoneyCounter = new TextBlock()
            {
                Text                = Player.Gold.ToString(CultureInfo.InvariantCulture),
                Width               = 75,
                Foreground          = WaveEngine.Common.Graphics.Color.DarkGreen,
                TextAlignment       = TextAlignment.Right,
                HorizontalAlignment = HorizontalAlignment.Right,
                Margin              = new Thickness(0, 0, 180, 0)
            };

            MonsterCounter = new TextBlock()
            {
                Text                = Player.Lives.ToString(CultureInfo.InvariantCulture),
                Width               = 75,
                Foreground          = WaveEngine.Common.Graphics.Color.Gainsboro,
                TextAlignment       = TextAlignment.Right,
                HorizontalAlignment = HorizontalAlignment.Right,
                Margin              = new Thickness(0, 0, 70, 0)
            };

            TimerCounter = new TextBlock()
            {
                Text                = "0",
                Width               = 100,
                Foreground          = WaveEngine.Common.Graphics.Color.BlanchedAlmond,
                TextAlignment       = TextAlignment.Left,
                HorizontalAlignment = HorizontalAlignment.Left,
                Margin              = new Thickness(120, 0, 0, 0)
            };


            Create_Timer();
        }
Example #9
0
        public void TestEntityAndChildren()
        {
            var registry      = new ServiceRegistry();
            var entityManager = new CustomEntityManager(registry);

            // Entity with a sub-Entity
            var childEntity0 = new Entity();
            var entity       = new Entity();

            entity.AddChild(childEntity0);

            // ================================================================
            // 1) Add entity with sub-entity and check EntityManager and TransformProcessor
            // ================================================================
            entityManager.Add(entity);
            var transformProcessor = entityManager.GetProcessor <TransformProcessor>();

            Assert.NotNull(transformProcessor);

            Assert.AreEqual(2, entityManager.Count);
            Assert.AreEqual(1, transformProcessor.TransformationRoots.Count);
            Assert.True(transformProcessor.TransformationRoots.Contains(entity.Transform));

            // ================================================================
            // 2) Remove child from entity while the Entity is still in the EntityManager
            // ================================================================
            entity.Transform.Children.RemoveAt(0);

            Assert.AreEqual(1, entityManager.Count);
            Assert.AreEqual(1, transformProcessor.TransformationRoots.Count);
            Assert.True(transformProcessor.TransformationRoots.Contains(entity.Transform));

            // ================================================================
            // 3) Add a child to the root entity while the Entity is still in the EntityManager
            // ================================================================
            var childEntity = new Entity();

            entity.AddChild(childEntity);

            Assert.AreEqual(2, entityManager.Count);
            Assert.AreEqual(1, transformProcessor.TransformationRoots.Count);
            Assert.True(transformProcessor.TransformationRoots.Contains(entity.Transform));

            // ================================================================
            // 3) Remove top level entity
            // ================================================================
            entityManager.Remove(entity);

            Assert.AreEqual(0, entityManager.Count);
            Assert.AreEqual(0, transformProcessor.TransformationRoots.Count);
        }
Example #10
0
        protected override void ContextMenuImpl(Entity parent, PlatformContext context, Vector2 world)
        {
            var tilePos = context.WorldToTile(world);
            var cell    = context.Map[tilePos];

            var background = new Panel(new Vector2(0, 256), skin: PanelSkin.Simple, anchor: Anchor.AutoCenter);
            var label      = new Label("Background:", Anchor.TopCenter);

            background.AddChild(label);
            var backgroundPicker = new TilePicker(context.BlockStore, cell.Background, new Vector2(0, 128), Anchor.BottomCenter, overflow: false);

            backgroundPicker.OnItemClick += (e, tile) =>
            {
                backgroundPicker.RemoveChild(e);
                cell.Background.Remove(tile);
            };
            background.AddChild(backgroundPicker);
            parent.AddChild(background);

            var foreground = new Panel(new Vector2(0, 256), skin: PanelSkin.Simple, anchor: Anchor.AutoCenter);

            label = new Label("Foreground:", Anchor.TopCenter);
            foreground.AddChild(label);
            var foregroundPicker = new TilePicker(context.BlockStore, cell.Foreground, new Vector2(0, 128), Anchor.BottomCenter, overflow: false);

            foreground.AddChild(foregroundPicker);
            parent.AddChild(foreground);

            var blocking = new Panel(new Vector2(0, 256), skin: PanelSkin.Simple, anchor: Anchor.AutoCenter);

            label = new Label("Block:", Anchor.TopCenter);
            blocking.AddChild(label);
            var blocks         = cell.Block == null ? new ITile[0] : new[] { cell.Block };
            var blockingPicker = new TilePicker(context.BlockStore, blocks, new Vector2(0, 128), Anchor.BottomCenter, overflow: false);

            blocking.AddChild(blockingPicker);
            parent.AddChild(blocking);

            var button = new Button("Clear", anchor: Anchor.BottomCenter);

            button.OnClick += (e) =>
            {
                context.Map[tilePos].Background.Clear();
                context.Map[tilePos].Foreground.Clear();
                context.Map[tilePos].Block = null;
            };
            parent.AddChild(button);
        }
Example #11
0
        public override void Start()
        {
            radius = 0.001f;

            // VertexPositionNormalTexture is the layout that the engine uses in the shaders
            var vBuffer = Stride.Graphics.Buffer.Vertex.New(GraphicsDevice, new VertexPositionNormalTexture[]
            {
                new VertexPositionNormalTexture(new Vector3(-radius, radius, 0), new Vector3(0, 1, 1), new Vector2(0, 0)), //Top Left.
                new VertexPositionNormalTexture(new Vector3(radius, -radius, 0), new Vector3(0, 1, 1), new Vector2(0, 0)), //Bottom right.
                new VertexPositionNormalTexture(new Vector3(radius, radius, 0), new Vector3(0, 1, 1), new Vector2(0, 0)),  //Bottom right.
                new VertexPositionNormalTexture(new Vector3(-radius, -radius, 0), new Vector3(0, 1, 1), new Vector2(0, 0)) //Top Left.
            });

            MeshDraw meshDraw = new MeshDraw
            {
                PrimitiveType = PrimitiveType.LineStrip, // Tell the GPU that this is a line.
                VertexBuffers = new[] { new VertexBufferBinding(vBuffer, VertexPositionNormalTexture.Layout, vBuffer.ElementCount) },
                DrawCount     = vBuffer.ElementCount
            };

            Mesh mesh = new Mesh();

            mesh.Draw = meshDraw;

            Model model = new Model();

            model.Add(mesh);
            shotMesh = new ModelComponent(model);

            shot = new Entity();
            shot.Add(shotMesh);
            Entity.AddChild(shot);
            Disable();
        }
Example #12
0
        private Entity CreateCannon(Entity entity, Random random)
        {
            var cannonRotor = new Entity();

            entity.AddChild(cannonRotor);
            cannonRotor.AddComponent(new Transform2DComponent
            {
                Translation = Vector2.Zero,
                Rotation    = random.NextDouble(),
                Scale       = Vector2.One
            });

            var cannon = new Entity();

            cannonRotor.AddChild(cannon);

            cannon.AddComponent(new Transform2DComponent
            {
                Translation = new Vector2(0, 10),
                Rotation    = 0,
                Scale       = Vector2.One
            });
            cannon.AddComponent(new RectangleRendererComponent
            {
                Color        = Color.FromArgb(1, random.NextDouble(), random.NextDouble(), random.NextDouble()),
                Dimension    = new Vector2(10, 30),
                FillInterior = true,
                OrderInLayer = 1
            });
            cannon.AddComponent(new CannonBehaviorComponent {
                Random = random
            });

            return(cannon);
        }
Example #13
0
        public override async Task Execute()
        {
            var task = new Task(async() => {
                var ofn = $"/cache/{ZoneName}.zip";
                if (!await VirtualFileSystem.FileExistsAsync(ofn))
                {
                    WriteLine($"Attempting to convert zone {ZoneName} for first use.");

                    var taskS3dObjFiles = S3DConverter.ReadS3DAsync($@"{EverquestPath}\{ZoneName}_obj.s3d");
                    var taskS3dFiles    = S3DConverter.ReadS3DAsync($@"{EverquestPath}\{ZoneName}.s3d");

                    Task.WaitAll(taskS3dObjFiles, taskS3dFiles);
                    var s3dObjFilesDict = taskS3dObjFiles.Result.Merge(taskS3dFiles.Result);
                    var s3dFilesDict    = taskS3dFiles.Result.Merge(taskS3dObjFiles.Result);

                    var zone = new Zone();

                    ConvertObjects(s3dObjFilesDict, $"{ZoneName}_obj.wld", zone);
                    ConvertObjects(s3dFilesDict, "objects.wld", zone);
                    ConvertLights(s3dFilesDict, "lights.wld", zone);
                    ConvertZone(s3dFilesDict, $"{ZoneName}.wld", zone);

                    using (var stream = VirtualFileSystem.OpenStream(ofn, VirtualFileMode.Create, VirtualFileAccess.Write))
                        zone.Output(stream);
                }
                WriteLine("Loading zone");
                var rstream    = VirtualFileSystem.OpenStream(ofn, VirtualFileMode.Open, VirtualFileAccess.Read);
                var zoneEntity = OEQZoneReader.Read((Game)Game, ZoneName, rstream);
                Entity.AddChild(zoneEntity);
            });

            task.Start();
            await task;
        }
Example #14
0
        private void InstantiateTemplate(Model.Graph templateGraph, Entity targetEntity)
        {
            Dictionary <Entity, Entity> templateToInstanceMapping = new();

            // instantiate all entities from template and remember mapping
            foreach (var templateEntity in templateGraph.Entities)
            {
                var templateInstance = templateEntity.CreateDuplicate(_graph, targetEntity);
                templateToInstanceMapping.Add(templateEntity, templateInstance);
                targetEntity.AddChild(templateInstance);
            }

            // add internal relations between instantiated entities
            foreach (var templateLayer in templateGraph.GetLayers())
            {
                Layer layer = _graph.GetOrAddLayer(templateLayer.Name);

                foreach (var templateRelation in templateLayer.Relations)
                {
                    var from = templateToInstanceMapping[templateRelation.Entities[0]];
                    var to   = templateToInstanceMapping[templateRelation.Entities[1]];
                    layer.AddRelation(from, to, templateRelation.Name);
                }
            }
        }
Example #15
0
        public override void Start()
        {
            // creates a subentity for the light
            lightEntity = new Entity();
            lightSprite = lightEntity.GetOrCreate <SpriteComponent>();
            lightSprite.SpriteProvider = new SpriteFromSheet()
            {
                Sheet        = robotSpriteSheet,
                CurrentFrame = 1,
            };
            lightSprite.Enabled = false;

            lightPhysics = lightEntity.GetOrCreate <RigidbodyComponent>();
            lightPhysics.ColliderShapes.Add(new BoxColliderShapeDesc
            {
                Is2D = true,
                Size = new Vector3(0.3f, 0.4f, 0),
            });
            lightPhysics.RigidBodyType = RigidBodyTypes.Kinematic;
            // Reacts with light switches
            lightPhysics.CanCollideWith = CollisionFilterGroupFlags.CustomFilter1;
            lightPhysics.CollisionGroup = CollisionFilterGroups.CustomFilter1;
            lightPhysics.Enabled        = false;

            Entity.AddChild(lightEntity);
            EnabledState = false;
        }
Example #16
0
 /// <summary>
 /// Замена юнитов из цепочки однородных сущностей на саму сущность
 /// </summary>
 /// <param name="unitCollection">коллекция, содержащие юниты цепочки однородных сущностей</param>
 public void ReplaceUnits(IList <UnitTextBase> unitCollection)
 {
     if (_units.Any())
     {
         int    index       = unitCollection.IndexOf(_units.First());
         Entity homogeneous = new Entity(_units.GetText(), _units.First().PositionInfo.Start, new HomogeneousEntityInfo()
         {
             Pretext = _pretext
         });
         SimpleStringBuilder value = new SimpleStringBuilder();
         foreach (UnitTextBase unit in _units)
         {
             unitCollection.RemoveAt(index);
             if (unit.IsEntity)
             {
                 Entity entity = (Entity)unit;
                 homogeneous.AddChild(entity);
                 value.Append(entity.Value);
             }
             else
             {
                 value.Append(unit.Text);
             }
         }
         homogeneous.EntityInfo.Value  = value.TrueValue;
         homogeneous.EntityInfo.Morpho = GetChainMorphoInformation();
         unitCollection.Insert(index, homogeneous);
     }
 }
Example #17
0
        public unsafe void TestComponentAccess()
        {
            var entity = new Entity();

            entity.AddChild(new Entity("child1")
            {
                new LightComponent()
            });

            var modelComponent = new ModelComponent();

            var compiledUpdate = UpdateEngine.Compile(typeof(Entity), new List <UpdateMemberInfo>
            {
                new UpdateMemberInfo("[ModelComponent.Key]", 0),
                new UpdateMemberInfo("child1[LightComponent.Key].Intensity", 0),
            });

            var testData = new TestData[] { 32.0f };

            fixed(TestData *dataPtr = testData)
            {
                UpdateEngine.Run(entity, compiledUpdate, (IntPtr)dataPtr, new[] { new UpdateObjectData(modelComponent) });
            }

            Assert.That(entity.Get(ModelComponent.Key), Is.EqualTo(modelComponent));
            Assert.That(entity.GetChild(0).Get(LightComponent.Key).Intensity, Is.EqualTo(32.0f));
        }
Example #18
0
 public override void Start()
 {
     //Sites.Add(new Site() {degreesLat = 52, degreesLong = 0});
     //Sites.Add(new Site() {degreesLat = 36.2f, degreesLong = 138.25f});
     LoadSites();
     Log.Info("local path" + Directory.GetCurrentDirectory());
     foreach (var site in Captials)
     {
         Log.Info("adding cap enity " + site.Name);
         var instance     = capitialPrefab.Instantiate();
         var siteInstance = instance[0];
         siteInstance.Transform.Scale = siteInstance.Transform.Scale / Entity.Transform.Scale.X;
         siteInstance.Components.Add(site);
         Entity.AddChild(siteInstance);
         Log.Info("added cap enity" + site.Name);
         foreach (var subsite in site.subSites)
         {
             Log.Info("adding site enity" + subsite.Name);
             var subInstance = sitePrefab.Instantiate();
             Log.Info("instatiated prefab");
             var subSiteInstance = subInstance[0];
             Log.Info("got prefab isntance");
             subSiteInstance.Transform.Scale = subSiteInstance.Transform.Scale / Entity.Transform.Scale.X;
             Log.Info("transforemd scale");
             subSiteInstance.Components.Add(subsite);
             Log.Info("added com");
             Entity.AddChild(subSiteInstance);
             Log.Info("added site enity" + subsite.Name);
         }
     }
     // Initialization of the script.
 }
Example #19
0
        public void Test_TreeSet()
        {
            var a = new Entity();
            var b = new Entity();
            var c = new Entity();
            var d = new Entity();
            var e = new Entity();

            a.AddChild(b);
            Assert.Equal(a.Info.Tree, b.Info.Tree);

            c.AddChild(d);
            Assert.Equal(c.Info.Tree, d.Info.Tree);
            Assert.Equal(1, c.Data.Children.Count);

            e.AddChild(c);
            Assert.Equal(1, e.Data.Children.Count);
            Assert.Equal(e.Context, c.Context);
            Assert.Equal(e.Context, d.Context);
            Assert.Equal(e.Info.Tree, c.Info.Tree);
            Assert.Equal(e.Info.Tree, d.Info.Tree);

            b.AddChild(e);

            Assert.Equal(a.Info.Tree, b.Info.Tree);
            Assert.Equal(a.Info.Tree, c.Info.Tree);
            Assert.Equal(a.Info.Tree, d.Info.Tree);
            Assert.Equal(a.Info.Tree, e.Info.Tree);
        }
Example #20
0
        public unsafe void TestComponentAccess()
        {
            var entity = new Entity();

            entity.AddChild(new Entity("child1")
            {
                new LightComponent()
            });

            var modelComponent = new ModelComponent();

            var compiledUpdate = UpdateEngine.Compile(typeof(Entity), new List <UpdateMemberInfo>
            {
                new UpdateMemberInfo("[ModelComponent]", 0),
                new UpdateMemberInfo("child1[LightComponent.Key].Intensity", 0), // Keep key just for backward comp, we will remove it
            });

            var testData = new TestData[] { 32.0f };

            fixed(TestData *dataPtr = testData)
            {
                UpdateEngine.Run(entity, compiledUpdate, (IntPtr)dataPtr, new[] { new UpdateObjectData(modelComponent) });
            }

            Assert.Equal(modelComponent, entity.Get <ModelComponent>());
            Assert.Equal(32.0f, entity.GetChild(0).Get <LightComponent>().Intensity);
        }
Example #21
0
        public void UpdateDiagnostics_ShouldCauseGetDiagnosticInfoReturn_RootEntitiesCount_Of3_And_AllEntitiesCount_Of5()
        {
            // Arrange
            var configurationBuilder = CoreConfiguration.CreateBuilder();

            configurationBuilder.WithShowRootEntitiesCount(true);
            configurationBuilder.WithShowAllEntitiesCount(true);

            var entity1 = new Entity();

            entity1.AddChild(new Entity());
            var entity2 = new Entity();

            entity2.AddChild(new Entity());
            var entity3 = new Entity();

            var scene = TestSceneFactory.Create();

            scene.AddEntity(entity1);
            scene.AddEntity(entity2);
            scene.AddEntity(entity3);

            var coreDiagnosticInfoProvider = GetCoreDiagnosticInfoProvider(configurationBuilder.Build());

            // Act
            coreDiagnosticInfoProvider.UpdateDiagnostics(scene);

            // Assert
            var diagnosticInfo    = coreDiagnosticInfoProvider.GetDiagnosticInfo().ToList();
            var rootEntitiesCount = diagnosticInfo.Single(di => di.Name == "RootEntitiesCount").Value;
            var allEntitiesCount  = diagnosticInfo.Single(di => di.Name == "AllEntitiesCount").Value;

            Assert.That(rootEntitiesCount, Is.EqualTo(3.ToString()));
            Assert.That(allEntitiesCount, Is.EqualTo(5.ToString()));
        }
Example #22
0
        public override void Start()
        {
            base.Start();
            float size = Main.instance.RandomMinMax(0.003666f, 0.00666f);
            // VertexPositionNormalTexture is the layout that the engine uses in the shaders
            var vBuffer = Stride.Graphics.Buffer.Vertex.New(GraphicsDevice, new VertexPositionNormalTexture[]
            {
                new VertexPositionNormalTexture(new Vector3(0, -size, 0), new Vector3(0, 1, 1), new Vector2(0, 0)), //Top Left.
                new VertexPositionNormalTexture(new Vector3(0, size, 0), new Vector3(0, 1, 1), new Vector2(0, 0))   //Bottom right.
            });

            MeshDraw meshDraw = new MeshDraw
            {
                PrimitiveType = PrimitiveType.LineStrip, // Tell the GPU that this is a line.
                VertexBuffers = new[] { new VertexBufferBinding(vBuffer, VertexPositionNormalTexture.Layout, vBuffer.ElementCount) },
                DrawCount     = vBuffer.ElementCount
            };

            Mesh mesh = new Mesh();

            mesh.Draw = meshDraw;

            Model model = new Model();

            model.Add(mesh);
            lineMesh = new ModelComponent(model);
            line     = new Entity();
            line.Add(lineMesh);
            Entity.AddChild(line);
            Destroy();
        }
        private void CreatePipe(Entity pipeEntity, float startPosX)
        {
            var pipe = new PipeSet(pipeEntity, -GameScript.GameSpeed, startPosX, GraphicsDevice.BackBuffer.Width);

            pipeSetList.Add(pipe);
            Entity.AddChild(pipe.Entity);
        }
Example #24
0
        private void ReadEntity(JsonElement entityElement, Entity entity)
        {
            #region Name

            var name = entityElement.GetProperty(PropertyName.Entity.Name).GetString() ??
                       throw new InvalidOperationException($"Cannot deserialize scene. {PropertyName.Entity.Name} property of entity cannot be null.");
            entity.Name = name;

            #endregion

            #region Components

            var componentsElement = entityElement.GetProperty(PropertyName.Entity.Components).EnumerateArray();
            foreach (var componentElement in componentsElement)
            {
                ReadComponent(componentElement, entity);
            }

            #endregion

            #region Children

            var childrenElement = entityElement.GetProperty(PropertyName.Entity.Children).EnumerateArray();
            foreach (var childEntityElement in childrenElement)
            {
                var childEntity = new Entity();
                ReadEntity(childEntityElement, childEntity);
                entity.AddChild(childEntity);
            }

            #endregion
        }
Example #25
0
        public void TestReset()
        {
            var registry      = new ServiceRegistry();
            var entityManager = new CustomEntityManager(registry);

            // Entity with a sub-Entity
            var childEntity0 = new Entity();
            var entity       = new Entity();

            entity.AddChild(childEntity0);

            // ================================================================
            // 1) Add entity with sub-entity and check EntityManager and TransformProcessor
            // ================================================================
            entityManager.Add(entity);
            var transformProcessor = entityManager.GetProcessor <TransformProcessor>();

            Assert.NotNull(transformProcessor);

            Assert.AreEqual(2, entityManager.Count);
            Assert.AreEqual(1, transformProcessor.TransformationRoots.Count);
            Assert.True(transformProcessor.TransformationRoots.Contains(entity.Transform));

            // ================================================================
            // 2) Reset the manager
            // ================================================================
            entityManager.Reset();

            Assert.AreEqual(0, entityManager.Count);
            Assert.AreEqual(0, entityManager.MapComponentTypeToProcessors.Count);
            Assert.AreEqual(0, entityManager.Processors.Count);
            Assert.AreEqual(0, transformProcessor.TransformationRoots.Count);
            Assert.Null(transformProcessor.EntityManager);
            Assert.Null(entity.Owner);
        }
Example #26
0
        public override void Start()
        {
            var spawnedEntity = Prefab.Instantiate().First();

            spawnedEntity.Name = Entity.GetParent().Name;
            Entity.AddChild(spawnedEntity);
        }
Example #27
0
        public void Start()
        {
            characterPrefab = Content.Load(CharacterPrefabUrl);

            UIScript.UserControlled = false;

            neat = new NeuralNetworkEvolution();

            generation = 0;
            highscore  = 0;

            root             = new Entity("CharacterRoot");
            characters       = new Entity[neat.options.Population];
            characterScripts = new CharacterScript[neat.options.Population];
            characterPhysics = new RigidbodyComponent[neat.options.Population];

            for (int i = 0; i < characters.Length; i++)
            {
                characters[i]                   = characterPrefab.Instantiate()[0];
                characterScripts[i]             = characters[i].Get <CharacterScript>();
                characterScripts[i].CharacterId = (uint)i + 1;
                characterScripts[i].Broadcast   = false;
                characterPhysics[i]             = characters[i].Get <RigidbodyComponent>();

                root.AddChild(characters[i]);
            }

            Entity.Scene.Entities.Insert(2, root);

            Profiler.Enable(AIProfilingKey);
            //characterPhysics[0].Simulation.ColliderShapesRendering = true;

            ResetRound();
        }
Example #28
0
        public static void SpawnPrefabModel(this ScriptComponent script, Prefab source, Entity attachEntity, Matrix localMatrix, Vector3 forceImpulse)
        {
            if (source == null)
            {
                return;
            }

            // Clone
            var spawnedEntities = source.Instantiate();

            // Add
            foreach (var prefabEntity in spawnedEntities)
            {
                prefabEntity.Transform.UpdateLocalMatrix();
                var entityMatrix = prefabEntity.Transform.LocalMatrix * localMatrix;
                entityMatrix.Decompose(out prefabEntity.Transform.Scale, out prefabEntity.Transform.Rotation, out prefabEntity.Transform.Position);

                if (attachEntity != null)
                {
                    attachEntity.AddChild(prefabEntity);
                }
                else
                {
                    script.SceneSystem.SceneInstance.RootScene.Entities.Add(prefabEntity);
                }

                var physComp = prefabEntity.Get <RigidbodyComponent>();
                if (physComp != null)
                {
                    physComp.ApplyImpulse(forceImpulse);
                }
            }
        }
Example #29
0
        private Entity LoadModel(string model, string texture, Entity parent, bool isAdditive)
        {
            Entity entity = new Entity(model)
                            .AddComponent(new Model(string.Format(PATHMODELS, model)))
                            .AddComponent(new Transform3D())
                            .AddComponent(new ModelRenderer());

            if (!isAdditive)
            {
                entity.AddComponent(new MaterialsMap(new BasicMaterial(string.Format(PATHMATERIAL, texture), typeof(CustomLayer))));
            }
            else
            {
                entity.AddComponent(new MaterialsMap(new BasicMaterial(string.Format(PATHMATERIAL, texture), DefaultLayers.Additive)
                {
                    DiffuseColor = new Color(0.6f, 0.6f, 0.6f)
                }));
            }

            if (parent == null)
            {
                EntityManager.Add(entity);
            }
            else
            {
                parent.AddChild(entity);
            }

            return(entity);
        }
Example #30
0
        }                                                                      // reduce the size of billboard gizmos.

        protected override Entity Create()
        {
            var gizmoTexture = GraphicsDevice.GetOrCreateSharedData(gizmoName, d => TextureExtensions.FromFileData(d, billboardData));

            // Create a root that will contains the billboard as a child, so that it is easier to add other elements with only the billboard set as a GizmoScalingEntity
            var root = new Entity(gizmoName);

            var billboard = new Entity(gizmoName + " Billboard")
            {
                new SpriteComponent
                {
                    SpriteType     = SpriteType.Billboard,
                    SpriteProvider = new SpriteFromTexture
                    {
                        IsTransparent = true,
                        Texture       = gizmoTexture,
                        PixelsPerUnit = gizmoTexture.Width,
                    },
                    PremultipliedAlpha = false,
                    Color         = new Color(255, 255, 255, 192),
                    IsAlphaCutoff = false,
                    RenderGroup   = RenderGroup,
                }
            };

            root.AddChild(billboard);

            // Scaling should only affect billboard
            GizmoScalingEntity = billboard;

            return(root);
        }
Example #31
0
        protected override async Task LoadContent()
        {
            await base.LoadContent();

            var debugSheet = Asset.Load<SpriteSheet>("DebugSpriteSheet");

            // normal reference one
            var normal = CreateSpriteEntity(debugSheet, "Normal");
            normal.Transform.Position = new Vector3(75, 75, 0);
            normal.Transform.RotationEulerXYZ = new Vector3(0.8f, 1.2f, 0.3f);
            normal.Get<SpriteComponent>().CurrentSprite.Center = new Vector2(75);

            // billboard
            var billboard = CreateSpriteEntity(debugSheet, "Billboard");
            billboard.Transform.Position = new Vector3(150, 150, 0);
            billboard.Transform.RotationEulerXYZ = new Vector3(0.5f, 1f, 1.5f);
            billboard.Get<SpriteComponent>().SpriteType = SpriteType.Billboard;

            // ratio
            var child = CreateSpriteEntity(debugSheet, "Child", false);
            child.Transform.Position = new Vector3(100, 0, 0);
            ratio = CreateSpriteEntity(debugSheet, "OtherRatio");
            ratio.Transform.Position = new Vector3(350, 150, 0);
            ratio.AddChild(child);

            // depth test
            var onBack = CreateSpriteEntity(debugSheet, "OnBack");
            onBack.Transform.Position = new Vector3(75, 250, 0);
            onBack.Transform.RotationEulerXYZ = new Vector3(0, 1f, 0);
            onBack.Get<SpriteComponent>().CurrentSprite.Center = new Vector2(75);
            var onFront = CreateSpriteEntity(debugSheet, "OnFront");
            onFront.Transform.Position = new Vector3(75, 350, 0.1f);
            onFront.Transform.RotationEulerXYZ = new Vector3(0, 1f, 0);
            onFront.Get<SpriteComponent>().CurrentSprite.Center = new Vector2(75);
            var noDepth = CreateSpriteEntity(debugSheet, "NoDepth");
            noDepth.Transform.Position = new Vector3(75, 450, 0.2f);
            noDepth.Get<SpriteComponent>().CurrentSprite.Center = new Vector2(75);
            noDepth.Get<SpriteComponent>().IgnoreDepth = true;

            // create the rotating sprites
            rotatingSprites.Add(CreateSpriteEntity(debugSheet, "Center"));
            rotatingSprites.Add(CreateSpriteEntity(debugSheet, "TopLeft"));
            rotatingSprites.Add(CreateSpriteEntity(debugSheet, "OutOfImage"));

            for (int i = 0; i < rotatingSprites.Count; i++)
                rotatingSprites[i].Transform.Position = new Vector3(ScreenWidth, ScreenHeight, 0) / 2;

            // add all the entities to the scene
            foreach (var entity in entities)
                SceneSystem.SceneInstance.Scene.Entities.Add(entity);

            cameraScript = new TestCamera();
            CameraComponent = cameraScript.Camera;
            Script.Add(cameraScript);

            cameraScript.Yaw = 0;
            cameraScript.Pitch = 0;
            cameraScript.Position = new Vector3(400, 300, 800);
        }
Example #32
0
 public override Entity CreateEntity(EntityWorld world, Entity ship, Entity parent, int? index = default(int?))
 {
     var entity = world.CreateEntity();
     parent.AddChild(entity);
     var xform = entity.AddComponentFromPool<Transform>();
     xform.CopyValuesFrom(Transform);
     var component = new DummyPartComponent(this, ship);
     entity.AddComponent(component);
     entity.AddComponent<IShipPartComponent>(component);
     entity.AddComponent(new BoundingBoxComponent(new FloatRect(-10, -10, 20, 20)));
     return entity;
 }
Example #33
0
        public virtual Entity Install(EntityWorld world, Entity shipEntity, Entity hardpointEntity)
        {
            var slot = hardpointEntity.GetComponent<HardpointComponent>();
            if (!hardpointEntity.IsChildOf(shipEntity)) throw new InvalidOperationException("Cannot install, ship entity does not own hardpoint entity.");
            if (slot == null) throw new InvalidOperationException("Cannot install on non-hardpoint entity.");
            var shipComponent = shipEntity.GetComponent<ShipComponent>();
            var moduleEntity = world.CreateEntity();

            var hardpointTransform = hardpointEntity.GetComponent<Transform>();
            var moduleTransform = moduleEntity.AddComponentFromPool<Transform>();
            moduleTransform.Position = Vector2.Zero;
            moduleTransform.Rotation = 0;
            moduleTransform.Scale = Vector2.One;
            moduleTransform.Origin = -hardpointTransform.Origin;            

            var scale = hardpointTransform.Scale;
            var origin = -hardpointTransform.Origin;
            if (scale.X < 0)
            {
                scale.X = Math.Abs(scale.X);
                origin.X *= -1;
            }
            if (scale.Y < 0)
            {
                scale.Y *= Math.Abs(scale.Y);
                origin.Y *= -1;
            }
            moduleTransform.Scale = scale;
            moduleTransform.Origin = origin;

            hardpointEntity.AddChild(moduleEntity);
            var previousInstalled = slot.InstalledEntity;
            if (previousInstalled != null)
            {
                previousInstalled.GetComponent<ModuleComponent>().Module.Uninstall(shipEntity, previousInstalled);
            }

            if (!string.IsNullOrWhiteSpace(PartGroupId))
            {
                ShipEntityFactory.GetShipModel(PartGroupId).CreateChildEntities(world, moduleEntity);
            }

            var moduleComponent = new ModuleComponent
            {
                HardpointEntity = hardpointEntity,
                Module = this
            };
            slot.InstalledEntity = moduleEntity;
            moduleEntity.AddComponent(moduleComponent);
            return moduleEntity;
        }
            public void Setup()
            {
                entity = new EntityImpl("Child");
                parent = new EntityImpl("Parent");
                parent.AddChild(entity);

                property = new PropertyImpl { Name = "Prop1"};
                parent.AddProperty(property);
            }
Example #35
0
        /// <summary>
        /// Create the cockpit entity, that contains:
        /// - The stereoscopic 3D camera,
        /// - The player controlled fighter,
        /// - The HUD
        /// </summary>
        private void CreateCockpit()
        {
            // Materials
            Dictionary<string, Material> materials = new Dictionary<string, Material>()
            {
                {
                    "Seat",
                    new BasicMaterial("Content/Textures/Cockpit.png", typeof(CockpitLayer))
                },
                {
                    "Trail",
                    new BasicMaterial("Content/Textures/Trail.wpk", DefaultLayers.Additive)
                    {
                        SamplerMode = AddressMode.LinearClamp
                    }
                }
            };

            // Player fighter entity
            var playerFighter = new Entity("Player")
            .AddComponent(new Transform3D())
            .AddComponent(new Sound3DEmitter())
            .AddComponent(new FollowPathBehavior("Content/Paths/Fighter_1.txt"))
            .AddComponent(new TrailManager())
            .AddComponent(new TrailsRenderer())
            .AddComponent(new MaterialsMap(materials))
            .AddComponent(new AnimatedParamBehavior("Content/Paths/Fighter1_Lasers.txt"))
            .AddComponent(new FighterController(FighterState.Player, new List<Vector3>() { new Vector3(-3, -1.6f, -9f), new Vector3(3f, -1.6f, -9f) }, SoundType.Engines_1, SoundType.Shoot))
            ;

            // Cockpit model
            Entity cockpitEntity = new Entity()
            .AddComponent(new Transform3D() { LocalScale = Vector3.One * 5, LocalPosition = Vector3.UnitZ * -0.8f })
            .AddComponent(new MaterialsMap(materials))
            .AddComponent(new Model("Content/Models/Cockpit.FBX"))
            .AddComponent(new ModelRenderer())
            ;

            playerFighter.AddChild(cockpitEntity);

            // Hud Entity
            var hud = new HudDecorator("hud");
            playerFighter.AddChild(hud.Entity);

            // Stereoscopic camera
            var stereoscopicCamera = new StereoscopicCameraDecorator("stereoCamera");
            playerFighter.AddChild(stereoscopicCamera.Entity);

            // Guns
            Entity projectileEmitter = new Entity() { Tag = "Gun" }
                .AddComponent(new Transform3D() { LocalPosition = new Vector3(3.376f, -2.689f, -3.499f), Orientation = Quaternion.CreateFromAxisAngle(Vector3.UnitY, MathHelper.Pi) })
                .AddComponent(new ProjectileEmitter(800, 7f, 1, 0));
            playerFighter.AddChild(projectileEmitter);

            projectileEmitter = new Entity() { Tag = "Gun" }
                .AddComponent(new Transform3D() { LocalPosition = new Vector3(-3.376f, -2.689f, -3.499f), Orientation = Quaternion.CreateFromAxisAngle(Vector3.UnitY, MathHelper.Pi) })
                .AddComponent(new ProjectileEmitter(800, 7f, 1, 0.5f));
            playerFighter.AddChild(projectileEmitter);

            #if WINDOWS
            // In Windows platform, you must set the Oculus Rift  rendertarget and view proyections for each eye.
            var OVRService = WaveServices.GetService<WaveEngine.OculusRift.OVRService>();
            if (OVRService != null)
            {
                stereoscopicCamera.SetRenderTarget(OVRService.RenderTarget, OVRService.GetProjectionMatrix(WaveEngine.OculusRift.EyeType.Left), OVRService.GetProjectionMatrix(WaveEngine.OculusRift.EyeType.Right));
            }
            #endif

            this.EntityManager.Add(playerFighter);
        }
 /// <summary>
 /// Creates a standard entity object. Add it to the scene to get it to render and stuff
 /// </summary>
 public static Entity Create( string name, Point3 pos, float facing, ISource graphicsSource )
 {
     Entity entity = new Entity( );
     entity.Name = name;
     entity.Position = pos;
     entity.Angle = facing;
     entity.AddChild( new EntityGraphics( graphicsSource ) );
     entity.AddChild( new Body( ) );
     return entity;
 }
        public void SetUp()
        {
            entities = new EntitySetImpl();

            entityParent = new EntityImpl("EntityParent");
            entityParent.AddProperty(new PropertyImpl("PrimaryKey") { Type = "int", IsKeyProperty = true });

            entityChild = new EntityImpl("EntityChild");
            entityParent.AddChild(entityChild);
            entityChild.CopyPropertyFromParent(entityParent.ConcreteProperties[0]);
            entityChild.AddProperty(new PropertyImpl("ActualProperty"){ Type = "string" });

            entities.AddEntity(entityParent);
            entities.AddEntity(entityChild);

            var proc = new MappingProcessor(new OneToOneEntityProcessor());
            mappingSet = proc.CreateOneToOneMapping(entities);
        }
Example #38
0
 public override Entity CreateEntity(EntityWorld world, Entity ship, Entity parent, int? index=null)
 {
     var entity = world.CreateEntity();
     parent.AddChild(entity, index);
     var thruster = new ThrusterComponent(this, ship);
     entity.AddComponent<IShipPartComponent>(thruster);
     entity.AddComponent(thruster);
     entity.AddSceneGraphRendererComponent<StandardShipModelRenderer>();
     entity.AddComponentFromPool<Transform>(t=>t.CopyValuesFrom(Transform));
     var spriteManager = ServiceLocator.Instance.GetService<ISpriteManagerService>();
     var spriteComponent = spriteManager.CreateSpriteComponent(SpriteId);
     entity.AddComponent(spriteComponent);
     entity.AddComponent(new BoundingBoxComponent(new FloatRect(0, 0, spriteComponent.TextureRect.Width, spriteComponent.TextureRect.Height)));
     ship.GetComponent<ShipComponent>()?.Thrusters.Add(entity);
     return entity;
 }
Example #39
0
        /// <summary>
        /// Create the enemy fighter entity
        /// </summary>
        private void CreateEnemyFighter()
        {
            Dictionary<string, Material> materials = new Dictionary<string, Material>()
            {
                {
                    "EnemyFighter",
                    new NormalMappingMaterial(
                    "Content/Textures/enemyfighter_diffuse.png",
                    "Content/Textures/enemyfighter_normal_spec.png")
                    {
                        AmbientColor = GameResources.AmbientColor
                    }
                },
                {
                    "EnemyGlow",
                    new BasicMaterial("Content/Textures/enemyfighter_diffuse.png")
                    {
                        DiffuseColor = GameResources.AmbientColor
                    }
                },
                {
                    "Trail",
                    new BasicMaterial("Content/Textures/EnemyTrail.wpk", DefaultLayers.Additive)
                    {
                        SamplerMode = AddressMode.LinearClamp
                    }
                },
                {
                    "EnemyThrust",
                    new BasicMaterial("Content/Textures/EnemyThrust.wpk", DefaultLayers.Additive)
                    {
                        SamplerMode = AddressMode.LinearClamp
                    }
                }
            };

            Entity fighter = new Entity()
                .AddComponent(new Transform3D())
                .AddComponent(new Sound3DEmitter())
                .AddComponent(new FollowPathBehavior("Content/Paths/EnemyFighter.txt", Quaternion.CreateFromAxisAngle(Vector3.UnitY, MathHelper.Pi)))
                .AddComponent(new AnimatedParamBehavior("Content/Paths/Enemy_Lasers.txt"))
                .AddComponent(new Model("Content/Models/EnemyFighter.FBX"))
                .AddComponent(new MaterialsMap(materials))
                .AddComponent(new ModelRenderer())
                .AddComponent(new TrailManager())
                .AddComponent(new TrailsRenderer())
                .AddComponent(new FighterController(FighterState.Enemy, new List<Vector3>()
                {
                    new Vector3(-4.5f, -3.7f, 9),
                    new Vector3(4.5f , -3.7f, 9),
                    new Vector3(-4.5f, 3.7f, 9),
                    new Vector3(4.5f , 3.7f, 9),
                }, SoundType.Engines_2, SoundType.Shoot))
                ;

            EntityManager.Add(fighter);

            // Gun entities
            Entity projectileEmitter = new Entity() { Tag = "Gun" }
                .AddComponent(new Transform3D() { LocalPosition = new Vector3(9.197f, 1.99f, -13.959f) })
                .AddComponent(new ProjectileEmitter(800, 5f, 1, 0));
            fighter.AddChild(projectileEmitter);

            projectileEmitter = new Entity() { Tag = "Gun" }
                .AddComponent(new Transform3D() { LocalPosition = new Vector3(-9.197f, 1.99f, -13.959f) })
                .AddComponent(new ProjectileEmitter(800, 5f, 1, 0.75f));
            fighter.AddChild(projectileEmitter);

            projectileEmitter = new Entity() { Tag = "Gun" }
                .AddComponent(new Transform3D() { LocalPosition = new Vector3(9.197f, -1.99f, -13.959f) })
                .AddComponent(new ProjectileEmitter(800, 5f, 1, 0.5f));
            fighter.AddChild(projectileEmitter);

            projectileEmitter = new Entity() { Tag = "Gun" }
                .AddComponent(new Transform3D() { LocalPosition = new Vector3(-9.197f, -1.99f, -13.959f) })
                .AddComponent(new ProjectileEmitter(800, 5f, 1, 0.25f));
            fighter.AddChild(projectileEmitter);
        }
Example #40
0
        /// <summary>
        /// Create wingman fighter
        /// </summary>
        private void CreateWingman()
        {
            Dictionary<string, Material> materials = new Dictionary<string, Material>()
            {
                {
                    "Fighter",
                    new NormalMappingMaterial(
                    "Content/Textures/fighter_diffuse.png",
                    "Content/Textures/fighter_normal_spec.png")
                    {
                        AmbientColor = GameResources.AmbientColor
                    }
                },
                {
                    "Glow",
                    new BasicMaterial("Content/Textures/fighter_diffuse.png")
                    {
                        DiffuseColor = GameResources.AmbientColor
                    }
                },
                {
                    "Trail",
                    new BasicMaterial("Content/Textures/Trail.wpk", DefaultLayers.Additive)
                    {
                        SamplerMode = AddressMode.LinearClamp
                    }
                },
                {
                    "Thrust",
                    new BasicMaterial("Content/Textures/Thrust.wpk", DefaultLayers.Additive)
                    {
                        SamplerMode = AddressMode.LinearClamp
                    }
                }
            };

            Entity fighter = new Entity("Wingman")
                .AddComponent(new Transform3D())
                .AddComponent(new Sound3DEmitter())
                .AddComponent(new FollowPathBehavior("Content/Paths/Fighter_2.txt", Quaternion.CreateFromAxisAngle(Vector3.UnitY, MathHelper.Pi)))
                .AddComponent(new AnimatedParamBehavior("Content/Paths/Fighter2_Lasers.txt"))
                .AddComponent(new Model("Content/Models/Fighter.FBX"))
                .AddComponent(new MaterialsMap(materials))
                .AddComponent(new ModelRenderer())
                .AddComponent(new TrailManager())
                .AddComponent(new TrailsRenderer())
                .AddComponent(new FighterController(FighterState.Wingman, new List<Vector3>() { new Vector3(-3, 0, 6.8f), new Vector3(3f, 0, 6.8f) }, SoundType.Engines_2, SoundType.Shoot))
            ;

            EntityManager.Add(fighter);

            // Wingman guns
            Entity projectileEmitter = new Entity() { Tag = "Gun" }
                .AddComponent(new Transform3D() { LocalPosition = new Vector3(3.376f, -0.689f, -3.499f) })
                .AddComponent(new ProjectileEmitter(800, 7f, 1, 0));
            fighter.AddChild(projectileEmitter);

            projectileEmitter = new Entity() { Tag = "Gun" }
                .AddComponent(new Transform3D() { LocalPosition = new Vector3(-3.376f, -0.689f, -3.499f) })
                .AddComponent(new ProjectileEmitter(800, 7f, 1, 0.5f));
            fighter.AddChild(projectileEmitter);
        }