Esempio n. 1
0
        private static void Main(string[] args)
        {
            var   start    = new Point(0, 1, 0);
            Tuple velocity = new Vector(1, 1.8, 0).Normalize();

            velocity *= 11.25;
            var gravity = new Vector(0, -0.1, 0);
            var wind    = new Vector(-0.01, 0, 0);

            var environment = new ProjectileEnvironment(gravity, wind);
            var projectile  = new Projectile.Lib.Projectile(start, velocity);
            var canvas      = new Canvas(900, 550);

            while (projectile.Position.Y > 0)
            {
                var x = (int)projectile.Position.X;
                var y = (int)(canvas.Height - projectile.Position.Y);
                canvas[x, y] = Colors.Green;
                projectile   = RenderCycle.Tick(environment, projectile);
            }

            var formatter = new PPMImageFormatter();
            var image     = (PPMImage)formatter.CreateImage(canvas);

            File.WriteAllText("projectile.ppm", image.Content);

            Process.Start("explorer", "projectile.ppm");
            System.Console.WriteLine("Done");
            System.Console.ReadLine();
        }
Esempio n. 2
0
        public Canvas Tick(int x, int y)
        {
            var environment = new ProjectileEnvironment(_gravity, _wind);
            var projectile  = new Projectile.Lib.Projectile(_start, _velocity);
            var canvas      = new Canvas(x, y);

            while (projectile.Position.Y > 0)
            {
                var X = (int)projectile.Position.X;
                var Y = (int)(canvas.Height - projectile.Position.Y);
                canvas[X, Y] = Colors.Green;
                projectile   = RenderCycle.Tick(environment, projectile);
            }
            return(canvas);
        }
Esempio n. 3
0
        private static void Main(string[] args)
        {
            var environment = new ProjectileEnvironment(new Vector(0, -0.1, 0), new Vector(-0.01, 0, 0));
            var projectile  = new Lib.Projectile(new Point(0, 1, 0), new Vector(10, 15, 0).Normalize());

            while (projectile.Position.Y > 0)
            {
                ConsoleHelpers.Log(projectile);
                projectile = RenderCycle.Tick(environment, projectile);
            }

            ConsoleHelpers.Log(projectile);
            System.Console.WriteLine("Done");
            System.Console.ReadLine();
        }
Esempio n. 4
0
            private void CalculateRenderItem(int item, int line, int pix)
            {
                Renderer[item] = new RenderCycle();

                Renderer[item].RAction = RenderAction.None;
                int pitchWidth = _ula.ScreenWidth + _ula.BorderRightWidth + _ula.BorderLeftWidth;

                int scrPix = pix - _ula.FirstPaperTState;
                int scrLin = line - _ula.FirstPaperLine;

                if ((line >= (_ula.FirstPaperLine - _ula.BorderTopHeight)) && (line < (_ula.FirstPaperLine + 192 + _ula.BorderBottomHeight)) &&
                    (pix >= (_ula.FirstPaperTState - _ula.BorderLeftTime)) && (pix < (_ula.FirstPaperTState + 128 + _ula.BorderRightTime)))
                {
                    // visibleArea (vertical)
                    if ((line >= _ula.FirstPaperLine) && (line < (_ula.FirstPaperLine + 192)) &&
                        (pix >= _ula.FirstPaperTState) && (pix < (_ula.FirstPaperTState + 128)))
                    {
                        // pixel area
                        switch (scrPix & 7)
                        {
                        case 0:
                            Renderer[item].RAction = RenderAction.Shift1AndFetchByte2;                                       // shift 1 + fetch B2
                            // +4 = prefetch!
                            Renderer[item].ByteAddress = CalculateByteAddress(scrPix + 4, scrLin);
                            break;

                        case 1:
                            Renderer[item].RAction = RenderAction.Shift1AndFetchAttribute2;                                       // shift 1 + fetch A2
                            // +3 = prefetch!
                            Renderer[item].AttributeAddress = CalculateAttributeAddress(scrPix + 3, scrLin);
                            break;

                        case 2:
                            Renderer[item].RAction = RenderAction.Shift1;                                       // shift 1
                            break;

                        case 3:
                            Renderer[item].RAction = RenderAction.Shift1Last;                                       // shift 1 (last)
                            break;

                        case 4:
                            Renderer[item].RAction = RenderAction.Shift2;                                       // shift 2
                            break;

                        case 5:
                            Renderer[item].RAction = RenderAction.Shift2;                                       // shift 2
                            break;

                        case 6:
                            if (pix < (_ula.FirstPaperTState + 128 - 2))
                            {
                                Renderer[item].RAction = RenderAction.Shift2AndFetchByte1;                                           // shift 2 + fetch B2
                            }
                            else
                            {
                                Renderer[item].RAction = RenderAction.Shift2;                                                     // shift 2
                            }

                            // +2 = prefetch!
                            Renderer[item].ByteAddress = CalculateByteAddress(scrPix + 2, scrLin);
                            break;

                        case 7:
                            if (pix < (_ula.FirstPaperTState + 128 - 2))
                            {
                                //???
                                Renderer[item].RAction = RenderAction.Shift2AndFetchAttribute1;                                           // shift 2 + fetch A2
                            }
                            else
                            {
                                Renderer[item].RAction = RenderAction.Shift2;                                                     // shift 2
                            }

                            // +1 = prefetch!
                            Renderer[item].AttributeAddress = CalculateAttributeAddress(scrPix + 1, scrLin);
                            break;
                        }
                    }
                    else if ((line >= _ula.FirstPaperLine) && (line < (_ula.FirstPaperLine + 192)) &&
                             (pix == (_ula.FirstPaperTState - 2)))                              // border & fetch B1
                    {
                        Renderer[item].RAction = RenderAction.BorderAndFetchByte1;              // border & fetch B1
                        // +2 = prefetch!
                        Renderer[item].ByteAddress = CalculateByteAddress(scrPix + 2, scrLin);
                    }
                    else if ((line >= _ula.FirstPaperLine) && (line < (_ula.FirstPaperLine + 192)) &&
                             (pix == (_ula.FirstPaperTState - 1)))                              // border & fetch A1
                    {
                        Renderer[item].RAction = RenderAction.BorderAndFetchAttribute1;         // border & fetch A1
                        // +1 = prefetch!
                        Renderer[item].AttributeAddress = CalculateAttributeAddress(scrPix + 1, scrLin);
                    }
                    else
                    {
                        Renderer[item].RAction = RenderAction.Border;                         // border
                    }

                    int wy = line - (_ula.FirstPaperLine - _ula.BorderTopHeight);
                    int wx = (pix - (_ula.FirstPaperTState - _ula.BorderLeftTime)) * 2;
                    Renderer[item].LineOffset = wy * pitchWidth + wx;
                }
            }