Angry Birds Fanon Wiki
Advertisement

Ben Bird[]

Ben Bird

Ben Bird to Bird z gry Angry Birds Death Mission. Ben Bird (po polsku Ptak Benowy) to najsilniejszy ptak z rodziny Masno Birds. Obecnie jest to jedyny znany osobnik posiadający legendarną klasę picipumpek.

Historia[]

Niewiele o nim wiadomo, ale jak podają źródła, Ben Bird opuścił nierozłączną rodzinę Masno Birds aby odnaleźć Darkness Bird. Cel tych poszukiwań jest jednak nieznany.

Umiejętności[]

  • Skok przez płot (umiejętność pasywna) - Ben Bird posiada 100% szans na wyminięcie pierwszego płotu (muru) niezależnie od jego wysokości (wyjątek stanowi Wielki Mur Masoński)
  • Odwracające lustro - Ben Bird ma możliwość wystrzelenia się w lewą stronę planszy. Obecnie nie znaleziono dla tej umiejętności praktycznego zastosowania.
  • Kupa_kłopotów.exe (umiejętność łączona, wymagany shiny Ted Bird) - Ben Bird wyciąga Wiatrówkę CyberGun Swiss Arms P1911 Blow Back 4,5 mm (288710) i zadaje (99*0,7 siły Ben Bird) DMG wszystkim obiektom i przeciwnikom w zasięgu 45m-270m (skaluje się z poziomem Ben Bird).
  • [ZREDAGOWANE]
  • [ZREDAGOWANE]
  • [ZREDAGOWANE] - Ben Bird otrzymuje [ZREDAGOWANE], użycie tej umiejętnośći jest jednym z 3 sposobów na ukończenie mapy German Abyss.

Ciekawostki[]

  • Ben Bird został dodany do gry w patchu v 3.14.9 (The Masno Update) wraz z Ted Bird, Bil Bird, Olo Bird, Den Bird. Jest to obecnie jedyny znany przypadek gdy do gry zostało dodanych 5 lub więcej ptaków w jednym patchu.
  • Jeśli posiadacie deweloperską wersję gry, to po wpisaniu tego kodu w konsoli kominiarka Ben Bird zostanie zastąpiona kominiarką w barwach Ukrainy:
    #include <iostream>
    #include <vector>
    #include <cstdlib>
    #include <cmath>
    #include <sys/time.h>
    #include <sstream> 
    #include <string.h> 
    #include <math.h>
    #include <stdlib.h>
    #include <algorithm>
    
    
    /*
     * Header files for X functions
     */
    #include <X11/Xlib.h>
    #include <X11/Xutil.h>
    
    //======================================================================
    //  Compile: g++ a1.cpp -o a1 –L/usr/X11R6/lib –lX11
    //======================================================================
    
    using namespace std;
    
    //======================================================================
    //
    //  Constants definition
    //
    //======================================================================
    
    //======================================================================
    //  Window Constants
    //======================================================================
    
    /*----- Window Border  -----*/
    const int Border = 5;
    
    /*----- Window Position -----*/
    const int windowX = 100;
    const int windowY = 100;
    
    /*----- Window Size -----*/
    int windowWidth = 800;
    int windowHeight= 500;
    
    /*----- For Key event -----*/
    const int BufferSize = 10;
    
    //======================================================================
    //  Layout Constants
    //======================================================================
    
    const double layoutHeightU = 0.6;
    const int layoutHeight = layoutHeightU * windowHeight;
    const int layoutInitialX = 0;
    const int layoutInitialY = 0.5 * (1 - layoutHeightU) * windowHeight;
    
    //======================================================================
    //  Bird Constants
    //======================================================================
    
    /*----- Bird Initial Positions -----*/
    const int birdX = 0.2 * windowWidth;
    const int birdY = 0.6 * windowHeight; 
    
    /*----- Bird other constans -----*/
    const int birdR = 20;
    const int birdD = 2*birdR; 
    
    
    /*----- Velocity Coeficient -----*/
    double uVelocity = 0.1;
    
    /*----- Gravity Accelation -----*/
    const double g = 0.1;
    
    /*----- usleep time -----*/
    int usleepTime = 20000;
    
    /*----- Second/Microsecond -----*/
    const int secondMicrosecond = 1000000;
    
    //======================================================================
    //  Brick Constants
    //======================================================================
    
    //----------------------------------------------------------------------
    // Common Used Variables
    
    // Bottom of Layout
    const double brickY = windowHeight * ( (0.5 * (1 + layoutHeightU) ));
    
    /*----- For 3D Effect -----*/
    const int brickShift = 3;
    
    /*----- Brick Length  -----*/
    const int brickLength = 30;
    
    
    /*----- Bottom Brick Initial Positions -----*/
    // Need reset
    //
    double brickX_1;
    double brickX_2; 
    double brickX_3;
    
    /*----- Number of Bricks -----*/
    // Need reset
    //
    int brickNum_1;
    int brickNum_2;
    int brickNum_3;
    
    //----------------------------------------------------------------------
    // Level One
    
    /*----- Bottom Brick Initial Positions -----*/
    const double brickX_1_UlevelOne = 0.7; 
    
    const double brickX_2_UlevelOne = 0.8; 
    
    /*----- Number of Bricks -----*/
    const int brickNum_1_levelOne = 4;
    const int brickNum_2_levelOne = 6;
    
    //----------------------------------------------------------------------
    // Level Two
    
    /*----- Bottom Brick Initial Positions -----*/
    const double brickX_1_UlevelTwo = 0.7; 
    
    // brick_2 depends on the position of brick_1, and connected
    // to it
    
    const double brickX_3_UlevelTwo = 0.9;
    
    
    /*----- Number of Bricks -----*/
    const int brickNum_1_levelTwo = 7;
    const int brickNum_2_levelTwo = 2;
    const int brickNum_3_levelTwo = 10;
    
    //======================================================================
    //  Ball Constants 
    //======================================================================
    //
    // Common Used Variables
    
    const int ballDiameter = brickLength;
    
    /*----- Ball Initial Positions -----*/
    // Need reset
    
    int ballX_1; 
    int ballY_1;
    int ballX_2;
    int ballY_2;
    
    /*----- For Level Two -----*/
    int ballX_3;
    int ballY_3;
    
    /*----- Number of Balls  -----*/
    // Need reset
    int ballNum;
    
    
    /*----- Level 1  -----*/
    const int ballNumLevelOne = 2;
    
    /*----- Level 2  -----*/
    const int ballNumLevelTwo = 3;
    double velocityBall_3 = 1;
    
    //======================================================================
    //  Score Initial Positions
    //======================================================================
    int score = 0;
    
    const int scoreX = 0.8 * windowWidth;
    const int scoreY = layoutInitialY - 10;
    
    const int pointsBall = 10;
    const int pointsShoot = 10;
    //======================================================================
    //  Other Constants
    //======================================================================
    
    int level;
    int flying = 0;
    int hit = 0;
    int dead = 0;
    int over = 0;
    int birdsLeft;
    int birdsLeft_1 = 2;
    int birdsLeft_2 = 3;
    
    const int scoreVelocity = 1; 
    int scoreRaiseCounter = 0;
    int hitBall_1 = 0;
    int hitBall_2 = 0;
    int hitBall_3 = 0;
    
    const double lineWidth = 2.5;
    const int pathDiameter = 5;
    
    const int slingshotWidth = 0.25 * birdR;
    const int slingshotLength = 2 * birdR;
    
    /*----- Stick -----*/
    const int slingshotInitX = birdX + 0.5*birdR;
    const int slingshotInitY = birdY + 2*birdR;
    
    /*----- Leftmost -----*/
    const int slingshotLeftmostInitX = slingshotInitX - 0.5*slingshotLength;
    const int slingshotLeftmostInitY = slingshotInitY - slingshotLength; 
    
    /*----- Rightmost -----*/
    const int slingshotRightmostInitX = slingshotInitX + 0.5*slingshotLength;
    const int slingshotRightmostInitY = slingshotInitY - slingshotLength; 
    
    /*----- Cheating Function  -----*/
    const int cheatingBoxInitX = 0.1 * windowWidth;  
    const int cheatingBoxInitY = layoutInitialY - 30;
    const int cheatingBoxWidth = 70;
    const int cheatingBoxLength = 20;
    
    /*----- Restart Button -----*/
    const int restartBoxInitX = 0.03 * windowWidth;  
    const int restartBoxInitY = cheatingBoxInitY; 
    const int restartBoxWidth = 50;
    const int restartBoxLength = cheatingBoxLength;
    //======================================================================
    //
    //  Global Variables
    //
    //======================================================================
    
    
    //----------------------------------------------------------------------
    //  One GC can be used to paint many birds, add bricks etc
    //  later
    GC birdGC;
    GC ordinaryGC;
    GC eyeGC;
    GC ballGC;
    GC noseGC;
    GC brickGC;
    GC backgroundGC;
    
    //======================================================================
    //
    //  Classes and structures
    //  
    //======================================================================
    
    //======================================================================
    //  Information to draw on the window.
    //======================================================================
    struct XInfo
    {  
        Display  *display;
        Window   window;
        GC       gc;
        int screen;
    };
    
    //======================================================================
    //  An abstract class representing displayable things. 
    //======================================================================
    
    class Displayable
    { 
        public:
            virtual void paint(XInfo &xinfo) = 0;
    
            int getX(){
                return x;
            }
    
            int getY(){
                return y;
            } 
    
            int getWidth(){
                return width;
            }
    
            int getLength(){
                return length;
            } 
    
            int getDiameter(){
                return diameter;
            } 
    
            void setX(int X){
                x = X;
            }
    
            void setY(int Y){
                y = Y;
            }
    
            void setWidth(int w){
                width = w;
            }
    
            void setLength(int l){
                length = l;
            }
    
            void setDiameter(int d){
                diameter = d;
            }
    
        private:
            /*----- For rectangle  -----*/
            int x;
            int y;
            int width;
            int length;
            int diameter;
    
    };       
    
    vector<Displayable *> dVector;
    vector<Displayable *> dVectorPath;
    vector<Displayable *> dVectorBird;
    
    //======================================================================
    //  Bird Class (now rectangle, modified later)
    //======================================================================
    
    class Bird : public Displayable {
        public:
            virtual void paint(XInfo &xinfo){
                int eyeDiameter = 0.3 * getWidth();
    
                // Bird
                XDrawRectangle(
                        xinfo.display, xinfo.window, 
                        ordinaryGC,
                        getX(), getY(), 
                        getWidth(), getLength()
                        ); 
    
                XDrawArc(
                        xinfo.display, xinfo.window,
                        ordinaryGC,
                        (getX() + getWidth()*0.5) - getWidth() * 0.65, 
                        (getY() + getWidth()*0.5) - getWidth() * 0.65,
                        1.3*getWidth(), 1.4*getWidth(),
                        0, 360*64
                        );
                
                // Bird Circle
                XFillArc(
                        xinfo.display, xinfo.window,
                        birdGC,
                        (getX() + getWidth()*0.5) - getWidth() * 0.65,
                        (getY() + getWidth()*0.5) - getWidth() * 0.65, 
                        1.3*getWidth(), 1.4*getWidth(),
                        0, 360*64
                        );
    
                // Eye 1
                XDrawArc(
                        xinfo.display, xinfo.window,
                        ordinaryGC,
                        (getX() + getWidth()*0.65) - (eyeDiameter/2),
                        (getY() + getWidth()*0.4) - (eyeDiameter/2),
                        eyeDiameter, eyeDiameter,
                        0, 360*64
                        );
    
                XFillArc(
                        xinfo.display, xinfo.window,
                        eyeGC,
                        (getX() + getWidth()*0.65) - (eyeDiameter/2),
                        (getY() + getWidth()*0.4) - (eyeDiameter/2),
                        eyeDiameter, eyeDiameter,
                        0, 360*64
                        );
    
                XDrawPoint(
                        xinfo.display,
                        xinfo.window,
                        ordinaryGC,
                        (getX() + getWidth()*0.65),
                        (getY() + getWidth()*0.4)
                        );
    
                // Eye 2
                XDrawArc(
                        xinfo.display, xinfo.window,
                        ordinaryGC,
                        (getX() + getWidth()*0.95) - (eyeDiameter/2),
                        (getY() + getWidth()*0.4) - (eyeDiameter/2),
                        eyeDiameter, eyeDiameter,
                        0, 360*64
                        );
    
                XFillArc(
                        xinfo.display, xinfo.window,
                        eyeGC,
                        (getX() + getWidth()*0.95) - (eyeDiameter/2),
                        (getY() + getWidth()*0.4) - (eyeDiameter/2),
                        eyeDiameter, eyeDiameter,
                        0, 360*64
                        );
    
                XDrawPoint(
                        xinfo.display,
                        xinfo.window,
                        ordinaryGC,
                        (getX() + getWidth()*0.95),
                        (getY() + getWidth()*0.4)
                        );
    
                // Tail 1
                XDrawLine(xinfo.display, xinfo.window,
                        ordinaryGC,
                        getX(), getY() + 0.5 * getWidth(),
                        getX() -0.4*getWidth(),
                        getY() + 0.5 * getWidth() 
                        );
    
                // Tail 2
                XDrawLine(xinfo.display, xinfo.window,
                        ordinaryGC,
                        getX(), getY() + 0.5 * getWidth(),
                        getX() -0.4*getWidth(),
                        getY() + 0.3 * getWidth() 
                        );
    
                // Tail 3
                XDrawLine(xinfo.display, xinfo.window,
                        ordinaryGC,
                        getX(), getY() + 0.5 * getWidth(),
                        getX() -0.4*getWidth(),
                        getY() + 0.7 * getWidth() 
                        );
    
                
                // Mouth 1
                XDrawLine(xinfo.display, xinfo.window,
                        ordinaryGC,
                        getX() + 0.7 * getWidth(), getY() + 0.8 * getWidth(),
                        getX() + 0.9 * getWidth(),
                        getY() + 0.7 * getWidth() 
                        );
    
                // Mouth 2
                XDrawLine(xinfo.display, xinfo.window,
                        ordinaryGC,
                        getX() + 0.7 * getWidth(), getY() + 0.8 * getWidth(),
                        getX() + 0.9 * getWidth(),
                        getY() + 0.9 * getWidth() 
                        );
    
                // Eyebrow 1  
                XDrawLine(xinfo.display, xinfo.window,
                        ordinaryGC,
                        getX() + getWidth() * 0.85, getY() + 0.3 * getWidth(),
                        getX() + 0.5*getWidth(),
                        getY() - 0.3 * getWidth() 
                        );
    
                // Eyebrow 2
                XDrawLine(xinfo.display, xinfo.window,
                        ordinaryGC,
                        getX() + getWidth() * 0.85, getY() + 0.3 * getWidth(),
                        getX() + 1.2*getWidth(),
                        getY() - 0.3 * getWidth() 
                        );
    
                // Bad flying variable to save time :(
                if (getDiameter() == 0 && flying == 0){
    
                    /*----- Slingshot Line Left -----*/
                    XDrawLine(xinfo.display, xinfo.window,
                            ordinaryGC,
                            getX(), getY() + getWidth(),
                            slingshotLeftmostInitX, slingshotLeftmostInitY
                            );
    
                    /*----- Slingshot Line Right -----*/
                    XDrawLine(xinfo.display, xinfo.window,
                            ordinaryGC,
                            getX()+getWidth(), getY() + getWidth(),
                            slingshotRightmostInitX, slingshotRightmostInitY
                            );
                }
    
                  
    
                XFlush(xinfo.display);
            }
            
    
            
            /*-----  Constructor -----*/
            Bird(int x, int y, int w, int l, int d){
                setX(x);
                setY(y);
                setWidth(w);
                setLength(l);
                setDiameter(d);
            }
    };
    
    //======================================================================
    //  Brick Class 
    //======================================================================
    
    /*----- Ordinary Brick -----*/
    
    class Brick: public Displayable {
        public:
            virtual void paint(XInfo &xinfo){
    
    
                XDrawRectangle(
                        xinfo.display, xinfo.window,
                        ordinaryGC, getX(), getY(), getWidth(), getLength()
                        );
                
                XSetForeground(xinfo.display, brickGC, 0xab916e); 
                XFillRectangle(
                        xinfo.display, xinfo.window,
                        brickGC, 
                        getX(), getY(), 
                        getWidth(), getLength()
                        );
    
                XSetForeground(xinfo.display, brickGC, 0x714226); 
                XFillRectangle(
                        xinfo.display, xinfo.window,
                        brickGC, 
                        getX()+brickShift, getY()+brickShift, 
                        getWidth()-brickShift, getLength()-brickShift
                        );
    
                /*
                 
                XDrawRectangle(
                        xinfo.display, xinfo.window, 
                        brick, (getX()+brickShift), (getY()-brickShift), getWidth(), getLength()
                        ); 
                
                //----- Line 1 -----
                XDrawLine(
                        xinfo.display, xinfo.window,
                        brick, getX(), getY(), (getX()+brickShift), (getY()-brickShift)
                        );
                //----- Line 2 -----
                XDrawLine(
                        xinfo.display, xinfo.window,
                        brick, (getX()+brickLength), getY(), (getX()+brickShift+brickLength), (getY()-brickShift)
                        );
                //----- Line 3 -----
                XDrawLine(
                        xinfo.display, xinfo.window,
                        brick, (getX()+brickLength), (getY()+brickLength), (getX()+brickShift+brickLength), (getY()-brickShift+brickLength)
                        );
                */
    
                XFlush(xinfo.display);
            }
    
            /*-----  Constructor -----*/
            Brick(int x, int y, int w, int l){
                setX(x);
                setY(y);
                setWidth(w);
                setLength(l);
            }
    };
    
    //======================================================================
    //  Ball Class
    //======================================================================
    
    class Ball: public Displayable {
        public:
            virtual void paint(XInfo &xinfo){
                int ballEyeD = 0.15 * getDiameter();
    
                XDrawArc(
                        xinfo.display, xinfo.window, 
                        ordinaryGC, getX()-(getDiameter()/2), getY()-(getDiameter()/2), 
                        getDiameter(), getDiameter(),
                        0, 360*64
                        ); 
    
                XFillArc(
                        xinfo.display, xinfo.window, 
                        ballGC, getX()-(getDiameter()/2), getY()-(getDiameter()/2), 
                        getDiameter(), getDiameter(),
                        0, 360*64
                        ); 
    
                XDrawArc(
                        xinfo.display, xinfo.window, 
                        ordinaryGC, (getX() + 0.25*getDiameter())-(getDiameter()/2), (getY()+0.3*getDiameter()-(getDiameter()/2)),
                        ballEyeD, ballEyeD,
                        0, 360*64
                        ); 
    
                XFillArc(
                        xinfo.display, xinfo.window, 
                        eyeGC, (getX() + 0.3*getDiameter())-(getDiameter()/2), (getY()+0.3*getDiameter()-(getDiameter()/2)),
                        ballEyeD, ballEyeD,
                        0, 360*64
                        ); 
    
                XDrawArc(
                        xinfo.display, xinfo.window, 
                        ordinaryGC, (getX() + 0.7*getDiameter())-(getDiameter()/2), (getY()+0.3*getDiameter()-(getDiameter()/2)),
                        ballEyeD, ballEyeD, 
                        0, 360*64
                        ); 
    
                XFillArc(
                        xinfo.display, xinfo.window, 
                        eyeGC, (getX() + 0.7*getDiameter())-(getDiameter()/2), (getY()+0.3*getDiameter()-(getDiameter()/2)),
                        ballEyeD, ballEyeD, 
                        0, 360*64
                        ); 
    
                // nose
                XDrawArc(
                        xinfo.display, xinfo.window, 
                        ordinaryGC, (getX()+0.4*getDiameter()) - getDiameter()/2, getY()+0.4*getDiameter()-(getDiameter()/2),
                        2*ballEyeD, 2*ballEyeD, 
                        0, 360*64
                        ); 
    
                XFillArc(
                        xinfo.display, xinfo.window, 
                        noseGC, 
                        (getX()+0.4*getDiameter()) - getDiameter()/2, getY()+0.4*getDiameter()-(getDiameter()/2),
                        2*ballEyeD, 2*ballEyeD, 
                        0, 360*64
                        ); 
    
    
                XDrawPoint(
                        xinfo.display,
                        xinfo.window,
                        ordinaryGC,
                        (getX()+0.50*getDiameter()) - getDiameter()/2, getY()+0.55*getDiameter()-(getDiameter()/2)
                        );
    
                XDrawPoint(
                        xinfo.display,
                        xinfo.window,
                        ordinaryGC,
                        (getX()+0.60*getDiameter()) - getDiameter()/2, getY()+0.55*getDiameter()-(getDiameter()/2)
                        );
    
    
                XFlush(xinfo.display);
            }
            
    
            /*-----  Constructor -----*/
            Ball(int x, int y, int d){
                setX(x);
                setY(y);
                setDiameter(d);
            }
    
    };
    
    
    //======================================================================
    //  Slingshot Class  
    //======================================================================
    
    class Slingshot: public Displayable {
        public:
            virtual void paint(XInfo &xinfo){
    
                // Rectangle stick
                XFillRectangle(
                        xinfo.display, xinfo.window,
                        ordinaryGC, 
                        getX(), getY(),
                        getWidth(), brickY - getY()
                        );
    
                // Rectangle leftmost 
                XFillRectangle(
                        xinfo.display, xinfo.window,
                        ordinaryGC, 
                        getX() - 0.5*getLength(), getY() - getLength(), 
                        getWidth(), getLength()
                        );
                // Rectangle rightmost
                XFillRectangle(
                        xinfo.display, xinfo.window,
                        ordinaryGC, 
                        getX() + 0.5*getLength(), getY() - getLength(),
                        getWidth(), getLength()
                        );
                
                // Rectangle bottom 
                XFillRectangle(
                        xinfo.display, xinfo.window,
                        ordinaryGC, 
                        getX() - 0.5*getLength(), getY() - getWidth(),
                        getLength(), getWidth()
                        );
    
                XFlush(xinfo.display);
            }
    
            /*-----  Constructor -----*/
            Slingshot(int x, int y, int w, int l){
                setX(x);
                setY(y);
                setWidth(w);
                setLength(l);
            }
    };
    
    
    //======================================================================
    //  Layout Line Class
    //======================================================================
    
    class Layout: public Displayable {
        public:
            virtual void paint(XInfo &xinfo){
           
                /*----- Line 1  -----*/
                XDrawLine(
                        xinfo.display, xinfo.window,
                        ordinaryGC, getX(), getY(), getX() + windowWidth, getY()
                        );
    
                /*----- Line 2  -----*/
                XDrawLine(
                        xinfo.display, xinfo.window,
                        ordinaryGC, getX(), getY() + layoutHeight, getX() + windowWidth, getY() + layoutHeight
                        );
    
    
                XFlush(xinfo.display);
            }
    
            /*-----  Constructor -----*/
            Layout(int x, int y){
                setX(x);
                setY(y);
            }
    };
    
Advertisement