Наследование: MonoBehaviour
Пример #1
1
        public Pyramid(World world, Vector2 position, int count, float density)
        {
            Vertices rect = PolygonTools.CreateRectangle(0.5f, 0.5f);
            PolygonShape shape = new PolygonShape(rect, density);

            Vector2 rowStart = position;
            rowStart.Y -= 0.5f + count * 1.1f;

            Vector2 deltaRow = new Vector2(-0.625f, 1.1f);
            const float spacing = 1.25f;

            // Physics
            _boxes = new List<Body>();

            for (int i = 0; i < count; i++)
            {
                Vector2 pos = rowStart;

                for (int j = 0; j < i + 1; j++)
                {
                    Body body = BodyFactory.CreateBody(world);
                    body.BodyType = BodyType.Dynamic;
                    body.Position = pos;
                    body.CreateFixture(shape);
                    _boxes.Add(body);

                    pos.X += spacing;
                }
                rowStart += deltaRow;
            }

            //GFX
            _box = new Sprite(ContentWrapper.PolygonTexture(rect, "Square", ContentWrapper.Blue, ContentWrapper.Gold, ContentWrapper.Black, 1f));
        }
Пример #2
1
        /// <summary>
        /// Create a new game screen. Should be done every time there is a new game.
        /// </summary>
        /// <param name="theScreenEvent"></param>
        /// <param name="contentManager"></param>
        public GameScreen(EventHandler theScreenEvent,ContentManager contentManager)
            : base(theScreenEvent)
        {
            bScoreWasAdded = false;

            this.contentManager = contentManager;
            dlDoubleJumpTimer = new DanLabel(1150, 20, 100, 50);

            //Init our intrepid hero
            csHero = new ControlledSprite();

            bg = new LayeredBackground();

            djeJumpEffect = new DoubleJumpEffect();

            altimeter = new Altimeter(); // Make a camera for the screen with an altimeter
            cCamera = new Camera(50, 100, 600, 520, altimeter);

            blocks = new List<Sprite>();
            Sprite sp = new Sprite();
            blocks.Add(sp);
            sp = new Sprite();
            blocks.Add(sp);
            sp = new Sprite();
            blocks.Add(sp);
            sp = new Sprite();
            blocks.Add(sp);
            sp = new Sprite();
            blocks.Add(sp);

            // REVIST Set up the Arcing Block Manager with the difficulty
            arcingBlockManager = new ArcingBlockManager(cCamera, blocks, contentManager, 500, 300, 150, "Sprites/block2");
        }
Пример #3
0
        /// <summary>
        /// 
        /// </summary>
        protected override void LoadContent()
        {
            Sprite road = new Sprite(Simulator.Content.Load<Texture2D>("Road"));
            road.Position = new Vector2(640, 360);

            Statistics statistics = new Statistics();
        }
Пример #4
0
 void Update()
 {
     if(Isvired)
     {
         gameObject.GetComponent<Image>().sprite = MyImage;
         switch(MyCard)
         {
             case 1:
                 MyImage = IdImage[0];
             break;
             case 2:
                 MyImage = IdImage[1];
             break;
             case 3:
                 MyImage = IdImage[2];
             break;
             case 4:
                 MyImage = IdImage[3];
             break;
             case 5:
                 MyImage = IdImage[4];
             break;
             case 6:
                 MyImage = IdImage[5];
             break;
         }
     }
     else
     {
         gameObject.GetComponent<Image>().sprite = Resources.Load("Sprites/Default",typeof(Sprite)) as Sprite;
     }
 }
Пример #5
0
    // Use this for initialization
    void Start()
    {
        string personaje = PlayerPrefs.GetString("personaje");
        int contador = 0;
        foreach (var item in sprite)
        {
            if (item.name.ToUpper() == personaje.ToUpper())
            {
                character_sprite = item;
                if (SceneManager.GetActiveScene().name != "_Menu_principal")
                {
                    GetComponent<SphereCollider>().center = colliderMod[contador];
                }
            }
            contador++;
        }

        player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        if (this != null)
        {
            SpriteRenderer player_transform = player.GetComponent<SpriteRenderer>();
            player_transform.sprite = character_sprite;
        }

        if (transform.name == "Image")
        {
            transform.GetComponent<Image>().sprite = character_sprite;
        }
    }
Пример #6
0
        public override void Render(Sprite sprite)
        {
            Rectangle rect = new Rectangle(0, 0, 1280, 720);
            if (currentFrame >= frames.Length)
            {
                if (delay > 1.25f)
                {
                    sprite.Draw(frames[frames.Length - 1], rect, ColorValue.White);
                    ColorValue color = ColorValue.White;
                    color.A = (byte)(byte.MaxValue * (1 - MathEx.Saturate((delay - 1.25f) / 1.25f)));
                    sprite.Draw(blackBg, rect, color);
                }
                else
                {
                    ColorValue color = ColorValue.White;
                    color.A = (byte)(byte.MaxValue * MathEx.Saturate(delay / 1.25f));
                    sprite.Draw(blackBg, rect, color);
                }


                delay -= 0.04f;
            }
            else
            {
                sprite.Draw(frames[currentFrame], rect, ColorValue.White);
            }
        }
Пример #7
0
	IEnumerator Flip(Sprite startImage, Sprite endImage, int cardIndex)

	{
		spriteRenderer.sprite = startImage;

		float time = 0f;
		while (time <= 2f) 
		{
			float scale = scaleCurve.Evaluate (time);
			time += Time.deltaTime / duration;

			Vector3 localScale = transform.localScale;
			localScale.x = scale;
			transform.localScale = localScale;

			if (time >= 0.5f) 
			{
				spriteRenderer.sprite = endImage;
			}

			yield return new WaitForFixedUpdate ();
		}

		if (cardIndex == -1) {
			model.ToggleFace (false);
		} 
		else 
		{
			model.cardIndex = cardIndex;
			model.ToggleFace (true);
		}
	}
Пример #8
0
 public void refresh(PLAYER_SELECT_CARD_RESULT result_type, Sprite card1, Sprite card2)
 {
     this.result_type_from_server = result_type;
     Debug.Log(this.slots.Count);
     this.slots[0].sprite = card1;
     this.slots[1].sprite = card2;
 }
Пример #9
0
	public ShieldEffect (string n, int dur, int shield, Sprite icon = null)
		: base(n, dur, 1, icon)
	{
		maxShield = shield;
		shieldAmount = maxShield;
		description = "Damage Shield " + shieldAmount.ToString();
	}
Пример #10
0
    void Start()
    {
        Texture2D texture = Resources.Load("testimg3",typeof(Texture2D)) as Texture2D;
        s	= new Sprite(texture);
        s.id	= "s";
        Stage.instance.addChild(s);
        s.x		= 300;
        s.y		= 300;
        s1	= new Sprite(texture);
        s1.id	= "s1";
        s.addChild(s1);
        s1.scaleX	= .5f;
        s1.x	= 150;
        s1.y	= 50;
        //s1.width	= 50;
        //s1.height	= 50;
        Debug.Log(s1.width+"/"+s1.height);
        s2	= new SelectableItem(texture);
        s2.id	= "s2";
        s1.addChild(s2);
        s2.x	= 250;
        s2.y	= 100;

        s3	= new Sprite(texture);
        s2.addChild(s3);
        s3.scaleX	= .3f;
        s3.scaleY	= .3f;
        s.addEventListner(MouseEvent.MOUSE_DOWN,new EventDispatcher.CallBack(clickHandler));
        s.addEventListner(GuiEvent.ENTER_FRAME,new EventDispatcher.CallBack(enterFrameHandler));
    }
Пример #11
0
        public override void LoadContent()
        {
            base.LoadContent();

            World.Gravity = Vector2.Zero;

            _border = new Border(World, Lines, Framework.GraphicsDevice);
            for (int i = 0; i < 3; i++)
            {
                _breakableCookie[i] = Framework.Content.Load<BodyContainer>("Pipeline/FarseerBreakableBody")["Cookie"].CreateBreakable(World);
                _breakableCookie[i].Strength = 120f;
                _breakableCookie[i].MainBody.Position = new Vector2(-20.33f + 15f * i, -5.33f);
            }

            _breakableSprite = new List<Sprite>();
            List<Texture2D> textures = ContentWrapper.BreakableTextureFragments(_breakableCookie[0], "Cookie");
            for (int i = 0; i < _breakableCookie[0].Parts.Count; i++)
            {
                AABB bounds;
                Transform transform;
                _breakableCookie[0].Parts[i].Body.GetTransform(out transform);
                _breakableCookie[0].Parts[i].Shape.ComputeAABB(out bounds, ref transform, 0);
                Vector2 origin = ConvertUnits.ToDisplayUnits(_breakableCookie[0].Parts[i].Body.Position - bounds.LowerBound);
                _breakableSprite.Add(new Sprite(textures[i], origin));
            }
            _completeSprite = new Sprite(ContentWrapper.GetTexture("Cookie"), Vector2.Zero);
        }
Пример #12
0
 public SpaceJunk(float x, float miny, float maxy, BitmapTexture2D texture, float scale)
 {
     Sprite = new Sprite(texture, scale);
     Sprite.UseCentreAsOrigin = true;
     Sprite.X = x;
     Sprite.Y = Program.Rand.NextSingle() * (maxy - miny) + miny;
 }
Пример #13
0
        public Vic(int newCycles, int newLines, int[][] newPipeline, int newCyclesPerSec, int hblankStart, int hblankEnd, int vblankStart, int vblankEnd)
        {
            {
                this.hblankStart = hblankStart;
                this.hblankEnd = hblankEnd;
                this.vblankStart = vblankStart;
                this.vblankEnd = vblankEnd;

                totalCycles = newCycles;
                totalLines = newLines;
                pipeline = newPipeline;
                cyclesPerSec = newCyclesPerSec;

                bufWidth = TimingBuilder_ScreenWidth(pipeline[0], hblankStart, hblankEnd);
                bufHeight = TimingBuilder_ScreenHeight(vblankStart, vblankEnd, newLines);

                buf = new int[bufWidth * bufHeight];
                bufLength = buf.Length;

                sprites = new Sprite[8];
                for (int i = 0; i < 8; i++)
                    sprites[i] = new Sprite();

                bufferC = new int[40];
                bufferG = new int[40];
            }
        }
Пример #14
0
        public DamageComponent(Sprite owner, int hitPoints, params string[] immuneTo)
        {
            // ...

            killActions.Add("stomp", s =>
                {
                    s.Graphics.State = "flattened"; // or whatever
                    s.AddTimer(seconds: 2.0f, action: sp => sp.Owner.RemoveSprite(sp));
                });

            killActions.Add("knock_off", s =>
            {
                s.Graphics.Orientation = GraphicsOrientation.UpsideDown;
                s.Velocity = GameServices.ISOStandardKnockOffVelocity;
                s.State = SpriteState.Inert;
            });

            killActions.Add("vaporize", s =>
            {
                s.Owner.RemoveSprite(s);
                s.Owner.CreateEffect("fireballPuff", s.Position);
                SoundManager.PlaySoundEffect("vaporize");
            });

            killActions.Add("default", s => s.Owner.RemoveSprite(s));
        }
Пример #15
0
        public void FireShot(
            Vector2 location,
            Vector2 velocity,
            bool playerFired)
        {
            Sprite thisShot = new Sprite(
                location,
                Texture,
                InitialFrame,
                velocity);

            thisShot.Velocity *= shotSpeed;

            for (int x = 1; x < FrameCount; x++)
            {
                thisShot.AddFrame(new Rectangle(
                    InitialFrame.X + (InitialFrame.Width * x),
                    InitialFrame.Y,
                    InitialFrame.Width,
                    InitialFrame.Height));
            }
            thisShot.CollisionRadius = CollisionRadius;
            Shots.Add(thisShot);

            if (playerFired)
            {

                SoundManager.PlayPlayerShot();
            }
            else
            {

                SoundManager.PlayEnemyShot();
            }
        }
Пример #16
0
        public TgcDrawText(Device d3dDevice)
        {
            textSprite = new Sprite(d3dDevice);

            //Fuente default
            dxFont = new Microsoft.DirectX.Direct3D.Font(d3dDevice, VERDANA_10);
        }
Пример #17
0
 public override void LoadAssets()
 {
     mouthLeft = resourceFactory.Create(this, "MouthLeft-WeNeedThisTaste").GetComponent<Sprite>();
     mouthRight = resourceFactory.Create(this, "MouthRight-WeNeedThisTaste").GetComponent<Sprite>();
     mouthLeft.visible(false);
     mouthRight.visible(false);
 }
Пример #18
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Platform"/> class.
 /// </summary>
 /// <param name="description">The platform description.</param>
 /// <param name="physicsWorld">The physics world.</param>
 /// <param name="spriteBatch">The sprite batch to use for rendering.</param>
 /// <param name="contentManager">The game's content manager.</param>
 public Platform(PlatformDescription description, ref World physicsWorld, SpriteBatch spriteBatch, ContentManager contentManager)
 {
     this.spriteOffsets = new List<Vector2>();
     this.sprite = new Sprite();
     this.InitializeAndLoadSprites(spriteBatch, contentManager, description);
     this.SetUpPhysics(ref physicsWorld, description);
 }
Пример #19
0
    public virtual void Init(Grid grid, int x, int y, float scale = 1, Sprite asset = null)
    {
        sfx = AudioManager.instance;

        container = transform.Find("Sprites");
        outline = transform.Find("Sprites/Outline").GetComponent<SpriteRenderer>();
        img = transform.Find("Sprites/Sprite").GetComponent<SpriteRenderer>();
        shadow = transform.Find("Sprites/Shadow").GetComponent<SpriteRenderer>();
        shadow.gameObject.SetActive(false);

        label = transform.Find("Label").GetComponent<TextMesh>();
        label.GetComponent<Renderer>().sortingLayerName = "Ui";
        label.gameObject.SetActive(Debug.isDebugBuild);

        this.grid = grid;
        this.x = x;
        this.y = y;
        this.asset = asset;

        this.walkable = true;

        transform.localPosition = new Vector3(x, y, 0);

        SetAsset(asset);
        SetImages(scale, Vector3.zero, 0);
        SetSortingOrder(0);

        visible = false;
        explored = false;
    }
 public void AddPoints(IEnumerable<Point> points, Sprite sprite)
 {
     foreach (Point point in points) {
         _points[point] = sprite;
         _wasChanged = true;
     }
 }
Пример #21
0
 public SpriteComponent(Sprite sprite, Texture2D texture)
 {
     Name = sprite.Id;
     Texture = texture;
     Origin = new Vector2(sprite.OriginX ?? sprite.W/2, sprite.OriginY ?? sprite.H/2);
     TextureRect = new Rectangle(sprite.X, sprite.Y, sprite.W, sprite.H);
 }
Пример #22
0
        public override DataObject Copy(Sprite parent)
        {
            var newBrick = new ChangeSizeByNBrick(parent);
            newBrick.size = size;

            return newBrick;
        }
Пример #23
0
 public static bool KolizjaDlaOkregow(Sprite a, Sprite b)
 {
     float d = Odleglosc(a.pozycja, b.pozycja);
     if ((a.teksturaPodstawowa.Height * a.wielkoscObiektu.Y + +b.teksturaPodstawowa.Height * b.wielkoscObiektu.Y) / 2 > d)
         return true;
     return false;
 }
Пример #24
0
 public Shield(string pname, float pweight, float pdefense, Sprite psprite)
 {
     itemName = pname;
     weight = pweight;
     sprite = psprite;
     defense = pdefense;
 }
Пример #25
0
 public Button(Sprite sprite)
     : base()
 {
     m_buttonSprite = sprite;
     m_transform = m_buttonSprite.Transform;
     m_aabb = new AABB(m_transform, m_buttonSprite.Dimensions);
 }
Пример #26
0
 public SpaceJunk(float x, float y, BitmapTexture2D texture, float scale)
 {
     Sprite = new Sprite(texture, scale);
     Sprite.UseCentreAsOrigin = true;
     Sprite.X = x;
     Sprite.Y = y;
 }
Пример #27
0
	public void Pointed()
	{

		flag = Resources.Load<Sprite> (EarthManager.Instance.info_flag_path);

		Image tempImage=image.GetComponent<Image> ();

		tempImage.sprite = flag;

		//tempImage.sprite.texture
		//Text temp = GetComponent<Text> ();
		Text temp = title.GetComponent<Text> ();
		temp.text = EarthManager.Instance.title;

		temp = country.GetComponent<Text> ();
		temp.text = EarthManager.Instance.country;

		temp = area.GetComponent<Text> ();
		temp.text = EarthManager.Instance.area;

		temp = contents.GetComponent<Text> ();
		temp.text = EarthManager.Instance.contents;

		InformationCanvas.SetActive (true);
	}
Пример #28
0
        public LevelMenyState(Game1 game, Sprite spriteSheet)
            : base(game)
        {
            this.spriteSheet = spriteSheet;
            font = game.Content.Load<SpriteFont>("menyFont");

            knappar = new List<Clickable>();

            Random random = new Random();

            LevelMenyExitKnapp levelExit = new LevelMenyExitKnapp(game, spriteSheet, new Vector2(410, 550));
            levelExit.Initialize();

            Level1 lv1 = new Level1(game, spriteSheet, random);
            Level1Knapp level1knapp = new Level1Knapp(game, spriteSheet, new Vector2(200, 200), lv1);
            level1knapp.Initialize();
            lv1.AddLevelButton(level1knapp);

            Level2 lv2 = new Level2(game, spriteSheet, random);
            Level2Knapp level2knapp = new Level2Knapp(game, spriteSheet, new Vector2(300, 200), lv2);
            level2knapp.Initialize();
            lv2.AddLevelButton(level2knapp);

            Level3 lv3 = new Level3(game, spriteSheet, random);
            Level3Knapp level3knapp = new Level3Knapp(game, spriteSheet, new Vector2(400, 200), lv3);
            level3knapp.Initialize();
            lv3.AddLevelButton(level3knapp);

            Level4 lv4 = new Level4(game, spriteSheet, random);
            Level4Knapp level4knapp = new Level4Knapp(game, spriteSheet, new Vector2(500, 200), lv4);
            level4knapp.Initialize();
            lv4.AddLevelButton(level4knapp);

            Level5 lv5 = new Level5(game, spriteSheet, random);
            Level5Knapp level5knapp = new Level5Knapp(game, spriteSheet, new Vector2(600, 200), lv5);
            level5knapp.Initialize();
            lv5.AddLevelButton(level5knapp);

            Level6 lv6 = new Level6(game, spriteSheet, random);
            Level6Knapp level6knapp = new Level6Knapp(game, spriteSheet, new Vector2(700, 200), lv6);
            level6knapp.Initialize();
            lv6.AddLevelButton(level6knapp);

            LevelTest lvTest = new LevelTest(game, spriteSheet, random);
            TestLevelKnapp levelTestknapp = new TestLevelKnapp(game, spriteSheet, new Vector2(800, 600), lvTest);
            levelTestknapp.Initialize();
            lvTest.AddLevelButton(levelTestknapp);

            knappar.Add(level1knapp);
            knappar.Add(level2knapp);
            knappar.Add(level3knapp);
            knappar.Add(level4knapp);
            knappar.Add(level5knapp);
            knappar.Add(level6knapp);
            knappar.Add(levelTestknapp);

            knappar.Add(levelExit);

            textTimer = 0;
        }
Пример #29
0
        //Method to Initiliaze
        public static void Instantiate()
        {
            //Initialize the buttongroup
            buttons = new ButtonGroup();

            background = new Sprite();
        }
Пример #30
0
        public override DataObject Copy(Sprite parent)
        {
            var newBrick = new ChangeYByBrick(parent);
            newBrick.yMovement = yMovement;

            return newBrick;
        }
Пример #31
0
 /// <summary>
 /// Forces display of lable if we are hooked
 /// </summary>
 /// <param name="drawArgs"></param>
 /// <param name="sprite"></param>
 /// <param name="projectedPoint"></param>
 /// <param name="color"></param>
 /// <param name="labelRectangles"></param>
 /// <param name="isMouseOver"></param>
 protected override void RenderLabel(DrawArgs drawArgs, Sprite sprite, Vector3 projectedPoint, int color, List <Rectangle> labelRectangles, bool isMouseOver)
 {
     base.RenderLabel(drawArgs, sprite, projectedPoint, color, labelRectangles, (isMouseOver || this.IsHooked));
 }
Пример #32
0
        public static LayeredTileMap FromTiledMapSave(string fileName, string contentManager)
        {
            TiledMapSave tms = TiledMapSave.FromFile(fileName);

            // Ultimately properties are tied to tiles by the tile name.
            // If a tile has no name but it has properties, those properties
            // will be lost in the conversion. Therefore, we have to add name properties.
            tms.MoveTypeToProperties();

#if DEBUG
            CheckForDuplicateTilesets(tms);
#endif

            tms.NameUnnamedTilesetTiles();
            tms.NameUnnamedObjects();


            string directory = FlatRedBall.IO.FileManager.GetDirectory(fileName);

            var rtmi = ReducedTileMapInfo.FromTiledMapSave(
                tms, 1, 0, directory, FileReferenceType.Absolute);

            var toReturn = FromReducedTileMapInfo(rtmi, contentManager, fileName);

            AddShapeCollections(toReturn, tms);

            foreach (var layer in tms.MapLayers)
            {
                var matchingLayer = toReturn.MapLayers.FirstOrDefault(item => item.Name == layer.Name);


                if (matchingLayer != null)
                {
                    if (layer is MapLayer)
                    {
                        var mapLayer = layer as MapLayer;
                        foreach (var propertyValues in mapLayer.properties)
                        {
                            matchingLayer.Properties.Add(new NamedValue
                            {
                                Name  = propertyValues.StrippedName,
                                Value = propertyValues.value,
                                Type  = propertyValues.Type
                            });
                        }

                        matchingLayer.Visible = mapLayer.visible == 1;
                    }
                }
            }


            foreach (var tileset in tms.Tilesets)
            {
                foreach (var tile in tileset.TileDictionary.Values)
                {
                    int propertyCountFromTileset = 0;

                    if (tile.properties.Count != 0)
                    {
                        // this needs a name:
                        string name = tile.properties.FirstOrDefault(item => item.StrippedName.ToLowerInvariant() == "name")?.value;
                        // todo - eventually need to copy default values from the Tileset to the tile here
                        AddPropertiesToMap(tms, toReturn.TileProperties, tile.properties, null, name);
                    }
                }
            }

            foreach (var objectLayer in tms.objectgroup)
            {
                if (objectLayer.@object != null)
                {
                    foreach (var objectInstance in objectLayer.@object)
                    {
                        TMXGlueLib.Tileset tileset   = null;
                        int propertyCountFromTileset = 0;

                        var             objectProperties  = objectInstance.properties;
                        List <property> tilesetProperties = null;
                        if (objectInstance.gid != null)
                        {
                            tileset = tms.GetTilesetForGid(objectInstance.gid.Value);
                            if (tileset.TileDictionary.ContainsKey(objectInstance.gid.Value - tileset.Firstgid))
                            {
                                tilesetProperties        = tileset.TileDictionary[objectInstance.gid.Value - tileset.Firstgid].properties;
                                propertyCountFromTileset = tilesetProperties.Count;
                            }
                        }


                        if (objectProperties.Count + propertyCountFromTileset != 0)
                        {
                            string name = objectInstance.Name;
                            // if name is null, check the properties:
                            if (string.IsNullOrEmpty(name))
                            {
                                name = objectProperties.FirstOrDefault(item => item.StrippedNameLower == "name")?.value;
                            }

                            var objectInstanceIsTile = objectInstance.gid != null;

                            if (objectInstanceIsTile)
                            {
                                AddPropertiesToMap(tms, toReturn.TileProperties, objectProperties, tilesetProperties, name);
                            }
                            else
                            {
                                AddPropertiesToMap(tms, toReturn.ShapeProperties, objectProperties, tilesetProperties, name);
                            }
                        }
                    }
                }
            }

            var tmxDirectory = FileManager.GetDirectory(fileName);

            // add image layers
            foreach (var imageLayer in tms.ImageLayers)
            {
                var imageLayerFile = tmxDirectory + imageLayer.ImageObject.Source;
                var texture        = FlatRedBallServices.Load <Microsoft.Xna.Framework.Graphics.Texture2D>(imageLayerFile);

                var newSprite = new Sprite
                {
                    Texture = texture,
                    Width   = imageLayer.ImageObject.Width,
                    Height  = imageLayer.ImageObject.Height,
                    X       = imageLayer.ImageObject.Width / 2 + imageLayer.OffsetX,
                    Y       = -imageLayer.ImageObject.Height / 2 + imageLayer.OffsetY
                };

                var mdb = new MapDrawableBatch(1, texture);
                mdb.AttachTo(toReturn, false);
                mdb.Paste(newSprite);
                mdb.Visible = imageLayer.Visible;

                toReturn.mMapLists.Add(mdb);
            }

            var animationDictionary = new Dictionary <string, AnimationChain>();

            // add animations
            foreach (var tileset in tms.Tilesets)
            {
                string tilesetImageFile = tmxDirectory + tileset.Images[0].Source;

                if (tileset.SourceDirectory != ".")
                {
                    tilesetImageFile = tmxDirectory + tileset.SourceDirectory + tileset.Images[0].Source;
                }

                var texture = FlatRedBallServices.Load <Microsoft.Xna.Framework.Graphics.Texture2D>(tilesetImageFile);

                foreach (var tile in tileset.Tiles.Where(item => item.Animation != null && item.Animation.Frames.Count != 0))
                {
                    var animation = tile.Animation;

                    var animationChain = new AnimationChain();
                    foreach (var frame in animation.Frames)
                    {
                        var animationFrame = new AnimationFrame();
                        animationFrame.FrameLength = frame.Duration / 1000.0f;
                        animationFrame.Texture     = texture;

                        int tileIdRelative = frame.TileId;
                        int globalTileId   = (int)(tileIdRelative + tileset.Firstgid);

                        int leftPixel;
                        int rightPixel;
                        int topPixel;
                        int bottomPixel;
                        TiledMapSave.GetPixelCoordinatesFromGid((uint)globalTileId, tileset, out leftPixel, out topPixel, out rightPixel, out bottomPixel);

                        animationFrame.LeftCoordinate  = MapDrawableBatch.CoordinateAdjustment + leftPixel / (float)texture.Width;
                        animationFrame.RightCoordinate = -MapDrawableBatch.CoordinateAdjustment + rightPixel / (float)texture.Width;

                        animationFrame.TopCoordinate    = MapDrawableBatch.CoordinateAdjustment + topPixel / (float)texture.Height;
                        animationFrame.BottomCoordinate = -MapDrawableBatch.CoordinateAdjustment + bottomPixel / (float)texture.Height;


                        animationChain.Add(animationFrame);
                    }

                    var property = tile.properties.FirstOrDefault(item => item.StrippedNameLower == "name");

                    if (property == null)
                    {
                        throw new InvalidOperationException(
                                  $"The tile with ID {tile.id} has an animation, but it doesn't have a Name property, which is required for animation.");
                    }
                    else
                    {
                        animationDictionary.Add(property.value, animationChain);
                    }
                }
            }

            toReturn.Animation = new LayeredTileMapAnimation(animationDictionary);

            AddTileShapeCollections(toReturn, tms);


            toReturn.MapProperties = tms.properties
                                     .Select(propertySave => new NamedValue
            {
                Name = propertySave.name, Value = propertySave.value, Type = propertySave.Type
            })
                                     .ToList();


            return(toReturn);
        }
Пример #33
0
    void Update()
    {
        Texture2D activeWheelTex = GameResources.Instance.wheelTexList [ds.warplan.blueprints[blueprintNo].wheel.getTexIndex()];

        image.sprite = Sprite.Create(activeWheelTex, new Rect(0, 0, activeWheelTex.width, activeWheelTex.height), new Vector2(0, 0), activeWheelTex.width);
    }
 public void Start()
 {
     sprite    = GetComponent <SpriteRenderer>().sprite;
     valueable = new Valueable(name, sprite, worth);
 }
Пример #35
0
        public WebOfGoo(World world, Vector2 position, float radius, int rings, int sides)
        {
            _ringBodys  = new List <List <Body> >(rings);
            _ringJoints = new List <DistanceJoint>();

            for (int i = 1; i < rings; i++)
            {
                Vertices vertices = PolygonTools.CreateCircle(i * 2.9f, sides);
                vertices.Translate(ref position);
                List <Body> bodies = new List <Body>(sides);

                //Create the first goo
                Body previous = BodyFactory.CreateCircle(world, radius, 0.2f, vertices[0]);
                previous.BodyType = BodyType.Dynamic;

                bodies.Add(previous);

                //Connect the first goo to the next
                for (int j = 1; j < vertices.Count; j++)
                {
                    Body current = BodyFactory.CreateCircle(world, radius, 0.2f, vertices[j]);
                    current.BodyType = BodyType.Dynamic;

                    DistanceJoint joint = new DistanceJoint(previous, current, Vector2.Zero, Vector2.Zero);
                    joint.Frequency    = 4.0f;
                    joint.DampingRatio = 0.5f;
                    joint.Breakpoint   = Breakpoint;
                    world.AddJoint(joint);
                    _ringJoints.Add(joint);

                    previous = current;
                    bodies.Add(current);
                }

                //Connect the first and the last goo
                DistanceJoint jointClose = new DistanceJoint(bodies[0], bodies[bodies.Count - 1], Vector2.Zero, Vector2.Zero);
                jointClose.Frequency    = 4.0f;
                jointClose.DampingRatio = 0.5f;
                jointClose.Breakpoint   = Breakpoint;
                world.AddJoint(jointClose);
                _ringJoints.Add(jointClose);

                _ringBodys.Add(bodies);
            }

            //Create an outer ring
            Vertices frame = PolygonTools.CreateCircle(rings * 2.9f - 0.9f, sides);

            frame.Translate(ref position);

            Body anchor = new Body(world, position);

            anchor.BodyType = BodyType.Static;

            //Attach the outer ring to the anchor
            for (int i = 0; i < _ringBodys[rings - 2].Count; i++)
            {
                DistanceJoint joint = new DistanceJoint(anchor, _ringBodys[rings - 2][i], frame[i], _ringBodys[rings - 2][i].Position, true);
                joint.Frequency    = 8.0f;
                joint.DampingRatio = 0.5f;
                joint.Breakpoint   = Breakpoint;
                world.AddJoint(joint);
                _ringJoints.Add(joint);
            }

            //Interconnect the rings
            for (int i = 1; i < _ringBodys.Count; i++)
            {
                for (int j = 0; j < sides; j++)
                {
                    DistanceJoint joint = new DistanceJoint(_ringBodys[i - 1][j], _ringBodys[i][j], Vector2.Zero, Vector2.Zero);
                    joint.Frequency    = 4.0f;
                    joint.DampingRatio = 0.5f;
                    joint.Breakpoint   = Breakpoint;
                    world.AddJoint(joint);
                    _ringJoints.Add(joint);
                }
            }

            _link = new Sprite(ContentWrapper.GetTexture("Link"));
            _goo  = new Sprite(ContentWrapper.GetTexture("Goo"));
        }
Пример #36
0
        public override void Load()
        {
            System.Console.WriteLine("000.000.000.000/000000000000000000");

            _harmony = new Harmony("com.slushiegoose.townofus");

            Generate.GenerateAll();

            JanitorClean          = CreateSprite("TownOfUs.Resources.Janitor.png");
            EngineerFix           = CreateSprite("TownOfUs.Resources.Engineer.png");
            SwapperSwitch         = CreateSprite("TownOfUs.Resources.SwapperSwitch.png");
            SwapperSwitchDisabled = CreateSprite("TownOfUs.Resources.SwapperSwitchDisabled.png");
            Shift        = CreateSprite("TownOfUs.Resources.Shift.png");
            Footprint    = CreateSprite("TownOfUs.Resources.Footprint.png");
            Rewind       = CreateSprite("TownOfUs.Resources.Rewind.png");
            NormalKill   = CreateSprite("TownOfUs.Resources.NormalKill.png");
            ShiftKill    = CreateSprite("TownOfUs.Resources.ShiftKill.png");
            MedicSprite  = CreateSprite("TownOfUs.Resources.Medic.png");
            SeerSprite   = CreateSprite("TownOfUs.Resources.Seer.png");
            SampleSprite = CreateSprite("TownOfUs.Resources.Sample.png");
            MorphSprite  = CreateSprite("TownOfUs.Resources.Morph.png");
            Camouflage   = CreateSprite("TownOfUs.Resources.Camouflage.png");
            Arrow        = CreateSprite("TownOfUs.Resources.Arrow.png");
            Abstain      = CreateSprite("TownOfUs.Resources.Abstain.png");
            MineSprite   = CreateSprite("TownOfUs.Resources.Mine.png");
            SwoopSprite  = CreateSprite("TownOfUs.Resources.Swoop.png");
            DouseSprite  = CreateSprite("TownOfUs.Resources.Douse.png");
            IgniteSprite = CreateSprite("TownOfUs.Resources.Ignite.png");
            ReviveSprite = CreateSprite("TownOfUs.Resources.Revive.png");
            FlashSprite  = CreateSprite("TownOfUs.Resources.Flash.png");
            ButtonSprite = CreateSprite("TownOfUs.Resources.Button.png");
            DragSprite   = CreateSprite("TownOfUs.Resources.Drag.png");
            DropSprite   = CreateSprite("TownOfUs.Resources.Drop.png");
            PolusSprite  = CreateSprite("TownOfUs.Resources.polus.gg.png");
            CycleSprite  = CreateSprite("TownOfUs.Resources.Cycle.png");
            GuessSprite  = CreateSprite("TownOfUs.Resources.Guess.png");

            PalettePatch.Load();
            ClassInjector.RegisterTypeInIl2Cpp <RainbowBehaviour>();

            // RegisterInIl2CppAttribute.Register();

            Ip   = Config.Bind("Custom", "Ipv4 or Hostname", "127.0.0.1");
            Port = Config.Bind("Custom", "Port", (ushort)22023);
            var defaultRegions = ServerManager.DefaultRegions.ToList();
            var ip             = Ip.Value;

            if (Uri.CheckHostName(Ip.Value).ToString() == "Dns")
            {
                foreach (var address in Dns.GetHostAddresses(Ip.Value))
                {
                    if (address.AddressFamily != AddressFamily.InterNetwork)
                    {
                        continue;
                    }
                    ip = address.ToString();
                    break;
                }
            }

            ServerManager.DefaultRegions = defaultRegions.ToArray();

            SceneManager.add_sceneLoaded((Action <Scene, LoadSceneMode>)((scene, loadSceneMode) =>
            {
                ModManager.Instance.ShowModStamp();
            }));

            _harmony.PatchAll();
            DirtyPatches.Initialize(_harmony);
        }
Пример #37
0
 protected override void applyPreviewSprites(ref Sprite groundSprite, ref Sprite objectSprite, ref Sprite overlaySprite)
 {
     groundSprite  = this.railSprite;
     objectSprite  = this._minecartSprites.sideEmpty;
     overlaySprite = this._minecartSprites.sideFull;
 }
Пример #38
0
 void Awake()
 {
     _image        = GetComponent <Image>();
     _normalSprite = _image.sprite;
 }
Пример #39
0
 public void SetSprite(Sprite sprite)
 {
     SpriteRenderer.sprite = sprite;
 }
Пример #40
0
        private IEnumerator Invoke(StageBuilder stageBuilder)
        {
            if (stageBuilder.stopAudio)
            {
                Audio.stopAudio(false);
            }

            if (stageBuilder.pauseBattleTheme)
            {
                Audio.pauseAudio(true);
            }

            if (stageBuilder.newcomer != null)
            {
                if (FindActor(stageBuilder.newcomer.name) != null)
                {
                    throw new UnityException(
                              "There already exists an actor in the scene with name: "
                              + stageBuilder.newcomer.name);
                }

                yield return(AddActor(stageBuilder.newcomer, stageBuilder.newcomer.side));
            }

            if (stageBuilder.expression != null)
            {
                Actor foundActor = FindActor(stageBuilder.speaker);

                if (foundActor == null)
                {
                    throw new UnityException(
                              "There exists no actor in the scene with name: "
                              + stageBuilder.speaker
                              );
                }

                foundActor.image.sprite = stageBuilder.expression;
            }

            if (stageBuilder.sfx != null)
            {
                Audio.playSfx(stageBuilder.sfx);
            }

            if (stageBuilder.background != null)
            {
                Sprite foundSprite = (Resources.Load <Sprite>("Sprites/" + stageBuilder.background));

                if (foundSprite == null)
                {
                    throw new UnityException(
                              "There exists no background " + stageBuilder.background + " in the Resources/Sprites folder, or it has not been imported as a Sprite."
                              );
                }

                yield return(changeBackground(foundSprite));
            }

            if (stageBuilder.message != null)
            {
                CutsceneSide side = CutsceneSide.None;

                if (!string.IsNullOrEmpty(stageBuilder.speaker))
                {
                    Actor foundActor = FindActor(stageBuilder.speaker);

                    if (foundActor == null)
                    {
                        throw new UnityException(
                                  "There exists no actor in the scene with name: "
                                  + stageBuilder.speaker
                                  );
                    }

                    side = foundActor.side;

                    foreach (Actor actor in actors)
                    {
                        if (actor.side != side)
                        {
                            actor.IsDark = true;
                        }
                    }
                }

                textbox.AddText(side, stageBuilder.speaker, stageBuilder.message);

                //I approximate it to take ~0.03 seconds per letter, but we do more so players can actually read
                float playTimeGuess = (float)(stageBuilder.message.Length * 0.06 + 1.5);
                currentDialogLine = this.StartStoppableCoroutine(waitForSeconds(playTimeGuess));
                yield return(currentDialogLine.WaitFor());

                foreach (Actor actor in actors)
                {
                    actor.IsDark = false;
                }
            }

            if (!string.IsNullOrEmpty(stageBuilder.leaverName))
            {
                Actor foundActor = FindActor(stageBuilder.leaverName);

                if (foundActor == null)
                {
                    throw new UnityException(
                              "There exists no actor in the scene with name: "
                              + stageBuilder.leaverName
                              );
                }
                yield return(RemoveActor(foundActor));
            }

            yield break;
        }
Пример #41
0
 public void SetFace(Sprite face)
 {
     renderers.faceRenderer.sprite = face;
 }
Пример #42
0
 public void ChangeCut(Sprite _sprite)
 {
     theCut.ChangeCut(_sprite);
 }
Пример #43
0
 public CactusGroup(Texture2D spriteSheet, bool isLarge, GroupSize size, Trex trex, Vector2 position) : base(trex, position)
 {
     IsLarge = isLarge;
     Size    = size;
     Sprite  = GenerateSprite(spriteSheet);
 }
Пример #44
0
        /// <summary>
        /// Helper function to render icon texture.  Broken out so that child classes can override this behavior.
        /// </summary>
        /// <param name="drawArgs"></param>
        /// <param name="sprite"></param>
        /// <param name="projectedPoint"></param>
        /// <param name="color">the color to render the icon</param>
        /// <param name="isMouseOver">Whether or not the mouse is over the icon</param>
        protected override void RenderTexture(DrawArgs drawArgs, Sprite sprite, Vector3 projectedPoint, int color, bool isMouseOver)
        {
            Matrix scaleTransform;
            Matrix rotationTransform;

            Matrix rotation2Transform;
            Matrix rotation3Transform;

            //Do Altitude depedent scaling for KMLIcons
            if (this.AutoScaleIcon)
            {
                float factor = 1;
                if (this.DistanceToIcon > this.MinIconZoomDistance)
                {
                    factor -= (float)((this.DistanceToIcon - this.MinIconZoomDistance) / this.DistanceToIcon);
                }
                if (factor < this.MinScaleFactor)
                {
                    factor = this.MinScaleFactor;
                }

                this.XScale = factor * ((float)this.Width / this.IconTexture.Width);
                this.YScale = factor * ((float)this.Height / this.IconTexture.Height);
            }

            //scale and rotate image
            scaleTransform = Matrix.Scaling(this.XScale, this.YScale, 0);

            if (this.IsRotated)
            {
                rotationTransform = Matrix.RotationZ((float)this.Rotation.Radians - (float)drawArgs.WorldCamera.Heading.Radians);
            }
            else
            {
                rotationTransform = Matrix.Identity;
            }

            sprite.Transform = scaleTransform * rotationTransform * Matrix.Translation(projectedPoint.X, projectedPoint.Y, 0);
            sprite.Draw(this.IconTexture.Texture,
                        new Vector3(this.IconTexture.Width >> 1, this.IconTexture.Height >> 1, 0),
                        Vector3.Zero,
                        color);

            if (this.m_iconTexture2Show)
            {
                Matrix tmpMatrix = sprite.Transform;

                if (this.Texture2IsRotatedDifferent)
                {
                    if (this.Texture2UseHeading)
                    {
                        rotation2Transform = Matrix.RotationZ((float)this.Rotation.Radians - (float)drawArgs.WorldCamera.Heading.Radians);
                    }
                    else
                    {
                        rotation2Transform = Matrix.RotationZ((float)this.Texture2Rotation.Radians - (float)drawArgs.WorldCamera.Heading.Radians);
                    }

                    sprite.Transform = scaleTransform * rotation2Transform * Matrix.Translation(projectedPoint.X, projectedPoint.Y, 0);
                }

                sprite.Draw(this.m_iconTexture2.Texture,
                            new Vector3(this.m_iconTexture2.Width >> 1, this.m_iconTexture2.Height >> 1, 0),
                            Vector3.Zero,
                            normalColor);

                // restore the main texture transform
                if (this.Texture2IsRotatedDifferent)
                {
                    sprite.Transform = tmpMatrix;
                }
            }

            if (this.m_iconTexture3Show)
            {
                if (this.Texture3IsRotatedDifferent)
                {
                    if (this.Texture3UseHeading)
                    {
                        rotation3Transform = Matrix.RotationZ((float)this.Rotation.Radians - (float)drawArgs.WorldCamera.Heading.Radians);
                    }
                    else
                    {
                        rotation3Transform = Matrix.RotationZ((float)this.Texture3Rotation.Radians - (float)drawArgs.WorldCamera.Heading.Radians);
                    }

                    sprite.Transform = scaleTransform * rotation3Transform * Matrix.Translation(projectedPoint.X, projectedPoint.Y, 0);
                }

                sprite.Draw(this.m_iconTexture3.Texture,
                            new Vector3(this.m_iconTexture3.Width >> 1, this.m_iconTexture3.Height >> 1, 0),
                            Vector3.Zero,
                            normalColor);
            }

            // Reset transform to prepare for text rendering later
            sprite.Transform = Matrix.Identity;
        }
Пример #45
0
        static void Main(string[] args)
        {
            Initialize();

            OpenConsoleWindow(4, 4, 66, 25, "Welcome to Tic Tac Toe!");

            WriteLine("Controlls in the game:");
            WriteLine();
            WriteLine("Move the mouse to controll pointer on the screen.");
            WriteLine("Press the left mouse button while inside an cell to place an X.");
            WriteLine("Press Q to restart the current game.");
            WriteLine("Press ESC to close the application.");
            WriteLine();
            WriteLine("To play, press ENTER.");

            ReadLine();
            ClearConsoleWindowArea();
            Clear();

            // Draw board
            FillRectangle(170, 189, 470, 191, Color.White);
            FillRectangle(170, 289, 470, 291, Color.White);
            FillRectangle(269, 90, 271, 390, Color.White);
            FillRectangle(170, 389, 470, 391, Color.White);
            FillRectangle(170, 89, 470, 91, Color.White);
            FillRectangle(169, 90, 171, 390, Color.White);
            FillRectangle(369, 90, 371, 390, Color.White);
            FillRectangle(469, 90, 471, 390, Color.White);

            int    MousePointerTexture = AddSpriteTexture(GetResourceBitmap("MouseCoursor.png"), System.Drawing.Color.FromArgb(0, 0, 255), true);
            bool   GameOver            = false;
            bool   Done  = false;
            Point  Point = GetMousePointer();
            Point  MouseDownPoint;
            Sprite MousePointer = CreateSprite(Point.X, Point.Y, MousePointerTexture);

            char[,] Grid = new char[, ] {
                { '-', '-', '-' },
                { '-', '-', '-' },
                { '-', '-', '-' }
            };

            OnKeyPressed += (sender, e) =>
            {
                switch (e.Character)
                {
                case '\x1b':
                    Done = true;
                    break;

                case 'q':
                case 'Q':
                    GameOver = true;
                    break;
                }
            };

            OnUpdateModel += (sender, e) =>
            {
                if (!GridControll.IsMovePossible(Grid) || GridControll.CheckWinner(Grid) != 0)
                {
                    GameOver = true;
                }
            };

            OnMouseMove += (sender, e) =>
            {
                Point = e.Position;
                MousePointer.SetPosition(Point);
            };

            OnMouseDown += (sender, e) =>
            {
                if (GameOver)
                {
                    return;
                }

                MouseDownPoint = e.Position;

                // Check if mouse is down inside an cell and if that cell is empty
                if (GridControll.PointInsideCell(MouseDownPoint, 170, 290, 270, 390) && Grid[2, 0] == '-')
                {
                    Grid[2, 0] = 'X';
                    DrawLine(180, 380, 260, 300, Color.White);
                    DrawLine(181, 380, 261, 300, Color.White);
                    DrawLine(179, 380, 259, 300, Color.White);
                    DrawLine(260, 380, 180, 300, Color.White);
                    DrawLine(261, 380, 181, 300, Color.White);
                    DrawLine(259, 380, 179, 300, Color.White);
                    Grid = Opponent.OpponentMove(Grid);
                }
                else if (GridControll.PointInsideCell(MouseDownPoint, 170, 190, 270, 290) && Grid[1, 0] == '-')
                {
                    Grid[1, 0] = 'X';
                    DrawLine(180, 280, 260, 200, Color.White);
                    DrawLine(181, 280, 261, 200, Color.White);
                    DrawLine(179, 280, 259, 200, Color.White);
                    DrawLine(260, 280, 180, 200, Color.White);
                    DrawLine(261, 280, 181, 200, Color.White);
                    DrawLine(259, 280, 179, 200, Color.White);
                    Grid = Opponent.OpponentMove(Grid);
                }
                else if (GridControll.PointInsideCell(MouseDownPoint, 170, 90, 270, 190) && Grid[0, 0] == '-')
                {
                    Grid[0, 0] = 'X';
                    DrawLine(180, 180, 260, 100, Color.White);
                    DrawLine(181, 180, 261, 100, Color.White);
                    DrawLine(179, 180, 259, 100, Color.White);
                    DrawLine(260, 180, 180, 100, Color.White);
                    DrawLine(261, 180, 181, 100, Color.White);
                    DrawLine(259, 180, 179, 100, Color.White);
                    Grid = Opponent.OpponentMove(Grid);
                }
                else if (GridControll.PointInsideCell(MouseDownPoint, 270, 290, 370, 390) && Grid[2, 1] == '-')
                {
                    Grid[2, 1] = 'X';
                    DrawLine(280, 380, 360, 300, Color.White);
                    DrawLine(281, 380, 361, 300, Color.White);
                    DrawLine(279, 380, 359, 300, Color.White);
                    DrawLine(360, 380, 280, 300, Color.White);
                    DrawLine(361, 380, 281, 300, Color.White);
                    DrawLine(359, 380, 279, 300, Color.White);
                    Grid = Opponent.OpponentMove(Grid);
                }
                else if (GridControll.PointInsideCell(MouseDownPoint, 270, 190, 370, 290) && Grid[1, 1] == '-')
                {
                    Grid[1, 1] = 'X';
                    DrawLine(280, 280, 360, 200, Color.White);
                    DrawLine(281, 280, 361, 200, Color.White);
                    DrawLine(279, 280, 359, 200, Color.White);
                    DrawLine(360, 280, 280, 200, Color.White);
                    DrawLine(361, 280, 281, 200, Color.White);
                    DrawLine(359, 280, 279, 200, Color.White);
                    Grid = Opponent.OpponentMove(Grid);
                }
                else if (GridControll.PointInsideCell(MouseDownPoint, 270, 90, 370, 190) && Grid[0, 1] == '-')
                {
                    Grid[0, 1] = 'X';
                    DrawLine(280, 180, 360, 100, Color.White);
                    DrawLine(281, 180, 361, 100, Color.White);
                    DrawLine(279, 180, 359, 100, Color.White);
                    DrawLine(360, 180, 280, 100, Color.White);
                    DrawLine(361, 180, 281, 100, Color.White);
                    DrawLine(359, 180, 279, 100, Color.White);
                    Grid = Opponent.OpponentMove(Grid);
                }
                else if (GridControll.PointInsideCell(MouseDownPoint, 370, 290, 470, 390) && Grid[2, 2] == '-')
                {
                    Grid[2, 2] = 'X';
                    DrawLine(380, 380, 460, 300, Color.White);
                    DrawLine(381, 380, 461, 300, Color.White);
                    DrawLine(379, 380, 459, 300, Color.White);
                    DrawLine(460, 380, 380, 300, Color.White);
                    DrawLine(461, 380, 381, 300, Color.White);
                    DrawLine(459, 380, 379, 300, Color.White);
                    Grid = Opponent.OpponentMove(Grid);
                }
                else if (GridControll.PointInsideCell(MouseDownPoint, 370, 190, 470, 290) && Grid[1, 2] == '-')
                {
                    Grid[1, 2] = 'X';
                    DrawLine(380, 280, 460, 200, Color.White);
                    DrawLine(381, 280, 461, 200, Color.White);
                    DrawLine(379, 280, 459, 200, Color.White);
                    DrawLine(460, 280, 380, 200, Color.White);
                    DrawLine(461, 280, 381, 200, Color.White);
                    DrawLine(459, 280, 379, 200, Color.White);
                    Grid = Opponent.OpponentMove(Grid);
                }
                else if (GridControll.PointInsideCell(MouseDownPoint, 370, 90, 470, 190) && Grid[0, 2] == '-')
                {
                    Grid[0, 2] = 'X';
                    DrawLine(380, 180, 460, 100, Color.White);
                    DrawLine(381, 180, 461, 100, Color.White);
                    DrawLine(379, 180, 459, 100, Color.White);
                    DrawLine(460, 180, 380, 100, Color.White);
                    DrawLine(461, 180, 381, 100, Color.White);
                    DrawLine(459, 180, 379, 100, Color.White);
                    Grid = Opponent.OpponentMove(Grid);
                }
            };

            while (!Done)
            {
                while (!Done && !GameOver)
                {
                    Sleep(1000);
                }

                if (GameOver)
                {
                    // Check who is the winner of the game
                    switch (GridControll.CheckWinner(Grid))
                    {
                    case 10:
                        ClearRaster();
                        OpenConsoleWindow(4, 4, 66, 25, "Game Over!");
                        WriteLine();
                        WriteLine("Your opponent (O) is the winner of the game!");
                        WriteLine();
                        WriteLine("To close application, press ESC");
                        WriteLine("To play again, press ENTER.");

                        ReadLine();
                        ClearConsoleWindowArea();
                        Clear();

                        GameOver = false;
                        Grid     = new char[, ] {
                            { '-', '-', '-' },
                            { '-', '-', '-' },
                            { '-', '-', '-' }
                        };

                        FillRectangle(170, 189, 470, 191, Color.White);
                        FillRectangle(170, 289, 470, 291, Color.White);
                        FillRectangle(269, 90, 271, 390, Color.White);
                        FillRectangle(170, 389, 470, 391, Color.White);
                        FillRectangle(170, 89, 470, 91, Color.White);
                        FillRectangle(169, 90, 171, 390, Color.White);
                        FillRectangle(369, 90, 371, 390, Color.White);
                        FillRectangle(469, 90, 471, 390, Color.White);
                        break;

                    case -10:
                        ClearRaster();
                        OpenConsoleWindow(4, 4, 66, 25, "Game Over!");
                        WriteLine();
                        WriteLine("Congratulations you (X) is the winner of the game!");
                        WriteLine();
                        WriteLine("To close application, press ESC");
                        WriteLine("To play again, press ENTER.");

                        ReadLine();
                        ClearConsoleWindowArea();
                        Clear();

                        GameOver = false;
                        Grid     = new char[, ] {
                            { '-', '-', '-' },
                            { '-', '-', '-' },
                            { '-', '-', '-' }
                        };

                        FillRectangle(170, 189, 470, 191, Color.White);
                        FillRectangle(170, 289, 470, 291, Color.White);
                        FillRectangle(269, 90, 271, 390, Color.White);
                        FillRectangle(170, 389, 470, 391, Color.White);
                        FillRectangle(170, 89, 470, 91, Color.White);
                        FillRectangle(169, 90, 171, 390, Color.White);
                        FillRectangle(369, 90, 371, 390, Color.White);
                        FillRectangle(469, 90, 471, 390, Color.White);
                        break;

                    default:
                        if (!GridControll.IsMovePossible(Grid))
                        {
                            ClearRaster();
                            OpenConsoleWindow(4, 4, 66, 25, "Game Over!");
                            WriteLine();
                            WriteLine("It's Tie between you (X) and your opponent (O).");
                            WriteLine();
                            WriteLine("To close application, press ESC");
                            WriteLine("To play again, press ENTER.");
                        }
                        else
                        {
                            ClearRaster();
                            OpenConsoleWindow(4, 4, 66, 25, "Game Over!");
                            WriteLine();
                            WriteLine("You restarted the game.");
                            WriteLine();
                            WriteLine("To close application, press ESC");
                            WriteLine("To play again, press ENTER.");
                        }

                        ReadLine();
                        ClearConsoleWindowArea();
                        Clear();

                        GameOver = false;
                        Grid     = new char[, ] {
                            { '-', '-', '-' },
                            { '-', '-', '-' },
                            { '-', '-', '-' }
                        };

                        FillRectangle(170, 189, 470, 191, Color.White);
                        FillRectangle(170, 289, 470, 291, Color.White);
                        FillRectangle(269, 90, 271, 390, Color.White);
                        FillRectangle(170, 389, 470, 391, Color.White);
                        FillRectangle(170, 89, 470, 91, Color.White);
                        FillRectangle(169, 90, 171, 390, Color.White);
                        FillRectangle(369, 90, 371, 390, Color.White);
                        FillRectangle(469, 90, 471, 390, Color.White);
                        break;
                    }
                }
            }

            Terminate();
        }
 static Sprite SpriteFromTex2D(Texture2D texture)
 {
     return(Sprite.Create(texture, new Rect(0, 0, texture.width, texture.height), new Vector2(0.5f, 0.5f)));
 }
 /// <summary>
 /// Sets the portrait sprite for an actor.
 /// This is used to immediately update the GUI control if the SetPortrait() sequencer
 /// command changes the portrait sprite.
 /// </summary>
 /// <param name="actorName">Actor name in database.</param>
 /// <param name="portraitSprite">Portrait sprite.</param>
 public virtual void SetActorPortraitSprite(string actorName, Sprite portraitSprite)
 {
     dialogueControls.npcSubtitleControls.SetActorPortraitSprite(actorName, portraitSprite);
     dialogueControls.pcSubtitleControls.SetActorPortraitSprite(actorName, portraitSprite);
     dialogueControls.responseMenuControls.SetActorPortraitSprite(actorName, portraitSprite);
 }
Пример #48
0
        public void CreatePreviewWindow(GUIFrame frame)
        {
            frame.ClearChildren();

            if (frame == null)
            {
                return;
            }

            var previewContainer = new GUILayoutGroup(new RectTransform(new Vector2(0.95f, 0.98f), frame.RectTransform, Anchor.Center))
            {
                Stretch = true
            };

            var title = new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.0f), previewContainer.RectTransform, Anchor.CenterLeft), ServerName, font: GUI.LargeFont)
            {
                ToolTip = ServerName
            };

            title.Text = ToolBox.LimitString(title.Text, title.Font, (int)(title.Rect.Width * 0.85f));

            GUITickBox favoriteTickBox = new GUITickBox(new RectTransform(new Vector2(0.15f, 0.8f), title.RectTransform, Anchor.CenterRight),
                                                        "", null, "GUIServerListFavoriteTickBox")
            {
                Selected   = Favorite,
                ToolTip    = TextManager.Get(Favorite ? "removefromfavorites" : "addtofavorites"),
                OnSelected = (tickbox) =>
                {
                    if (tickbox.Selected)
                    {
                        GameMain.ServerListScreen.AddToFavoriteServers(this);
                    }
                    else
                    {
                        GameMain.ServerListScreen.RemoveFromFavoriteServers(this);
                    }
                    tickbox.ToolTip = TextManager.Get(tickbox.Selected ? "removefromfavorites" : "addtofavorites");
                    return(true);
                }
            };

            new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.0f), previewContainer.RectTransform),
                             TextManager.AddPunctuation(':', TextManager.Get("ServerListVersion"), string.IsNullOrEmpty(GameVersion) ? TextManager.Get("Unknown") : GameVersion));

            PlayStyle playStyle = PlayStyle ?? Networking.PlayStyle.Serious;

            Sprite playStyleBannerSprite      = ServerListScreen.PlayStyleBanners[(int)playStyle];
            float  playStyleBannerAspectRatio = playStyleBannerSprite.SourceRect.Width / playStyleBannerSprite.SourceRect.Height;
            var    playStyleBanner            = new GUIImage(new RectTransform(new Point(previewContainer.Rect.Width, (int)(previewContainer.Rect.Width / playStyleBannerAspectRatio)), previewContainer.RectTransform),
                                                             playStyleBannerSprite, null, true);

            var playStyleName = new GUITextBlock(new RectTransform(new Vector2(0.15f, 0.0f), playStyleBanner.RectTransform)
            {
                RelativeOffset = new Vector2(0.01f, 0.06f)
            },
                                                 TextManager.AddPunctuation(':', TextManager.Get("serverplaystyle"), TextManager.Get("servertag." + playStyle)), textColor: Color.White,
                                                 font: GUI.SmallFont, textAlignment: Alignment.Center,
                                                 color: ServerListScreen.PlayStyleColors[(int)playStyle], style: "GUISlopedHeader");

            playStyleName.RectTransform.NonScaledSize = (playStyleName.Font.MeasureString(playStyleName.Text) + new Vector2(20, 5) * GUI.Scale).ToPoint();
            playStyleName.RectTransform.IsFixedSize   = true;

            var content = new GUILayoutGroup(new RectTransform(new Vector2(1.0f, 0.6f), previewContainer.RectTransform))
            {
                Stretch = true
            };
            // playstyle tags -----------------------------------------------------------------------------

            var playStyleContainer = new GUILayoutGroup(new RectTransform(new Vector2(1.0f, 0.15f), content.RectTransform), isHorizontal: true)
            {
                Stretch         = true,
                RelativeSpacing = 0.01f,
                CanBeFocused    = true
            };

            var playStyleTags = GetPlayStyleTags();

            foreach (string tag in playStyleTags)
            {
                if (!ServerListScreen.PlayStyleIcons.ContainsKey(tag))
                {
                    continue;
                }

                new GUIImage(new RectTransform(Vector2.One, playStyleContainer.RectTransform),
                             ServerListScreen.PlayStyleIcons[tag], scaleToFit: true)
                {
                    ToolTip = TextManager.Get("servertagdescription." + tag),
                    Color   = ServerListScreen.PlayStyleIconColors[tag]
                };
            }

            playStyleContainer.Recalculate();

            // -----------------------------------------------------------------------------

            float elementHeight = 0.075f;

            // Spacing
            new GUIFrame(new RectTransform(new Vector2(1.0f, 0.025f), content.RectTransform), style: null);

            var serverMsg = new GUIListBox(new RectTransform(new Vector2(1.0f, 0.3f), content.RectTransform))
            {
                ScrollBarVisible = true
            };
            var msgText = new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.0f), serverMsg.Content.RectTransform), ServerMessage, font: GUI.SmallFont, wrap: true)
            {
                CanBeFocused = false
            };

            serverMsg.Content.RectTransform.SizeChanged += () => { msgText.CalculateHeightFromText(); };
            msgText.RectTransform.SizeChanged           += () => { serverMsg.UpdateScrollBarSize(); };

            var gameMode = new GUITextBlock(new RectTransform(new Vector2(1.0f, elementHeight), content.RectTransform), TextManager.Get("GameMode"));

            new GUITextBlock(new RectTransform(Vector2.One, gameMode.RectTransform),
                             TextManager.Get(string.IsNullOrEmpty(GameMode) ? "Unknown" : "GameMode." + GameMode, returnNull: true) ?? GameMode,
                             textAlignment: Alignment.Right);

            /*var traitors = new GUITextBlock(new RectTransform(new Vector2(1.0f, elementHeight), bodyContainer.RectTransform), TextManager.Get("Traitors"));
             * new GUITextBlock(new RectTransform(Vector2.One, traitors.RectTransform), TextManager.Get(!TraitorsEnabled.HasValue ? "Unknown" : TraitorsEnabled.Value.ToString()), textAlignment: Alignment.Right);*/

            var subSelection = new GUITextBlock(new RectTransform(new Vector2(1.0f, elementHeight), content.RectTransform), TextManager.Get("ServerListSubSelection"));

            new GUITextBlock(new RectTransform(Vector2.One, subSelection.RectTransform), TextManager.Get(!SubSelectionMode.HasValue ? "Unknown" : SubSelectionMode.Value.ToString()), textAlignment: Alignment.Right);

            var modeSelection = new GUITextBlock(new RectTransform(new Vector2(1.0f, elementHeight), content.RectTransform), TextManager.Get("ServerListModeSelection"));

            new GUITextBlock(new RectTransform(Vector2.One, modeSelection.RectTransform), TextManager.Get(!ModeSelectionMode.HasValue ? "Unknown" : ModeSelectionMode.Value.ToString()), textAlignment: Alignment.Right);

            if (gameMode.TextSize.X + gameMode.GetChild <GUITextBlock>().TextSize.X > gameMode.Rect.Width ||
                subSelection.TextSize.X + subSelection.GetChild <GUITextBlock>().TextSize.X > subSelection.Rect.Width ||
                modeSelection.TextSize.X + modeSelection.GetChild <GUITextBlock>().TextSize.X > modeSelection.Rect.Width)
            {
                gameMode.Font = subSelection.Font = modeSelection.Font = GUI.SmallFont;
                gameMode.GetChild <GUITextBlock>().Font = subSelection.GetChild <GUITextBlock>().Font = modeSelection.GetChild <GUITextBlock>().Font = GUI.SmallFont;
            }

            var allowSpectating = new GUITickBox(new RectTransform(new Vector2(1, elementHeight), content.RectTransform), TextManager.Get("ServerListAllowSpectating"))
            {
                CanBeFocused = false
            };

            if (!AllowSpectating.HasValue)
            {
                new GUITextBlock(new RectTransform(new Vector2(0.8f, 0.8f), allowSpectating.Box.RectTransform, Anchor.Center), "?", textAlignment: Alignment.Center);
            }
            else
            {
                allowSpectating.Selected = AllowSpectating.Value;
            }

            var allowRespawn = new GUITickBox(new RectTransform(new Vector2(1, elementHeight), content.RectTransform), TextManager.Get("ServerSettingsAllowRespawning"))
            {
                CanBeFocused = false
            };

            if (!AllowRespawn.HasValue)
            {
                new GUITextBlock(new RectTransform(new Vector2(0.8f, 0.8f), allowRespawn.Box.RectTransform, Anchor.Center), "?", textAlignment: Alignment.Center);
            }
            else
            {
                allowRespawn.Selected = AllowRespawn.Value;
            }

            /*var voipEnabledTickBox = new GUITickBox(new RectTransform(new Vector2(1.0f, elementHeight), bodyContainer.RectTransform), TextManager.Get("serversettingsvoicechatenabled"))
             * {
             *  CanBeFocused = false
             * };
             * if (!VoipEnabled.HasValue)
             *  new GUITextBlock(new RectTransform(new Vector2(0.8f, 0.8f), voipEnabledTickBox.Box.RectTransform, Anchor.Center), "?", textAlignment: Alignment.Center);
             * else
             *  voipEnabledTickBox.Selected = VoipEnabled.Value;*/

            var usingWhiteList = new GUITickBox(new RectTransform(new Vector2(1, elementHeight), content.RectTransform), TextManager.Get("ServerListUsingWhitelist"))
            {
                CanBeFocused = false
            };

            if (!UsingWhiteList.HasValue)
            {
                new GUITextBlock(new RectTransform(new Vector2(0.8f, 0.8f), usingWhiteList.Box.RectTransform, Anchor.Center), "?", textAlignment: Alignment.Center);
            }
            else
            {
                usingWhiteList.Selected = UsingWhiteList.Value;
            }


            content.RectTransform.SizeChanged += () =>
            {
                GUITextBlock.AutoScaleAndNormalize(allowSpectating.TextBlock, allowRespawn.TextBlock, usingWhiteList.TextBlock);
            };

            new GUITextBlock(new RectTransform(new Vector2(1.0f, 0.0f), content.RectTransform),
                             TextManager.Get("ServerListContentPackages"), textAlignment: Alignment.Center, font: GUI.SubHeadingFont);

            var contentPackageList = new GUIListBox(new RectTransform(new Vector2(1.0f, 0.2f), content.RectTransform))
            {
                ScrollBarVisible = true
            };

            if (ContentPackageNames.Count == 0)
            {
                new GUITextBlock(new RectTransform(Vector2.One, contentPackageList.Content.RectTransform), TextManager.Get("Unknown"), textAlignment: Alignment.Center)
                {
                    CanBeFocused = false
                };
            }
            else
            {
                List <string> availableWorkshopUrls = new List <string>();
                for (int i = 0; i < ContentPackageNames.Count; i++)
                {
                    var packageText = new GUITickBox(new RectTransform(new Vector2(1.0f, 0.15f), contentPackageList.Content.RectTransform)
                    {
                        MinSize = new Point(0, 15)
                    },
                                                     ContentPackageNames[i])
                    {
                        Enabled = false
                    };
                    if (i < ContentPackageHashes.Count)
                    {
                        if (GameMain.Config.SelectedContentPackages.Any(cp => cp.MD5hash.Hash == ContentPackageHashes[i]))
                        {
                            packageText.Selected = true;
                            continue;
                        }

                        //matching content package found, but it hasn't been enabled
                        if (ContentPackage.List.Any(cp => cp.MD5hash.Hash == ContentPackageHashes[i]))
                        {
                            packageText.TextColor = GUI.Style.Orange;
                            packageText.ToolTip   = TextManager.GetWithVariable("ServerListContentPackageNotEnabled", "[contentpackage]", ContentPackageNames[i]);
                        }
                        //workshop download link found
                        else if (i < ContentPackageWorkshopUrls.Count && !string.IsNullOrEmpty(ContentPackageWorkshopUrls[i]))
                        {
                            availableWorkshopUrls.Add(ContentPackageWorkshopUrls[i]);
                            packageText.TextColor = Color.Yellow;
                            packageText.ToolTip   = TextManager.GetWithVariable("ServerListIncompatibleContentPackageWorkshopAvailable", "[contentpackage]", ContentPackageNames[i]);
                        }
                        else //no package or workshop download link found, tough luck
                        {
                            packageText.TextColor = GUI.Style.Red;
                            packageText.ToolTip   = TextManager.GetWithVariables("ServerListIncompatibleContentPackage",
                                                                                 new string[2] {
                                "[contentpackage]", "[hash]"
                            }, new string[2] {
                                ContentPackageNames[i], ContentPackageHashes[i]
                            });
                        }
                    }
                }
                if (availableWorkshopUrls.Count > 0)
                {
                    var workshopBtn = new GUIButton(new RectTransform(new Vector2(1.0f, 0.1f), content.RectTransform), TextManager.Get("ServerListSubscribeMissingPackages"))
                    {
                        ToolTip   = TextManager.Get(SteamManager.IsInitialized ? "ServerListSubscribeMissingPackagesTooltip" : "ServerListSubscribeMissingPackagesTooltipNoSteam"),
                        Enabled   = SteamManager.IsInitialized,
                        OnClicked = (btn, userdata) =>
                        {
                            GameMain.SteamWorkshopScreen.SubscribeToPackages(availableWorkshopUrls);
                            GameMain.SteamWorkshopScreen.Select();
                            return(true);
                        }
                    };
                    workshopBtn.TextBlock.AutoScaleHorizontal = true;
                }
            }

            // -----------------------------------------------------------------------------

            foreach (GUIComponent c in content.Children)
            {
                if (c is GUITextBlock textBlock)
                {
                    textBlock.Padding = Vector4.Zero;
                }
            }
        }
Пример #49
0
    public Journal(Level level) : base()
    {
        open          = new Sound("opening_journal_shop_sound.wav");
        this.level    = level;
        freshFish     = new List <Fish>();
        seaFish       = new List <Fish>();
        deepFish      = new List <Fish>();
        buttons       = new List <Button>();
        freshButtons  = new List <Button>();
        seaButtons    = new List <Button>();
        deepButtons   = new List <Button>();
        categories    = new List <Button>();
        fishSprites   = new List <Sprite>();
        freshSprites  = new List <Sprite>();
        seaSprites    = new List <Sprite>();
        deepSprites   = new List <Sprite>();
        journalButton = new Sprite("journal_icon.png");
        journalButton.SetScaleXY(0.25f);
        journalButton.SetXY(game.width - 130, game.height - 400);
        close = new Sprite("cross1.png");
        close.SetScaleXY(0.1f);
        journal = new Sprite("journalitself.png");
        journal.SetScaleXY(1.8f);
        journal.SetXY(game.width / 2 - journal.width / 2, game.height / 2 - journal.height / 2);
        close.SetXY(journal.x + journal.width - 120, journal.y + 40);
        canvas            = new Canvas(journal.width, journal.height);
        descriptionCanvas = new Canvas(550, 500);
        category          = 1;
        window            = new Sprite("window_PNG17666.png");
        window.SetScaleXY(0.9f, 0.5f);
        window.SetXY(journal.x + 660, journal.y + 120);
        window.alpha = 0f;
        AddChild(journalButton);
        AddChild(journal);
        AddChild(close);
        AddChild(canvas);
        AddChild(descriptionCanvas);
        AddChild(window);
        journal.alpha = 0f;
        close.alpha   = 0f;
        titleFont     = new Font("MV Boli", 48);
        textFont      = new Font("MV Boli", 16);
        inWindow      = false;
        for (int i = 0; i < 3; i++)
        {
            string text = "";
            switch (i)
            {
            case 0:
                text = "Fresh Water";
                break;

            case 1:
                text = "Sea Water";
                break;

            case 2:
                text = "Deep Water";
                break;
            }
            Button button = new Button(new Vec2(journal.x + 50 + 180 * i, journal.y + 50), 150, 75, text);
            categories.Add(button);
        }
    }
 public void SetTarget(Sprite image)
 {
     currentIndex = -1;
     targetImage  = image;
     StartCoroutine(DelaySwap());
 }
Пример #51
0
 public void SetBody(Sprite body)
 {
     renderers.bodyRenderer.sprite = body;
 }
 /// <summary>
 /// Sets the PC portrait name and sprite.
 /// </summary>
 /// <param name="portraitSprite">Portrait sprite.</param>
 /// <param name="portraitName">Portrait name.</param>
 public virtual void SetPCPortrait(Sprite portraitSprite, string portraitName)
 {
     dialogueControls.responseMenuControls.SetPCPortrait(portraitSprite, portraitName);
 }
Пример #53
0
        // A debug entry is received
        private void ReceivedLog(string logString, string stackTrace, LogType logType)
        {
            DebugLogEntry logEntry = new DebugLogEntry(logString, stackTrace, null);

            // Check if this entry is a duplicate (i.e. has been received before)
            int  logEntryIndex;
            bool isEntryInCollapsedEntryList = collapsedLogEntriesMap.TryGetValue(logEntry, out logEntryIndex);

            if (!isEntryInCollapsedEntryList)
            {
                // It is not a duplicate,
                // add it to the list of unique debug entries
                logEntry.logTypeSpriteRepresentation = logSpriteRepresentations[logType];

                logEntryIndex = collapsedLogEntries.Count;
                collapsedLogEntries.Add(logEntry);
                collapsedLogEntriesMap[logEntry] = logEntryIndex;
            }
            else
            {
                // It is a duplicate,
                // increment the original debug item's collapsed count
                logEntry = collapsedLogEntries[logEntryIndex];
                logEntry.count++;
            }

            // Add the index of the unique debug entry to the list
            // that stores the order the debug entries are received
            uncollapsedLogEntriesIndices.Add(logEntryIndex);

            // If this debug entry matches the current filters,
            // add it to the list of debug entries to show
            Sprite logTypeSpriteRepresentation = logEntry.logTypeSpriteRepresentation;

            if (isCollapseOn && isEntryInCollapsedEntryList)
            {
                if (isLogWindowVisible)
                {
                    recycledListView.OnCollapsedLogEntryAtIndexUpdated(logEntryIndex);
                }
            }
            else if (logFilter == DebugLogFilter.All ||
                     (logTypeSpriteRepresentation == infoLog && ((logFilter & DebugLogFilter.Info) == DebugLogFilter.Info)) ||
                     (logTypeSpriteRepresentation == warningLog && ((logFilter & DebugLogFilter.Warning) == DebugLogFilter.Warning)) ||
                     (logTypeSpriteRepresentation == errorLog && ((logFilter & DebugLogFilter.Error) == DebugLogFilter.Error)))
            {
                indicesOfListEntriesToShow.Add(logEntryIndex);

                if (isLogWindowVisible)
                {
                    recycledListView.OnLogEntriesUpdated(false);
                }
            }

            if (logType == LogType.Log)
            {
                infoEntryCount++;
                infoEntryCountText.text = infoEntryCount.ToString();

                // If debug popup is visible, notify it of the new debug entry
                if (!isLogWindowVisible)
                {
                    popupManager.NewInfoLogArrived();
                }
            }
            else if (logType == LogType.Warning)
            {
                warningEntryCount++;
                warningEntryCountText.text = warningEntryCount.ToString();

                // If debug popup is visible, notify it of the new debug entry
                if (!isLogWindowVisible)
                {
                    popupManager.NewWarningLogArrived();
                }
            }
            else
            {
                errorEntryCount++;
                errorEntryCountText.text = errorEntryCount.ToString();

                // If debug popup is visible, notify it of the new debug entry
                if (!isLogWindowVisible)
                {
                    popupManager.NewErrorLogArrived();
                }
            }
        }
Пример #54
0
 public Artifact(string name, WeaponType type, int bonus, bool isConsumable, Material material, Sprite image)
 {
     this.name         = name;
     this.type         = type;
     this.bonus        = bonus;
     this.isConsumable = isConsumable;
     this.material     = material;
     this.image        = image;
 }
Пример #55
0
 public ISEquipmentSlot()
 {
     _name = "Name";
     _icon = new Sprite();
 }
Пример #56
0
        public override void OnSuccess(Sprite sprite)
        {
            if (sprite is Aisling)
            {
                var client = (sprite as Aisling).Client;

                var action = new ServerFormat1A
                {
                    Serial = client.Aisling.Serial,
                    Number = 0x01,
                    Speed  = 20
                };


                var enemy = client.Aisling.GetInfront();

                if (enemy != null)
                {
                    foreach (var i in enemy)
                    {
                        if (i == null)
                        {
                            continue;
                        }

                        if (client.Aisling.Serial == i.Serial)
                        {
                            continue;
                        }
                        if (i is Money)
                        {
                            continue;
                        }
                        if (!i.Attackable)
                        {
                            continue;
                        }

                        //this should ensure we remove everyone from the tag list except me or group members.
                        if (i is Monster _monster)
                        {
                            if (sprite is Aisling _player)
                            {
                                if (_player.GroupParty.MembersExcludingSelfMapWide.Count > 0)
                                {
                                    var nearbyTags = _player.GroupParty.MembersExcludingSelfMapWide.ToArray();
                                    var removed    = 0;

                                    foreach (var obj in nearbyTags)
                                    {
                                        removed += _monster.TaggedAislings.RemoveWhere(n => n != obj.Serial);
                                    }
                                }
                            }
                        }

                        Target = i;
                        i.ApplyDamage(sprite, 0, true, Skill.Template.Sound, null, true);

                        if (i is Aisling)
                        {
                            if ((i as Aisling).Skulled)
                            {
                                (i as Aisling).RemoveDebuff("skulled", true);
                                (i as Aisling).Client.Revive();
                            }


                            (i as Aisling).Client.Aisling.Show(Scope.NearbyAislings,
                                                               new ServerFormat29((uint)client.Aisling.Serial, (uint)i.Serial, byte.MinValue,
                                                                                  Skill.Template.TargetAnimation, 100));
                            (i as Aisling).Client.Send(new ServerFormat08(i as Aisling, StatusFlags.All));
                        }

                        if (i is Monster || i is Mundane || i is Aisling)
                        {
                            client.Aisling.Show(Scope.NearbyAislings,
                                                new ServerFormat29((uint)client.Aisling.Serial, (uint)i.Serial,
                                                                   Skill.Template.TargetAnimation, 0, 100));
                        }
                    }
                }

                client.Aisling.Show(Scope.NearbyAislings, action);
            }
        }
Пример #57
0
 public override void SetImage(Sprite newHero_img)
 {
     gameObject.GetComponent <Image>().sprite = newHero_img;
     //hero_img = newHero_img;
 }
Пример #58
0
 public void SetCard(int id, Sprite image)
 {
     Id = id;
     GetComponent <SpriteRenderer>().sprite = image;
 }
Пример #59
0
 private GameObject changeToBlock(int x, int y, Sprite sprite)
 {
     return(changeTo(x, y, sprite, pieceScale, true));
 }
 public void GetItem(int slot, int id, Sprite new_image)                 // Acquire item from chest
 {
     inventory_list[slot].GetComponent <InventoryItems>().item_id = id;
     inventory_list[slot].GetComponent <Image>().sprite           = new_image;
 }