Esempio n. 1
0
        //NB: if button pushed again, we'll just add 10 more Shapes.
        private void btnGo_Click(object sender, EventArgs e)
        {
            //If timer is running, it could goof with my list.
            tmrAddShapes.Enabled = false;

            //Make sure I got a canvas
            if (canvas is null || canvas.DrawerWindowSize.IsEmpty)
            {
                canvas = new CDrawer(canvWidth, canvHeight);
            }

            //Set my Shapes to bounce on that size canvas
            Shape.SetCanvasProperties(canvas);

            //Create my list of 10 Shapes, obeying the rules for
            //resolving conflicts
            newShapes = new List <Shape>(10);
            while (newShapes.Count < 10)
            {
                Shape shape = random.Next(2) == 0 ? new Circle() : new Ellipse();
                if (!newShapes.Contains(shape))
                {
                    newShapes.Add(shape);
                }
            }
            //Sort them
            newShapes.Sort();

            //Start adding them to the animation by letting my timer go.
            tmrAddShapes.Enabled = true;
        }
Esempio n. 2
0
        public void Render(CDrawer canvas, Color bColor)
        {
            const int ballSize = 10;

            canvas.AddCenteredEllipse(_pos.X, _pos.Y, ballSize, ballSize, bColor);
            canvas.Render();
        }
Esempio n. 3
0
 virtual public void Render(CDrawer canvas)
 {
     if (obj != null)
     {
         canvas.AddLine((int)point.X, (int)point.Y, (int)obj.point.X, (int)obj.point.Y, Color.White);
     }
 }
Esempio n. 4
0
        public static void DrawWorldMap(Location CurrentLocation)
        {
            CDrawer Canvas = new CDrawer(1000, 1000);

            Canvas.Clear();
            Canvas.Scale = 50;
            int[] cordarray = new int[2] {
                0, 0
            };
            for (int row = 0; row < MapArray.GetLength(0); row++)
            {
                for (int columb = 0; columb < MapArray.GetLength(1); columb++)
                {
                    foreach (Location locals in Locations)
                    {
                        if (locals.Coordinates.SequenceEqual(cordarray))
                        {
                            Canvas.SetBBScaledPixel(row, columb, Color.Red);
                            Canvas.AddText(locals.Name, 10, row, columb, 1, 1, Color.White);
                        }
                        if (CurrentLocation.Coordinates.SequenceEqual(cordarray))
                        {
                            Canvas.SetBBScaledPixel(row, columb, Color.Green);
                        }
                    }

                    cordarray[1]++;
                }
                cordarray[1] = 0;
                cordarray[0]++;
            }
        }
Esempio n. 5
0
 public virtual void Render(CDrawer dr)
 {
     if (_parentShape != null)
     {
         dr.AddLine((int)_pos.X, (int)_pos.Y, (int)_parentShape._pos.X, (int)_parentShape._pos.Y, Color.White);
     }
 }
Esempio n. 6
0
        /// <summary>
        /// display blocks on certian key stroke
        /// set boundaris for gdi window
        /// </summary>
        /// <param name="drawer"></param>
        public virtual void ShowBlock(CDrawer drawer)
        {
            // Create a Size structure.
            SizeF inflateSize = new SizeF(3, 3);

            //Use one of the RectangleF helper methods to determine if the block center point has exceeded the CDrawer boundaries
            //make rect obj based on cdrwar dimensions//thecn check if out
            //btm of gdi
            if (localSize.IntersectsWith(new RectangleF(0, drawer.ScaledHeight + (localSize.Height / 2), drawer.ScaledWidth, 10)))
            {
                outside = true;
                return;
            }
            //left border
            if (localSize.IntersectsWith(new RectangleF(0 - (localSize.Width / 2) - 10, 0, 10, drawer.ScaledHeight)))
            {
                outside = true;
                return;
            }
            //right border
            if (localSize.IntersectsWith(new RectangleF(drawer.ScaledWidth + (localSize.Width / 2), 0, 10, drawer.ScaledHeight)))
            {
                outside = true;
                return;
            }
            else
            {
                //draw black rect(copy)
                //then draw real rect on top of it
                RectangleF temp = localSize;
                temp.Inflate(inflateSize);
                drawer.AddRectangle((int)temp.X, (int)temp.Y, (int)temp.Width, (int)temp.Height, Color.Black);//background square
            }
        }
Esempio n. 7
0
 public Form1()
 {
     InitializeComponent();
     canvas = new CDrawer();
     canvas.MouseLeftClick  += Canvas_MouseLeftClick;
     canvas.MouseRightClick += Canvas_MouseRightClick;
 }
Esempio n. 8
0
        /// <summary>
        /// returns a rect and has CDrawer arg
        /// sets up rectangles to be drwan at random points
        /// </summary>
        /// <param name="drawer"></param>
        /// <returns></returns>
        public Rectangle NextDrawerRect(CDrawer drawer)
        {
            //If the CDrawer is not valid, throw an ArgumentException
            if (drawer == null)
            {
                throw new ArgumentException("drawer noit valid");
            }

            //if the Maximum size exceeds the CDrawer bounds use cdrawer coundaries
            if (maxSize < 10)
            {
                maxSize = 10;
            }
            if (maxSize > drawer.ScaledHeight)
            {
                maxSize = drawer.ScaledHeight;
            }
            if (maxSize > drawer.ScaledWidth)
            {
                maxSize = drawer.ScaledWidth;
            }

            //rect sized between 10 and the Maximum size( new member field ) of the CDrawer and with[X, Y] coordinates
            //rect randomized somewhere so the Rectangle is always fully visible
            Size  size  = new Size(Next(10, maxSize), Next(10, maxSize));
            Point point = new Point();

            point.Y = Next(drawer.ScaledHeight - size.Height);
            point.X = Next(drawer.ScaledWidth - size.Width);

            //create a new Rectangle object
            Rectangle rect = new Rectangle(point, size);

            return(rect);
        }
Esempio n. 9
0
 public Fungus(Point s, CDrawer c, EColor e)
 {
   this.canvas = c;
   this.start = s;
   this.e = e;
   this.color_strength = 64;
 }
Esempio n. 10
0
        public Form1()
        {
            InitializeComponent();

            _draw = new CDrawer(WIDTH, HEIGHT); // make gdi window
            timer1.Start();                     // allow cliking in gdi window
        }
Esempio n. 11
0
        /// <summary>
        /// alternate method of set position method that uses a cdrawer instead of form app
        /// </summary>
        /// <param name="position"></param>
        /// <param name="drawer"></param>
        void SetPosition(EPosition position, CDrawer drawer)
        {
            Point local = drawer.Position;//pos of form

            switch (position)
            {
            case EPosition.eRight:
                local.X += drawer.ScaledWidth;
                break;

            case EPosition.eBelow:
                local.Y += drawer.ScaledHeight;
                break;

            case EPosition.eBelowRight:
                local.X += drawer.ScaledWidth;
                local.Y += drawer.ScaledHeight;
                break;

            case EPosition.eNone:
                local.X += drawer.ScaledWidth;
                break;

            default:
                break;
            }
            Position = local;
        }
 public void MoveBall(CDrawer canvas)
 {
     if ((pLocation.X + velX + Ballrad) >= canvas.ScaledWidth || (pLocation.X + velX - Ballrad) <= 0)
     {
         if ((pLocation.X + velX + Ballrad) >= canvas.ScaledWidth)
         {
             pLocation.X = canvas.ScaledWidth - Ballrad;
         }
         else if ((pLocation.X += velX - Ballrad) <= 0)
         {
             pLocation.X = 0 + Ballrad;
         }
         velX = -velX;
     }
     if ((pLocation.Y + velY + Ballrad) >= canvas.ScaledHeight || (pLocation.Y + velY - Ballrad) <= 0)
     {
         if ((pLocation.Y + velY + Ballrad) >= canvas.ScaledHeight)
         {
             pLocation.Y = canvas.ScaledHeight - Ballrad;
         }
         else if ((pLocation.Y += velY - Ballrad) <= 0)
         {
             pLocation.Y = 0 + Ballrad;
         }
         velY = -velY;
     }
     pLocation.Y += velY;
     pLocation.X += velX;
 }
        //******************************************************
        //Render Method: Draw the shape as a Polygon
        //******************************************************
        public override void Render(CDrawer drawer)
        {
            //Draw line to parent
            base.Render(drawer);

            drawer.AddPolygon((int)_position.X, (int)_position.Y, _size, _sides, _sequence, _color);
        }
Esempio n. 14
0
        static void RandomBlocks()
        {
            Random  rnd = new Random();
            CDrawer can = new CDrawer();

            System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
            watch.Reset();
            watch.Start();
            can.AddText("Random Known Colors SetBBPixel : 2s", 28, 0, 0, can.ScaledWidth, can.ScaledHeight, Color.White);
            can.AddText("Random Known Colors SetBBPixel : 2s", 28, 2, 2, can.ScaledWidth + 2, can.ScaledHeight + 2, Color.Black);
            while (watch.ElapsedMilliseconds < 2000)
            {
                can.SetBBPixel(rnd.Next(can.ScaledWidth), rnd.Next(can.ScaledHeight), RandColor.GetKnownColor());
            }
            can.Close();

            can       = new CDrawer(800, 800);
            can.Scale = 10;
            Console.WriteLine("Random Known Colors SetBBScaledPixel : 2s");
            watch.Reset();
            watch.Start();
            can.AddText("Random Known Colors SetBBScaledPixel : 2s", 24);
            while (watch.ElapsedMilliseconds < 2000)
            {
                can.SetBBScaledPixel(rnd.Next(can.ScaledWidth), rnd.Next(can.ScaledHeight), RandColor.GetKnownColor());
            }
            can.Close();
        }
Esempio n. 15
0
        //NB: if button pushed again, we'll just add 10 more balls.
        private void btnGo_Click(object sender, EventArgs e)
        {
            //If timer is running, it could goof with my list.
            tmrAddBalls.Enabled = false;

            //Make sure I got a canvas
            if (canvas is null || canvas.DrawerWindowSize.IsEmpty)
            {
                canvas = new CDrawer(canvWidth, canvHeight);
            }

            //Set my balls to bounce on that size canvas
            Ball.SetCanvasProperties(canvas);

            //Create my list of 10 balls, obeying the rules for
            //resolving conflicts
            newBalls = new List <Ball>(10);
            while (newBalls.Count < 10)
            {
                Ball ball = new Ball(true);
                if (!newBalls.Contains(ball))
                {
                    newBalls.Add(ball);
                }
            }
            //Sort them
            newBalls.Sort();

            //Start adding them to the animation by letting my timer go.
            tmrAddBalls.Enabled = true;
        }
Esempio n. 16
0
        private void UI_BTN_Play_Click(object sender, EventArgs e)
        {
            if (_canvas == null)
            {
                _canvas = new CDrawer(800, 600 + OFFSET);
            }

            _canvas.Clear();
            _score = 0;

            if (UI_RB_Easy.Checked)
            {
                Randomize(Difficulty.Easy);
            }
            else if (UI_RB_Medium.Checked)
            {
                Randomize(Difficulty.Medium);
            }
            else
            {
                Randomize(Difficulty.Hard);
            }

            Display();
            UI_Timer.Enabled    = true;
            UI_BTN_Play.Enabled = false;
        }
Esempio n. 17
0
 public static void SetCanvasProperties(CDrawer canvas)
 {
     //Reset static canvas size based on the sample I just got
     CanvasWidth  = canvas.ScaledWidth;
     CanvasHeight = canvas.ScaledHeight;
     MaxSize      = CanvasWidth / 5;
 }
Esempio n. 18
0
 static Block()
 {
     Height                  = 20;
     Canvas                  = new CDrawer();
     Canvas.BBColour         = Color.White;
     Canvas.ContinuousUpdate = false;
 }
Esempio n. 19
0
        const int unitValue4 = 10;  // 30pixels for unit x and y value

        static void Main(string[] args)
        {
            //make a canvas for graph
            CDrawer canvas = new CDrawer();
            //  y = Amplitude.sin(AngularFrequency.x + PhaseAngle) + VerticalOffset
            // a = Amplitude || f = AngularFrequency || p = Phase angle || v = VerticalOffset
            bool           success  = false;
            bool           success2 = false;
            double         a        = 0.00;
            double         f        = 0.00;
            double         p        = 0.00;
            double         v        = 0.00;
            ConsoleKeyInfo userChoice;

            Grid(canvas);
            do
            {
                do
                {
                    userChoice = GetUserChoice("Action:  ");
                    Console.WriteLine(userChoice);
                } while (!success);
                Console.Clear();
            } while (!success2);

            Console.ReadKey();
        }
Esempio n. 20
0
        // Thread to traverse 2D grid in random fashion
        private void TraverseGridRandomly()
        {
            int     steps  = 0;
            CDrawer canvas = new CDrawer(WIDTH, HEIGHT);

            int[,] grid = new int[X_MAX, Y_MAX];    // 2D backing array for the grid
            Point current  = new Point(0, 0);
            Point previous = new Point(0, 0);

            List <Point> nextPossiblePoint = new List <Point>();      // List of valid moves

            canvas.Scale = BLOCKSIZE;

            // Initialize each grid location with nominal value;
            for (int x = 0; x < X_MAX; ++x)
            {
                for (int y = 0; y < Y_MAX; ++y)
                {
                    grid[x, y] = BASE_RGB_VALUE;
                }
            }

            while (!HasTravelledAll(grid))
            {
                ++steps;

                // Increment intensity of current color to max of 255
                grid[current.X, current.Y] =
                    grid[current.X, current.Y] + 3 > 255 ? 255 : grid[current.X, current.Y] + 3;

                // Draw previous point in yellow - ignore initial start
                if (steps != 1)
                {
                    canvas.SetBBScaledPixel(previous.X, previous.Y,
                                            Color.FromArgb(grid[previous.X, previous.Y], grid[previous.X, previous.Y], 0));
                }

                // Draw current point location in red
                canvas.SetBBScaledPixel(current.X, current.Y, Color.Red);

                previous = current;

                // Clear previous list of valid movement and update list and move to new Point
                nextPossiblePoint.Clear();
                nextPossiblePoint = validLocation(current);
                current           = nextPossiblePoint[_rnd.Next(0, nextPossiblePoint.Count)];
            }

            // Display number of steps on screen
            canvas.AddText(steps.ToString() + " Steps Taken", 25, Color.Blue);

            try
            {
                Invoke(new delVoidInt(UpdateUI), steps);
            }
            catch
            {
                System.Diagnostics.Trace.WriteLine("Target thread is dead");
            }
        }
Esempio n. 21
0
        /// <summary>
        /// get balls to move and bounce around in gdi windows
        /// </summary>
        /// <param name="cDrawer"></param>
        public void Move(CDrawer cDrawer)
        {
            ballCenter.X += xVel;
            ballCenter.Y += yVel;

            //bounce off left wall
            if (ballCenter.X - radius < 0)
            {
                xVel         = -xVel;
                ballCenter.X = radius;
            }

            //bounce off right wall
            if (ballCenter.X + radius > cDrawer.ScaledWidth)
            {
                xVel         = -xVel;
                ballCenter.X = cDrawer.ScaledWidth - radius;
            }

            //bounce off top wall
            if (ballCenter.Y - radius < 0)
            {
                yVel         = -yVel;
                ballCenter.Y = radius;
            }

            //bounce off bottom wall
            if (ballCenter.Y + radius > cDrawer.ScaledHeight)
            {
                yVel         = -yVel;
                ballCenter.Y = cDrawer.ScaledHeight - radius;
            }
        }
Esempio n. 22
0
        //******************************************************
        //Render Method: Draw shape as a ball.
        //******************************************************
        public override void Render(CDrawer drawer)
        {
            //Draw line to parent
            base.Render(drawer);

            drawer?.AddCenteredEllipse((int)_position.X, (int)_position.Y, _size, _size, _color);
        }
Esempio n. 23
0
 static Bar()
 {
     Height                  = 20;
     drawer                  = new CDrawer();
     drawer.BBColour         = Color.White;
     drawer.ContinuousUpdate = false;
 }
Esempio n. 24
0
        //Take in a canvas and scale, draw all of the blocks
        public void Render(CDrawer canvas, int Size)
        {
            canvas.Clear();

            for (int x = 0; x < XLength; x++)
            {
                for (int y = 0; y < YLength; y++)
                {
                    //Ignore nulls and retainer blocks, don't need to render them
                    if (grid[x, y] != null && !(grid[x, y] is RetainerBlock))
                    {
                        //Centered point
                        Point point = new Point(x * Size + (Size / 2), y * Size + (Size / 2));
                        //If free block, offset the point by Animation state
                        if (grid[x, y] is FreeBlock && grid[x, y].life != Life.Dying)
                        {
                            point.Y += (Size / 10) * grid[x, y].AnimationState; //Move down 1/10 of the size, per AnimationState
                        }

                        //Get our side length, shrunk by death
                        int sideLength = Size;
                        if (grid[x, y].life == Life.Dying)
                        {
                            // (-10%) * State + Size
                            sideLength = (-(Size / 10)) * grid[x, y].AnimationState + Size; //Shrink by 10% of size for every AnimationState
                        }

                        //Add every block using the point and size we just made
                        canvas.AddCenteredRectangle(point.X, point.Y, sideLength, sideLength, grid[x, y].Colour, 1, Color.Black);
                    }
                }
            }

            canvas.Render();
        }
Esempio n. 25
0
        public DrawerWnd(CDrawer dr)
        {
            InitializeComponent();

            // use the log as built from parent
            _log = dr._log;

            // save window size
            m_ciWidth  = dr.m_ciWidth;
            m_ciHeight = dr.m_ciHeight;

            // cap delegates, this will be set by owner
            m_delRender          = null;
            m_delMouseMove       = null;
            m_delMouseLeftClick  = null;
            m_delMouseRightClick = null;

            // cap/set references
            m_bgc = new BufferedGraphicsContext();
            m_bg  = null;

            // create the bitmap for the underlay and clear it to whatever colour
            m_bmUnderlay = new Bitmap(dr.m_ciWidth, dr.m_ciHeight);    // docs say will use Format32bppArgb

            // fill the bitmap with the default drawer bb colour
            FillBB(Color.Black);

            // show that drawer is up and running
            _log.WriteLine("Drawer Started...");
        }
Esempio n. 26
0
        //******************************************************
        //Render Method: Draw beizer around the parent shape.
        //******************************************************
        public override void Render(CDrawer drawer)
        {
            //Draw line to parent
            base.Render(drawer);

            drawer?.AddBezier(_startPoint.X, _startPoint.Y, _ControlPoint1.X, _ControlPoint1.Y, _ControlPoint2.X, _ControlPoint2.Y, _endPoint.X, _endPoint.Y, Color.White, 1);
        }
Esempio n. 27
0
        public void Move(CDrawer cDrawer)
        {
            ballCenter.X += xVel;
            ballCenter.Y += yVel;

            if (ballCenter.X - radius < 0)
            {
                xVel         = -xVel;
                ballCenter.X = 0 + radius;
            }
            if (ballCenter.X + radius > cDrawer.ScaledWidth)
            {
                xVel         = -xVel;
                ballCenter.X = cDrawer.ScaledWidth - radius;
            }
            if (ballCenter.Y - radius < 0)
            {
                yVel         = -yVel;
                ballCenter.Y = 0 + radius;
            }
            if (ballCenter.Y + radius > cDrawer.ScaledHeight)
            {
                yVel         = -yVel;
                ballCenter.Y = cDrawer.ScaledHeight - radius;
            }
        }
Esempio n. 28
0
        /// <summary>
        /// keep track of current key state(s)
        /// </summary>
        /// <param name="bIsDown"></param>
        /// <param name="keyCode"></param>
        /// <param name="dr"></param>
        private void Pic_KeyboardEvent(bool bIsDown, Keys keyCode, CDrawer dr)
        {
            if (keyCode == Keys.F)
            {
                state = keyCode;
            }

            if (keyCode == Keys.D)
            {
                state = keyCode;
            }

            if (keyCode == Keys.C)
            {
                state = keyCode;
            }

            if (keyCode == Keys.Escape)
            {
                state = keyCode;
            }

            if (keyCode == Keys.F1)
            {
                state = keyCode;
            }
        }
Esempio n. 29
0
        public Form1()
        {
            InitializeComponent();
            this.StartPosition = FormStartPosition.Manual;
            this.Location      = new Point(10, 10);

            _greenBlueGDI = new CDrawer(800, 400);//main
            Point GDIpos = new Point(this.Width, this.Height);

            GDIpos.X += _greenBlueGDI.ScaledWidth;
            GDIpos.Y += _greenBlueGDI.ScaledHeight;
            _greenBlueGDI.Position = new Point(this.Width, this.Height - 250);

            //drawer position above colided gdi window
            _greenBlueGDI.ContinuousUpdate = false;

            //secondary window(red balls/green blue ball colision)
            _collidedGDI                  = new CDrawer(800, 400);
            _collidedGDI.Position         = new Point(this.Width, _greenBlueGDI.ScaledHeight + 50);
            _collidedGDI.ContinuousUpdate = false;

            _greenBlueGDI.MouseLeftClick  += _greenBlueGDI_MouseLeftClick;
            _greenBlueGDI.MouseRightClick += _greenBlueGDI_MouseRightClick;
            _timer.Tick    += _timer_Tick;
            _timer.Interval = 20;
            _timer.Enabled  = true;
        }
Esempio n. 30
0
 private void SetGuard(CDrawer dr, int ix, int iy, Color col)
 {
     if (ix >= 0 && ix < dr.m_ciWidth && iy >= 0 && iy < dr.m_ciHeight)
     {
         dr.SetBBPixel(ix, iy, col);
     }
 }